Replaced score::cpp with std

score/mw/com/impl/bindings/lola/skeleton_event.h

@@ -33,7 +33,6 @@
 #include "score/mw/log/logging.h"
 
 #include <score/assert.hpp>
-#include <score/optional.hpp>
 #include <score/utility.hpp>
 
 #include <atomic>
@@ -85,11 +84,11 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
     /// \brief Sends a value by _copy_ towards a consumer. It will allocate the necessary space and then copy the value
     /// into Shared Memory.
     Result<void> Send(const SampleType& value,
-                      score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>
+                      std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>
                           send_trace_callback) noexcept override;
 
     Result<void> Send(impl::SampleAllocateePtr<SampleType> sample,
-                      score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>
+                      std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>
                           send_trace_callback) noexcept override;
 
     Result<impl::SampleAllocateePtr<SampleType>> Allocate() noexcept override;
@@ -134,7 +133,7 @@ template <typename SampleType>
 // coverity[autosar_cpp14_a15_5_3_violation : FALSE]
 Result<void> SkeletonEvent<SampleType>::Send(
     const SampleType& value,
-    score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> send_trace_callback) noexcept
+    std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> send_trace_callback) noexcept
 {
     auto allocated_slot_result = Allocate();
     if (!(allocated_slot_result.has_value()))
@@ -150,7 +149,7 @@ Result<void> SkeletonEvent<SampleType>::Send(
 template <typename SampleType>
 Result<void> SkeletonEvent<SampleType>::Send(
     impl::SampleAllocateePtr<SampleType> sample,
-    score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> send_trace_callback) noexcept
+    std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> send_trace_callback) noexcept
 {
     const auto send_result = skeleton_event_common_.Send(sample);
     if (!send_result.has_value())

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

@@ -416,7 +416,7 @@ TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
     auto* first_lola_ptr = first_view.template As<lola::SampleAllocateePtr<test::TestSampleType>>();
     auto first_slot_index = first_lola_ptr->GetReferencedSlot();
 
-    auto first_send_result = skeleton_event_->Send(std::move(first_allocated_slot), score::cpp::nullopt);
+    auto first_send_result = skeleton_event_->Send(std::move(first_allocated_slot), std::nullopt);
     ASSERT_TRUE(first_send_result.has_value());
 
     // THEN its timestamp should be a valid, non-zero value
@@ -435,7 +435,7 @@ TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
     const impl::SampleAllocateePtrView<test::TestSampleType> second_view{second_allocated_slot};
     auto* second_lola_ptr = second_view.template As<lola::SampleAllocateePtr<test::TestSampleType>>();
     auto second_slot_index = second_lola_ptr->GetReferencedSlot();
-    auto second_send_result = skeleton_event_->Send(std::move(second_allocated_slot), score::cpp::nullopt);
+    auto second_send_result = skeleton_event_->Send(std::move(second_allocated_slot), std::nullopt);
     ASSERT_TRUE(second_send_result.has_value());
 
     // THEN its timestamp should be exactly one greater than the first one

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

@@ -226,7 +226,7 @@ void TracingRuntime::CacheFileDescriptorForReregisteringShmObject(
     }
 }
 
-score::cpp::optional<std::pair<memory::shared::ISharedMemoryResource::FileDescriptor, void*>>
+std::optional<std::pair<memory::shared::ISharedMemoryResource::FileDescriptor, void*>>
 TracingRuntime::GetCachedFileDescriptorForReregisteringShmObject(
     const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view) const noexcept
 {
@@ -282,20 +282,22 @@ analysis::tracing::ServiceInstanceElement TracingRuntime::ConvertToTracingServic
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(lola_service_type_deployment != nullptr);
 
     using ServiceInstanceElement = analysis::tracing::ServiceInstanceElement;
-    ServiceInstanceElement output_service_instance_element{};
     const auto service_element_type =
         service_element_instance_identifier_view.service_element_identifier_view.service_element_type;
     const auto service_element_name =
         service_element_instance_identifier_view.service_element_identifier_view.service_element_name;
+
+    // Compute element variant using the new type-safe StdVariantType interface
+    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});
-        output_service_instance_element.element_id = static_cast<ServiceInstanceElement::EventIdType>(lola_event_id);
+        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});
-        output_service_instance_element.element_id = static_cast<ServiceInstanceElement::FieldIdType>(lola_field_id);
+        element_variant = ServiceInstanceElement::FieldId{lola_field_id};
     }
     else
     {
@@ -304,7 +306,8 @@ analysis::tracing::ServiceInstanceElement TracingRuntime::ConvertToTracingServic
         std::terminate();
     }
 
-    output_service_instance_element.service_id =
+    // Compute other fields
+    const auto service_id =
         static_cast<ServiceInstanceElement::ServiceIdType>(lola_service_type_deployment->service_id_);
 
     if (!lola_service_instance_deployment->instance_id_.has_value())
@@ -313,16 +316,18 @@ analysis::tracing::ServiceInstanceElement TracingRuntime::ConvertToTracingServic
             << "Tracing should not be done on service element without configured instance ID. Terminating.";
         std::terminate();
     }
-    output_service_instance_element.instance_id = static_cast<ServiceInstanceElement::InstanceIdType>(
+    const auto instance_id = static_cast<ServiceInstanceElement::InstanceIdType>(
         lola_service_instance_deployment->instance_id_.value().GetId());
 
     const auto version = ServiceIdentifierTypeView{service_identifier}.GetVersion();
-    output_service_instance_element.major_version = ServiceVersionTypeView{version}.getMajor();
-    output_service_instance_element.minor_version = ServiceVersionTypeView{version}.getMinor();
-    return output_service_instance_element;
+    const auto major_version = ServiceVersionTypeView{version}.getMajor();
+    const auto minor_version = ServiceVersionTypeView{version}.getMinor();
+
+    // Construct using the new StdVariantType constructor
+    return ServiceInstanceElement{service_id, major_version, minor_version, instance_id, element_variant};
 }
 
-score::cpp::optional<analysis::tracing::ShmObjectHandle> TracingRuntime::GetShmObjectHandle(
+std::optional<analysis::tracing::ShmObjectHandle> TracingRuntime::GetShmObjectHandle(
     const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view) const noexcept
 {
     impl::tracing::ServiceElementInstanceIdentifierView lolaBindingSpecificIdentifier =
@@ -336,7 +341,7 @@ score::cpp::optional<analysis::tracing::ShmObjectHandle> TracingRuntime::GetShmO
     return find_result->second.first;
 }
 
-score::cpp::optional<void*> TracingRuntime::GetShmRegionStartAddress(
+std::optional<void*> TracingRuntime::GetShmRegionStartAddress(
     const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view) const noexcept
 {
     impl::tracing::ServiceElementInstanceIdentifierView simplifiedIdentifier =

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

@@ -23,8 +23,6 @@
 #include "score/language/safecpp/scoped_function/scope.h"
 #include "score/memory/shared/i_shared_memory_resource.h"
 
-#include <score/optional.hpp>
-
 #include <cstddef>
 #include <mutex>
 #include <optional>
@@ -102,20 +100,19 @@ class TracingRuntime : public impl::tracing::IBindingTracingRuntime
     void UnregisterShmObject(const impl::tracing::ServiceElementInstanceIdentifierView&
                                  service_element_instance_identifier_view) noexcept override;
 
-    score::cpp::optional<analysis::tracing::ShmObjectHandle> GetShmObjectHandle(
+    std::optional<analysis::tracing::ShmObjectHandle> GetShmObjectHandle(
         const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view)
         const noexcept override;
 
-    score::cpp::optional<void*> GetShmRegionStartAddress(
-        const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view)
-        const noexcept override;
+    std::optional<void*> GetShmRegionStartAddress(const impl::tracing::ServiceElementInstanceIdentifierView&
+                                                      service_element_instance_identifier_view) const noexcept override;
 
     void CacheFileDescriptorForReregisteringShmObject(
         const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view,
         const memory::shared::ISharedMemoryResource::FileDescriptor shm_file_descriptor,
         void* const shm_memory_start_address) noexcept override;
 
-    score::cpp::optional<std::pair<memory::shared::ISharedMemoryResource::FileDescriptor, void*>>
+    std::optional<std::pair<memory::shared::ISharedMemoryResource::FileDescriptor, void*>>
     GetCachedFileDescriptorForReregisteringShmObject(
         const impl::tracing::ServiceElementInstanceIdentifierView& service_element_instance_identifier_view)
         const noexcept override;
@@ -151,7 +148,7 @@ class TracingRuntime : public impl::tracing::IBindingTracingRuntime
         // Suppress "AUTOSAR C++14 M11-0-1" rule findings. This rule states: "Member data in non-POD class types shall
         // be private.". We need these data elements to be organized into a coherent organized data structure.
         // coverity[autosar_cpp14_m11_0_1_violation]
-        score::cpp::optional<impl::tracing::TypeErasedSamplePtr> sample_ptr;
+        std::optional<impl::tracing::TypeErasedSamplePtr> sample_ptr;
         // coverity[autosar_cpp14_m11_0_1_violation]
         std::mutex mutex;
     };
@@ -170,7 +167,7 @@ class TracingRuntime : public impl::tracing::IBindingTracingRuntime
         -> std::optional<TraceContextId>;
 
     const Configuration& configuration_;
-    score::cpp::optional<analysis::tracing::TraceClientId> trace_client_id_;
+    std::optional<analysis::tracing::TraceClientId> trace_client_id_;
     bool data_loss_flag_;
 
     /// \brief Array of type erased sample pointers containing one element per service element that registers itself via

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

@@ -1035,13 +1035,13 @@ TEST_F(TracingRuntimeConvertToTracingServiceInstanceElementFixture,
         major_version_number_,
         minor_version_number_,
         static_cast<ServiceInstanceElement::InstanceIdType>(instance_id_),
-        static_cast<ServiceInstanceElement::EventIdType>(event_id_)};
+        ServiceInstanceElement::StdVariantType{ServiceInstanceElement::EventId{event_id_}}};
     const ServiceInstanceElement expected_service_instance_element_field{
         static_cast<ServiceInstanceElement::ServiceIdType>(service_id_),
         major_version_number_,
         minor_version_number_,
         static_cast<ServiceInstanceElement::InstanceIdType>(instance_id_),
-        static_cast<ServiceInstanceElement::FieldIdType>(field_id_)};
+        ServiceInstanceElement::StdVariantType{ServiceInstanceElement::FieldId{field_id_}}};
 
     // Given a TracingRuntimeObject with a provided configuration object
     TracingRuntime tracing_runtime{kNumberOfTotalConfiguredTracingSlots, configuration};

score/mw/com/impl/bindings/mock_binding/skeleton_event.h

@@ -39,13 +39,12 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
   public:
     MOCK_METHOD(Result<void>,
                 Send,
-                (const SampleType& value,
-                 score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
+                (const SampleType& value, std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<void>,
                 Send,
                 (score::mw::com::impl::SampleAllocateePtr<SampleType> sample,
-                 score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
+                 std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<score::mw::com::impl::SampleAllocateePtr<SampleType>>, Allocate, (), (noexcept, override));
     MOCK_METHOD(Result<void>, PrepareOffer, (), (noexcept, override));
@@ -69,13 +68,13 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     ~SkeletonEventFacade() override = default;
     Result<void> Send(
         const SampleType& value,
-        score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> callback) noexcept override
+        std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> callback) noexcept override
     {
         return skeleton_event_.Send(value, std::move(callback));
     };
     Result<void> Send(
         score::mw::com::impl::SampleAllocateePtr<SampleType> sample,
-        score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> callback) noexcept override
+        std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback> callback) noexcept override
     {
         return skeleton_event_.Send(std::move(sample), std::move(callback));
     }

score/mw/com/impl/bindings/mock_binding/tracing/tracing_runtime.h

@@ -36,11 +36,11 @@ class TracingRuntime : public IBindingTracingRuntime
                 UnregisterShmObject,
                 (const impl::tracing::ServiceElementInstanceIdentifierView&),
                 (noexcept, override));
-    MOCK_METHOD(score::cpp::optional<analysis::tracing::ShmObjectHandle>,
+    MOCK_METHOD(std::optional<analysis::tracing::ShmObjectHandle>,
                 GetShmObjectHandle,
                 (const impl::tracing::ServiceElementInstanceIdentifierView&),
                 (const, noexcept, override));
-    MOCK_METHOD(score::cpp::optional<void*>,
+    MOCK_METHOD(std::optional<void*>,
                 GetShmRegionStartAddress,
                 (const impl::tracing::ServiceElementInstanceIdentifierView&),
                 (const, noexcept, override));
@@ -50,7 +50,7 @@ class TracingRuntime : public IBindingTracingRuntime
                  memory::shared::ISharedMemoryResource::FileDescriptor,
                  void*),
                 (noexcept, override));
-    MOCK_METHOD((score::cpp::optional<std::pair<memory::shared::ISharedMemoryResource::FileDescriptor, void*>>),
+    MOCK_METHOD((std::optional<std::pair<memory::shared::ISharedMemoryResource::FileDescriptor, void*>>),
                 GetCachedFileDescriptorForReregisteringShmObject,
                 (const impl::tracing::ServiceElementInstanceIdentifierView&),
                 (const, noexcept, override));

score/mw/com/impl/skeleton_event_binding.h

@@ -20,10 +20,10 @@
 #include "score/result/result.h"
 
 #include <score/callback.hpp>
-#include <score/optional.hpp>
 
 #include <cstddef>
 #include <cstdint>
+#include <optional>
 
 namespace score::mw::com::impl
 {
@@ -78,12 +78,12 @@ class SkeletonEventBinding : public SkeletonEventBindingBase
 
     /// \brief SampleType is allocated by the user and provided to the middleware to send
     /// \return On failure, returns an error code.
-    virtual Result<void> Send(const SampleType&, score::cpp::optional<SendTraceCallback>) noexcept = 0;
+    virtual Result<void> Send(const SampleType&, std::optional<SendTraceCallback>) noexcept = 0;
 
     /// \brief SampleType is previously allocated by middleware and provided by the user to indicate that he is finished
     /// filling the provided pointer with live.
     /// \return On failure, returns an error code.
-    virtual Result<void> Send(SampleAllocateePtr<SampleType>, score::cpp::optional<SendTraceCallback>) noexcept = 0;
+    virtual Result<void> Send(SampleAllocateePtr<SampleType>, std::optional<SendTraceCallback>) noexcept = 0;
 
     /// \brief Allocates memory for SampleType for the user to fill it. This is especially necessary for Zero-Copy
     /// implementations.

score/mw/com/impl/skeleton_event_binding_test.cpp

@@ -32,15 +32,13 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
         return {};
     }
     void PrepareStopOffer() noexcept override {}
-    Result<void> Send(
-        const SampleType&,
-        score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
+    Result<void> Send(const SampleType&,
+                      std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
     {
         return {};
     }
-    Result<void> Send(
-        SampleAllocateePtr<SampleType>,
-        score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
+    Result<void> Send(SampleAllocateePtr<SampleType>,
+                      std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
     {
         return {};
     }

score/mw/com/impl/tracing/common_event_tracing.cpp

@@ -46,7 +46,7 @@ Result<void> TraceData(const ServiceElementInstanceIdentifierView service_elemen
                        const TracingRuntime::TracePointType trace_point,
                        const BindingType binding_type,
                        const std::pair<const void*, std::size_t>& local_data_chunk,
-                       const score::cpp::optional<TracingRuntime::TracePointDataId> trace_point_data_id) noexcept
+                       const std::optional<TracingRuntime::TracePointDataId> trace_point_data_id) noexcept
 {
     auto* const tracing_runtime = impl::Runtime::getInstance().GetTracingRuntime();
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(tracing_runtime != nullptr);

score/mw/com/impl/tracing/common_event_tracing.h

@@ -18,9 +18,8 @@
 #include "score/mw/com/impl/tracing/configuration/service_element_instance_identifier_view.h"
 #include "score/mw/com/impl/tracing/tracing_runtime.h"
 
-#include <score/optional.hpp>
-
 #include <cstdint>
+#include <optional>
 #include <string_view>
 #include <utility>
 
@@ -39,7 +38,7 @@ Result<void> TraceData(const ServiceElementInstanceIdentifierView service_elemen
                        const TracingRuntime::TracePointType trace_point,
                        const BindingType binding_type,
                        const std::pair<const void*, std::size_t>& local_data_chunk = {nullptr, 0U},
-                       const score::cpp::optional<TracingRuntime::TracePointDataId> trace_point_data_id = {}) noexcept;
+                       const std::optional<TracingRuntime::TracePointDataId> trace_point_data_id = {}) noexcept;
 
 Result<void> TraceShmData(const BindingType binding_type,
                           const ServiceElementTracingData service_element_tracing_data,

score/mw/com/impl/tracing/common_event_tracing_test.cpp

@@ -22,13 +22,13 @@
 
 #include "score/result/result.h"
 
-#include <score/optional.hpp>
 #include <score/utility.hpp>
 
 #include <gtest/gtest.h>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <string_view>
 #include <utility>
 
@@ -119,7 +119,7 @@ TEST_F(CommonEventTracingLocalTraceDataFixture, CallingTraceDataWillDispatchToBi
                 Trace(binding_type_,
                       service_element_instance_identifier_view_,
                       trace_point_,
-                      score::cpp::optional<TracingRuntime::TracePointDataId>{trace_point_data_id_},
+                      std::optional<TracingRuntime::TracePointDataId>{trace_point_data_id_},
                       local_data_chunk_.first,
                       local_data_chunk_.second));