Use StringComparisonAdaptor as key to allow lookup with string_view

score/mw/com/impl/bindings/lola/proxy.cpp

@@ -268,7 +268,7 @@ std::atomic<ProxyInstanceIdentifier::ProxyInstanceCounter> Proxy::current_proxy_
 ElementFqId Proxy::EventNameToElementFqIdConverter::Convert(const std::string_view event_name) const noexcept
 {
     const auto& events = events_.get();
-    const auto event_it = events.find(std::string{event_name});
+    const auto event_it = events.find(event_name);
 
     std::stringstream sstream{};
     sstream << "Event name " << event_name << " does not exists in event map.";
@@ -620,8 +620,8 @@ score::Result<void> Proxy::SetupMethods()
         std::lock_guard lock{proxy_method_registration_mutex_};
         for (const auto& [field_name, field_instance_deployment] : lola_service_instance_deployment.fields_)
         {
-            const auto field_id =
-                GetServiceElementId<ServiceElementType::FIELD>(lola_service_type_deployment, field_name);
+            const auto field_id = GetServiceElementId<ServiceElementType::FIELD>(lola_service_type_deployment,
+                                                                                 field_name.GetAsStringView());
 
             if ((kUseGetIfAvailable) && (proxy_methods_.count({field_id, MethodType::kGet}) != 0U))
             {
@@ -769,8 +769,8 @@ Proxy::GetMethodIdAndQueueSizeForEnabledMethods() const
     {
         if (method_deployment.enabled_.has_value() && method_deployment.enabled_.value())
         {
-            const auto method_id =
-                GetServiceElementId<ServiceElementType::METHOD>(lola_service_type_deployment, method_name);
+            const auto method_id = GetServiceElementId<ServiceElementType::METHOD>(lola_service_type_deployment,
+                                                                                   method_name.GetAsStringView());
 
             SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(
                 method_deployment.queue_size_.has_value(),

score/mw/com/impl/bindings/lola/tracing/tracing_runtime.cpp

@@ -291,12 +291,12 @@ analysis::tracing::ServiceInstanceElement TracingRuntime::ConvertToTracingServic
     ServiceInstanceElement::StdVariantType element_variant;
     if (service_element_type == impl::ServiceElementType::EVENT)
     {
-        const auto lola_event_id = lola_service_type_deployment->events_.at(std::string{service_element_name});
+        const auto lola_event_id = lola_service_type_deployment->events_.at(service_element_name);
         element_variant = ServiceInstanceElement::EventId{lola_event_id};
     }
     else if (service_element_type == impl::ServiceElementType::FIELD)
     {
-        const auto lola_field_id = lola_service_type_deployment->fields_.at(std::string{service_element_name});
+        const auto lola_field_id = lola_service_type_deployment->fields_.at(service_element_name);
         element_variant = ServiceInstanceElement::FieldId{lola_field_id};
     }
     else

score/mw/com/impl/configuration/BUILD

@@ -235,6 +235,7 @@ cc_library(
         "//score/mw/com/impl:service_element_type",
         "@score_baselibs//score/json",
         "@score_baselibs//score/language/futurecpp",
+        "@score_baselibs//score/memory:string_comparison_adaptor",
     ],
 )
 
@@ -351,6 +352,7 @@ cc_library(
         ":configuration_common_resources",
         "//score/mw/com/impl:service_element_type",
         "@score_baselibs//score/json",
+        "@score_baselibs//score/memory:string_comparison_adaptor",
     ],
 )
 

score/mw/com/impl/configuration/binding_service_type_deployment.h

@@ -16,6 +16,7 @@
 #include "score/mw/com/impl/service_element_type.h"
 
 #include "score/json/json_parser.h"
+#include "score/memory/string_comparison_adaptor.h"
 
 #include <cstdint>
 #include <string>
@@ -28,9 +29,9 @@ template <typename EventIdType, typename FieldIdType, typename MethodIdType, typ
 class BindingServiceTypeDeployment
 {
   public:
-    using EventIdMapping = std::unordered_map<std::string, EventIdType>;
-    using FieldIdMapping = std::unordered_map<std::string, FieldIdType>;
-    using MethodIdMapping = std::unordered_map<std::string, MethodIdType>;
+    using EventIdMapping = std::unordered_map<score::memory::StringComparisonAdaptor, EventIdType>;
+    using FieldIdMapping = std::unordered_map<score::memory::StringComparisonAdaptor, FieldIdType>;
+    using MethodIdMapping = std::unordered_map<score::memory::StringComparisonAdaptor, MethodIdType>;
     using ServiceId = ServiceIdType;
 
     explicit BindingServiceTypeDeployment(const score::json::Object& json_object) noexcept;
@@ -80,7 +81,7 @@ template <ServiceElementType service_element_type,
           typename ServiceIdType>
 auto GetServiceElementId(const BindingServiceTypeDeployment<EventIdType, FieldIdType, MethodIdType, ServiceIdType>&
                              binding_service_type_deployment,
-                         const std::string& service_element_name);
+                         std::string_view service_element_name);
 
 template <typename EventIdType, typename FieldIdType, typename MethodIdType, typename ServiceIdType>
 bool operator==(

score/mw/com/impl/configuration/binding_service_type_deployment_impl.h

@@ -15,6 +15,7 @@
 
 #include "score/json/json_parser.h"
 
+#include "score/memory/string_comparison_adaptor.h"
 #include "score/mw/com/impl/configuration/configuration_common_resources.h"
 #include "score/mw/com/impl/service_element_type.h"
 
@@ -67,11 +68,11 @@ template <typename ServiceElementIdType>
 // be sure json.As<T> call will return a value. See Ticket-177855.
 // coverity[autosar_cpp14_a15_5_3_violation]
 auto ConvertJsonToServiceElementIdMap(const json::Object& json_object, const std::string_view key) noexcept
-    -> std::unordered_map<std::string, ServiceElementIdType>
+    -> std::unordered_map<score::memory::StringComparisonAdaptor, ServiceElementIdType>
 {
     const auto& service_element_json = GetValueFromJson<json::Object>(json_object, key);
 
-    std::unordered_map<std::string, ServiceElementIdType> service_element_map{};
+    std::unordered_map<score::memory::StringComparisonAdaptor, ServiceElementIdType> service_element_map{};
     for (auto& it : service_element_json)
     {
         const auto event_name_view{it.first.GetAsStringView()};
@@ -167,7 +168,7 @@ template <ServiceElementType service_element_type,
           typename ServiceIdType>
 auto GetServiceElementId(const BindingServiceTypeDeployment<EventIdType, FieldIdType, MethodIdType, ServiceIdType>&
                              binding_service_type_deployment,
-                         const std::string& service_element_name)
+                         const std::string_view service_element_name)
 {
     static_assert(service_element_type != ServiceElementType::INVALID);
 

score/mw/com/impl/configuration/config_parser.cpp

@@ -1385,7 +1385,8 @@ void CrosscheckServiceInstancesToTypes(const Configuration& config)
             if (search == serviceTypeDeployment.events_.cend())
             {
                 ::score::mw::log::LogFatal("lola")
-                    << "Service instance " << service_instance.first << "event" << eventInstanceElement.first
+                    << "Service instance " << service_instance.first << "event"
+                    << eventInstanceElement.first.GetAsStringView()
                     << "refers to an event, which doesn't exist in the referenced service type ("
                     << service_instance.second.service_.ToString() << "). This is invalid, terminating";
                 SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(false);
@@ -1399,7 +1400,8 @@ void CrosscheckServiceInstancesToTypes(const Configuration& config)
             if (search == serviceTypeDeployment.fields_.cend())
             {
                 ::score::mw::log::LogFatal("lola")
-                    << "Service instance " << service_instance.first << "field" << fieldInstanceElement.first
+                    << "Service instance " << service_instance.first << "field"
+                    << fieldInstanceElement.first.GetAsStringView()
                     << "refers to a field, which doesn't exist in the referenced service type ("
                     << service_instance.second.service_.ToString() << "). This is invalid, terminating";
                 SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(false);

score/mw/com/impl/configuration/lola_service_instance_deployment.cpp

@@ -254,17 +254,17 @@ score::json::Object LolaServiceInstanceDeployment::Serialize() const noexcept
     return json_object;
 }
 
-bool LolaServiceInstanceDeployment::ContainsEvent(const std::string& event_name) const noexcept
+bool LolaServiceInstanceDeployment::ContainsEvent(const std::string_view event_name) const noexcept
 {
     return (events_.find(event_name) != events_.end());
 }
 
-bool LolaServiceInstanceDeployment::ContainsField(const std::string& field_name) const noexcept
+bool LolaServiceInstanceDeployment::ContainsField(const std::string_view field_name) const noexcept
 {
     return (fields_.find(field_name) != fields_.end());
 }
 
-bool LolaServiceInstanceDeployment::ContainsMethod(const std::string& method_name) const noexcept
+bool LolaServiceInstanceDeployment::ContainsMethod(const std::string_view method_name) const noexcept
 {
     return (methods_.find(method_name) != methods_.end());
 }

score/mw/com/impl/configuration/lola_service_instance_deployment.h

@@ -18,11 +18,12 @@
 #include "score/mw/com/impl/configuration/lola_method_instance_deployment.h"
 #include "score/mw/com/impl/configuration/lola_service_instance_id.h"
 #include "score/mw/com/impl/configuration/quality_type.h"
-
 #include "score/mw/com/impl/service_element_type.h"
 
 #include "score/mw/log/logging.h"
 
+#include "score/memory/string_comparison_adaptor.h"
+
 #include <score/assert.hpp>
 #include <optional>
 
@@ -38,9 +39,12 @@ namespace score::mw::com::impl
 class LolaServiceInstanceDeployment
 {
   public:
-    using EventInstanceMapping = std::unordered_map<std::string, LolaEventInstanceDeployment>;
-    using FieldInstanceMapping = std::unordered_map<std::string, LolaFieldInstanceDeployment>;
-    using MethodInstanceMapping = std::unordered_map<std::string, LolaMethodInstanceDeployment>;
+    using EventInstanceMapping =
+        std::unordered_map<score::memory::StringComparisonAdaptor, LolaEventInstanceDeployment>;
+    using FieldInstanceMapping =
+        std::unordered_map<score::memory::StringComparisonAdaptor, LolaFieldInstanceDeployment>;
+    using MethodInstanceMapping =
+        std::unordered_map<score::memory::StringComparisonAdaptor, LolaMethodInstanceDeployment>;
 
     LolaServiceInstanceDeployment() = default;
     explicit LolaServiceInstanceDeployment(const score::json::Object& json_object) noexcept;
@@ -86,9 +90,9 @@ class LolaServiceInstanceDeployment
     bool inter_vm_forwarded_{false};
 
     score::json::Object Serialize() const noexcept;
-    bool ContainsEvent(const std::string& event_name) const noexcept;
-    bool ContainsField(const std::string& field_name) const noexcept;
-    bool ContainsMethod(const std::string& method_name) const noexcept;
+    bool ContainsEvent(std::string_view event_name) const noexcept;
+    bool ContainsField(std::string_view field_name) const noexcept;
+    bool ContainsMethod(std::string_view method_name) const noexcept;
 };
 
 bool areCompatible(const LolaServiceInstanceDeployment& lhs, const LolaServiceInstanceDeployment& rhs) noexcept;
@@ -97,7 +101,7 @@ bool operator<(const LolaServiceInstanceDeployment& lhs, const LolaServiceInstan
 
 template <ServiceElementType service_element_type>
 const auto& GetServiceElementInstanceDeployment(const LolaServiceInstanceDeployment& lola_service_instance_deployment,
-                                                const std::string& event_name)
+                                                const std::string_view event_name)
 {
     static_assert(service_element_type != ServiceElementType::INVALID);
 

score/mw/com/impl/generic_proxy.cpp

@@ -49,7 +49,7 @@ std::vector<std::string_view> GetEventNameList(const InstanceIdentifier& identif
             ReturnType event_names;
             for (const auto& event : deployment.events_)
             {
-                event_names.push_back(std::string_view{event.first});
+                event_names.push_back(event.first.GetAsStringView());
             }
             return event_names;
         },

score/mw/com/impl/generic_skeleton.cpp

@@ -38,10 +38,10 @@ std::string_view GetEventName(const InstanceIdentifier& identifier, std::string_
 
     auto visitor = score::cpp::overload(
         [&](const LolaServiceTypeDeployment& deployment) -> std::string_view {
-            const auto it = deployment.events_.find(std::string{search_name});
+            const auto it = deployment.events_.find(search_name);
             if (it != deployment.events_.end())
             {
-                return it->first;  // Return the stable address of the Key from the Config Map
+                return it->first.GetAsStringView();  // Return the stable address of the Key from the Config Map
             }
             return {};
         },

score/mw/com/impl/plumbing/lola_proxy_element_building_blocks.cpp

@@ -34,18 +34,17 @@ lola::ElementFqId GetElementFqId(const HandleType& handle,
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(lola_instance_id != nullptr,
                                                 "ServiceInstanceId does not contain lola binding.");
 
-    const std::string service_element_name_str{service_element_name};
-    const LolaServiceElementId element_id{[element_type, &lola_type_deployment, &service_element_name_str]() {
+    const LolaServiceElementId element_id{[element_type, &lola_type_deployment, &service_element_name]() {
         switch (element_type)
         {
             case ServiceElementType::EVENT:
-                return GetServiceElementId<ServiceElementType::EVENT>(lola_type_deployment, service_element_name_str);
+                return GetServiceElementId<ServiceElementType::EVENT>(lola_type_deployment, service_element_name);
                 break;
             case ServiceElementType::FIELD:
-                return GetServiceElementId<ServiceElementType::FIELD>(lola_type_deployment, service_element_name_str);
+                return GetServiceElementId<ServiceElementType::FIELD>(lola_type_deployment, service_element_name);
                 break;
             case ServiceElementType::METHOD:
-                return GetServiceElementId<ServiceElementType::METHOD>(lola_type_deployment, service_element_name_str);
+                return GetServiceElementId<ServiceElementType::METHOD>(lola_type_deployment, service_element_name);
                 break;
             case ServiceElementType::INVALID:
             default:

score/mw/com/impl/plumbing/proxy_event_binding_factory_impl.cpp

@@ -52,7 +52,7 @@ std::unique_ptr<GenericProxyEventBinding> GenericProxyEventBindingFactoryImpl::C
             }
 
             const auto element_fq_id =
-                GetElementFqId(parent.GetHandle(), lola_type_deployment, std::string{event_name}, service_element_type);
+                GetElementFqId(parent.GetHandle(), lola_type_deployment, event_name, service_element_type);
             return std::make_unique<lola::GenericProxyEvent>(*lola_proxy, element_fq_id, event_name);
         },
         [](const score::cpp::blank&) noexcept -> ReturnType {

score/mw/com/impl/plumbing/proxy_event_binding_factory_impl.h

@@ -58,7 +58,7 @@ std::unique_ptr<ProxyServiceElementBinding> CreateProxyEvent(ProxyBase& parent,
                                                         "ServiceInstanceId does not contain lola binding.");
 
             const auto lola_service_element_id =
-                GetServiceElementId<element_type>(lola_type_deployment, std::string{service_element_name});
+                GetServiceElementId<element_type>(lola_type_deployment, service_element_name);
             const lola::ElementFqId element_fq_id{lola_type_deployment.service_id_,
                                                   lola_service_element_id,
                                                   lola_service_instance_id->GetId(),

score/mw/com/impl/plumbing/proxy_method_binding_factory_impl.cpp

@@ -22,7 +22,7 @@ namespace detail
 {
 
 LolaMethodInstanceDeployment::QueueSize GetQueueSize(HandleType parent_handle,
-                                                     const std::string& method_name_str,
+                                                     const std::string_view method_name_str,
                                                      MethodType method_type)
 {
     // Field Get/Set methods are synchronous and always use a fixed queue size of 1.

score/mw/com/impl/plumbing/proxy_method_binding_factory_impl.h

@@ -41,12 +41,12 @@ namespace detail
 {
 
 LolaMethodInstanceDeployment::QueueSize GetQueueSize(HandleType parent_handle,
-                                                     const std::string& method_name_str,
+                                                     std::string_view method_name_str,
                                                      MethodType method_type);
 
 template <typename ReturnType, typename... ArgTypes>
 lola::TypeErasedCallQueue::TypeErasedElementInfo GetTypeErasedElementInfo(HandleType parent_handle,
-                                                                          const std::string& method_name_str,
+                                                                          std::string_view method_name_str,
                                                                           MethodType method_type)
 {
     std::optional<memory::DataTypeSizeInfo> in_arg_type_info{std::nullopt};
@@ -101,12 +101,12 @@ std::unique_ptr<ProxyMethodBinding> ProxyMethodBindingFactoryImpl<ReturnType(Arg
     const std::string_view method_name,
     MethodType method_type) noexcept
 {
-    auto method_name_str = std::string{method_name};
+    auto method_name_str = method_name;
 
     using LambdaReturnType = std::unique_ptr<ProxyMethodBinding>;
 
     auto deployment_info_visitor = score::cpp::overload(
-        [&parent_handle, parent_binding, &method_name_str, method_type](
+        [&parent_handle, parent_binding, method_name_str, method_type](
             const LolaServiceTypeDeployment& lola_type_deployment) -> LambdaReturnType {
             auto* const lola_proxy = dynamic_cast<lola::Proxy*>(parent_binding);
             if (lola_proxy == nullptr)

score/mw/com/impl/plumbing/skeleton_method_binding_factory_impl.cpp

@@ -52,13 +52,11 @@ auto SkeletonMethodBindingFactoryImpl::Create(const InstanceIdentifier& instance
         LolaServiceElementId lola_element_id{};
         if ((method_type == MethodType::kGet) || (method_type == MethodType::kSet))
         {
-            lola_element_id =
-                GetServiceElementId<ServiceElementType::FIELD>(lola_type_deployment, std::string{method_name});
+            lola_element_id = GetServiceElementId<ServiceElementType::FIELD>(lola_type_deployment, method_name);
         }
         else
         {
-            lola_element_id =
-                GetServiceElementId<ServiceElementType::METHOD>(lola_type_deployment, std::string{method_name});
+            lola_element_id = GetServiceElementId<ServiceElementType::METHOD>(lola_type_deployment, method_name);
         }
 
         lola::UniqueMethodIdentifier unique_method_identifier{lola_element_id, method_type};