mw/com/impl: Internally use memory::DataTypeSizeInfo

score/mw/com/gateway/gateway_application/BUILD

@@ -112,6 +112,7 @@ cc_unit_test(
         "//score/mw/com/impl/test:dummy_instance_identifier_builder",
         "//score/mw/com/impl/test:runtime_mock_guard",
         "@googletest//:gtest",
+        "@score_baselibs//score/memory:data_type_size_info",
         "@score_baselibs//score/result",
     ],
 )

score/mw/com/gateway/gateway_application/gateway_application_test.cpp

@@ -12,6 +12,7 @@
  *******************************************************************************/
 #include "score/mw/com/gateway/gateway_application/gateway_application.h"
 
+#include "score/memory/data_type_size_info.h"
 #include "score/mw/com/gateway/gateway_application/configuration/gateway_configuration.h"
 #include "score/mw/com/gateway/gateway_application/gateway_error.h"
 #include "score/mw/com/gateway/transport_layer/transport_mock.h"
@@ -701,7 +702,7 @@ class GatewayApplicationFlowTest : public ::testing::Test
         // --- Generic skeleton event binding factory: yields a fresh mock per event --------------
         ON_CALL(generic_skeleton_event_binding_factory_mock_, Create(::testing::_, ::testing::_, ::testing::_))
             .WillByDefault(::testing::Invoke(
-                [this](impl::SkeletonBase&, std::string_view event_name, const impl::DataTypeMetaInfo&)
+                [this](impl::SkeletonBase&, std::string_view event_name, const score::memory::DataTypeSizeInfo&)
                     -> score::Result<std::unique_ptr<impl::GenericSkeletonEventBinding>> {
                     auto mock = std::make_unique<::testing::NiceMock<impl::mock_binding::GenericSkeletonEvent>>();
                     ON_CALL(*mock, SetReceiveHandlerRegistrationChangedHandler(::testing::_))
@@ -1065,9 +1066,9 @@ TEST_F(GatewayApplicationFlowTest, ProvideServiceCreatesSkeletonRegistersCallbac
     // Given a whitelisted ("svc/a") provide request with one event whose binding expects exactly one
     // subscription-callback registration.
     ON_CALL(generic_skeleton_event_binding_factory_mock_, Create(::testing::_, ::testing::_, ::testing::_))
-        .WillByDefault(
-            ::testing::Invoke([this](impl::SkeletonBase&, std::string_view event_name, const impl::DataTypeMetaInfo&)
-                                  -> score::Result<std::unique_ptr<impl::GenericSkeletonEventBinding>> {
+        .WillByDefault(::testing::Invoke(
+            [this](impl::SkeletonBase&, std::string_view event_name, const score::memory::DataTypeSizeInfo&)
+                -> score::Result<std::unique_ptr<impl::GenericSkeletonEventBinding>> {
                 auto mock = std::make_unique<::testing::NiceMock<impl::mock_binding::GenericSkeletonEvent>>();
                 EXPECT_CALL(*mock, SetReceiveHandlerRegistrationChangedHandler(::testing::_))
                     .WillOnce(::testing::Return(score::Result<void>{}));
@@ -1203,9 +1204,9 @@ TEST_F(GatewayApplicationFlowTest, ProvideServiceSetReceiveHandlerRegistrationFa
 {
     // Given the skeleton event rejects the receive-handler-registration-changed handler
     ON_CALL(generic_skeleton_event_binding_factory_mock_, Create(::testing::_, ::testing::_, ::testing::_))
-        .WillByDefault(
-            ::testing::Invoke([this](impl::SkeletonBase&, std::string_view event_name, const impl::DataTypeMetaInfo&)
-                                  -> score::Result<std::unique_ptr<impl::GenericSkeletonEventBinding>> {
+        .WillByDefault(::testing::Invoke(
+            [this](impl::SkeletonBase&, std::string_view event_name, const score::memory::DataTypeSizeInfo&)
+                -> score::Result<std::unique_ptr<impl::GenericSkeletonEventBinding>> {
                 auto mock = std::make_unique<::testing::NiceMock<impl::mock_binding::GenericSkeletonEvent>>();
                 ON_CALL(*mock, SetReceiveHandlerRegistrationChangedHandler(::testing::_))
                     .WillByDefault(

score/mw/com/impl/BUILD

@@ -164,6 +164,7 @@ cc_library(
         "//score/mw/com/impl/plumbing",
         "//score/mw/com/impl/plumbing:generic_skeleton_event_binding_factory",
         "@score_baselibs//score/language/futurecpp",
+        "@score_baselibs//score/memory:data_type_size_info",
     ],
     tags = ["FFI"],
     visibility = [
@@ -237,6 +238,11 @@ cc_library(
         "//score/mw/com:__pkg__",
         "//score/mw/com/impl:__subpackages__",
     ],
+    deps = [
+        ":error",
+        "@score_baselibs//score/memory:data_type_size_info",
+        "@score_baselibs//score/result",
+    ],
 )
 
 cc_library(
@@ -905,20 +911,6 @@ cc_library(
     ],
 )
 
-cc_library(
-    name = "i_generic_skeleton_event_binding_factory",
-    hdrs = ["i_generic_skeleton_event_binding_factory.h"],
-    features = COMPILER_WARNING_FEATURES,
-    tags = ["FFI"],
-    visibility = [
-        "//score/mw/com/impl:__subpackages__",
-    ],
-    deps = [
-        ":generic_skeleton_event_binding",
-        ":skeleton_base",
-    ],
-)
-
 cc_library(
     name = "event_receive_handler",
     srcs = ["event_receive_handler.cpp"],
@@ -1243,6 +1235,16 @@ cc_unit_test(
     deps = [":method_type"],
 )
 
+cc_unit_test(
+    name = "data_type_meta_info_test",
+    srcs = ["data_type_meta_info_test.cpp"],
+    deps = [
+        ":data_type_meta_info",
+        ":error",
+        "@score_baselibs//score/result",
+    ],
+)
+
 cc_unit_test(
     name = "sample_reference_tracker_test",
     srcs = ["sample_reference_tracker_test.cpp"],

score/mw/com/impl/bindings/lola/BUILD

@@ -241,7 +241,7 @@ cc_library(
     ],
     deps = [
         "//score/memory/shared",
-        "//score/mw/com/impl:data_type_meta_info",
+        "@score_baselibs//score/memory:data_type_size_info",
     ],
 )
 

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

@@ -13,8 +13,8 @@
 #ifndef SCORE_MW_COM_IMPL_BINDINGS_LOLA_EVENT_META_INFO_H
 #define SCORE_MW_COM_IMPL_BINDINGS_LOLA_EVENT_META_INFO_H
 
+#include "score/memory/data_type_size_info.h"
 #include "score/memory/shared/offset_ptr.h"
-#include "score/mw/com/impl/data_type_meta_info.h"
 
 namespace score::mw::com::impl::lola
 {
@@ -26,7 +26,7 @@ namespace score::mw::com::impl::lola
 class EventMetaInfo
 {
   public:
-    EventMetaInfo(const impl::DataTypeMetaInfo data_type_info,
+    EventMetaInfo(const memory::DataTypeSizeInfo data_type_info,
                   const memory::shared::OffsetPtr<void> event_slots_raw_array)
         : data_type_info_(data_type_info), event_slots_raw_array_(event_slots_raw_array)
     {
@@ -36,7 +36,7 @@ class EventMetaInfo
     // be private.". There are no class invariants to maintain which could be violated by directly accessing member
     // variables.
     // coverity[autosar_cpp14_m11_0_1_violation]
-    impl::DataTypeMetaInfo data_type_info_;
+    memory::DataTypeSizeInfo data_type_info_;
     // coverity[autosar_cpp14_m11_0_1_violation]
     memory::shared::OffsetPtr<void> event_slots_raw_array_;
 };

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

@@ -79,7 +79,7 @@ inline Result<std::size_t> GenericProxyEvent::GetNewSamples(Callback&& receiver,
 
 std::size_t GenericProxyEvent::GetSampleSize() const noexcept
 {
-    return meta_info_.data_type_info_.size;
+    return meta_info_.data_type_info_.Size();
 }
 
 bool GenericProxyEvent::HasSerializedFormat() const noexcept
@@ -140,8 +140,8 @@ Result<std::size_t> GenericProxyEvent::GetNewSamplesImpl(Callback&& receiver, Tr
 
     auto& event_data_control_local = proxy_event_common_.GetConsumerEventDataControlLocal();
 
-    const std::size_t sample_size = meta_info_.data_type_info_.size;
-    const std::size_t sample_alignment = meta_info_.data_type_info_.alignment;
+    const std::size_t sample_size = meta_info_.data_type_info_.Size();
+    const std::size_t sample_alignment = meta_info_.data_type_info_.Alignment();
     const std::size_t aligned_size =
         memory::shared::CalculateAlignedSize(sample_size, static_cast<std::size_t>(sample_alignment));
 

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

@@ -127,11 +127,12 @@ TEST_F(LolaGenericProxyEventDeathTest, OverflowWhenCalculatingRawEventsSlotsArra
 
     // Given a mocked SkeletonEvent whose metainfo stores a size which will lead to an overflow when calculating the raw
     // event slot array size
-    const auto align_of = fake_data_->data_storage->events_metainfo_.at(element_fq_id_).data_type_info_.alignment;
+    const auto align_of = fake_data_->data_storage->events_metainfo_.at(element_fq_id_).data_type_info_.Alignment();
 
-    // Subtract the align of from the max size to prevent an overflow when calculating the aligned size
-    fake_data_->data_storage->events_metainfo_.at(element_fq_id_).data_type_info_.size =
-        std::numeric_limits<std::size_t>::max() - align_of;
+    // Subtract the align of from the max size to prevent an overflow when calculating the aligned size.
+    // Keep the size a multiple of the alignment to satisfy the DataTypeSizeInfo invariant.
+    fake_data_->data_storage->events_metainfo_.at(element_fq_id_).data_type_info_ =
+        score::memory::DataTypeSizeInfo{(std::numeric_limits<std::size_t>::max() / align_of) * align_of, align_of};
 
     // and given a GenericProxyEvent which has subscribed
     WithAGenericProxyEvent(element_fq_id_, event_name_);

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

@@ -11,21 +11,21 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 #include "score/mw/com/impl/bindings/lola/generic_skeleton_event.h"
-#include "score/memory/shared/pointer_arithmetic_util.h"
 #include "score/mw/com/impl/bindings/lola/skeleton.h"
 #include "score/mw/com/impl/bindings/lola/skeleton_event.h"
 #include "score/mw/com/impl/bindings/lola/skeleton_event_properties.h"
 #include "score/mw/com/impl/runtime.h"
 #include "score/mw/com/impl/sample_allocatee_guard.h"
-#include "score/mw/com/impl/skeleton_event_binding.h"
+
+#include "score/memory/shared/pointer_arithmetic_util.h"
 
 namespace score::mw::com::impl::lola
 {
 GenericSkeletonEvent::GenericSkeletonEvent(Skeleton& parent,
                                            const std::string_view event_name,
                                            const SkeletonEventProperties& event_properties,
                                            const ElementFqId& element_fq_id,
-                                           const DataTypeMetaInfo& size_info,
+                                           const memory::DataTypeSizeInfo& size_info,
                                            impl::tracing::SkeletonEventTracingData tracing_data)
     : size_info_{size_info},
       event_data_storage_{nullptr},
@@ -38,8 +38,8 @@
     const auto registration_result =
         skeleton_event_common_.GetParent().RegisterGeneric(skeleton_event_common_.GetElementFQId(),
                                                            skeleton_event_common_.GetEventProperties(),
-                                                           size_info_.size,
-                                                           size_info_.alignment);
+                                                           size_info_.Size(),
+                                                           size_info_.Alignment());
 
     event_data_storage_ = static_cast<std::uint8_t*>(registration_result.type_erased_event_data_storage_ptr);
 
@@ -66,14 +66,14 @@
     const auto slot_index = allocated_slot_result.value();
 
     // Calculate the exact slot spacing based on alignment padding
-    const auto aligned_size = memory::shared::CalculateAlignedSize(size_info_.size, size_info_.alignment);
+    const auto aligned_size = memory::shared::CalculateAlignedSize(size_info_.Size(), size_info_.Alignment());
     std::size_t offset = static_cast<std::size_t>(slot_index) * aligned_size;
     void* data_ptr = static_cast<void*>(memory::shared::AddOffsetToPointer(event_data_storage_, offset));
 
     // The ConsumerEventDataControlLocalView stored inside SampleAllocateePtr is only used by the send-tracing path.
-    //  Tracing is a diagnostic/monitoring feature with no safety requirement, so QM is sufficient.
-    //  GetConsumerEventDataControlLocalView(kASIL_B) is a separate code path introduced specifically for
-    //  GetLatestSample().
+    // Tracing is a diagnostic/monitoring feature with no safety requirement, so QM is sufficient.
+    // GetConsumerEventDataControlLocalView(kASIL_B) is a separate code path introduced specifically for
+    // GetLatestSample().
     auto lola_ptr = lola::SampleAllocateePtr<void>(
         data_ptr,
         skeleton_event_common_.GetEventDataControlComposite(),
@@ -89,7 +89,7 @@
 
 std::pair<size_t, size_t> GenericSkeletonEvent::GetSizeInfo() const noexcept
 {
-    return {size_info_.size, size_info_.alignment};
+    return {size_info_.Size(), size_info_.Alignment()};
 }
 
 void GenericSkeletonEvent::PrepareStopOffer() noexcept

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

@@ -18,10 +18,11 @@
 #include "score/mw/com/impl/bindings/lola/event_data_storage.h"
 #include "score/mw/com/impl/bindings/lola/skeleton_event_common.h"
 #include "score/mw/com/impl/bindings/lola/skeleton_event_properties.h"
-#include "score/mw/com/impl/data_type_meta_info.h"
 #include "score/mw/com/impl/generic_skeleton_event_binding.h"
 #include "score/mw/com/impl/sample_allocatee_guard.h"
 
+#include "score/memory/data_type_size_info.h"
+
 #include <optional>
 
 namespace score::mw::com::impl::lola
@@ -38,7 +39,7 @@ class GenericSkeletonEvent : public GenericSkeletonEventBinding
                          const std::string_view event_name,
                          const SkeletonEventProperties& event_properties,
                          const ElementFqId& element_fq_id,
-                         const DataTypeMetaInfo& size_info,
+                         const memory::DataTypeSizeInfo& size_info,
                          impl::tracing::SkeletonEventTracingData tracing_data = {});
 
     Result<void> Send(score::mw::com::impl::SampleAllocateePtr<void> sample) noexcept override;
@@ -59,7 +60,7 @@ class GenericSkeletonEvent : public GenericSkeletonEventBinding
 
     std::size_t GetMaxSize() const noexcept override
     {
-        return size_info_.size;
+        return size_info_.Size();
     }
 
     /// \brief Set callback, to get notified, when either the 1st event-notification has been registered or the last
@@ -80,7 +81,7 @@ class GenericSkeletonEvent : public GenericSkeletonEventBinding
     }
 
   private:
-    DataTypeMetaInfo size_info_;
+    memory::DataTypeSizeInfo size_info_;
     std::uint8_t* event_data_storage_;
     SkeletonEventCommon<void> skeleton_event_common_;
 };

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

@@ -54,7 +54,7 @@ class GenericSkeletonEventFixture : public SkeletonEventFixture
     }
 
     std::unique_ptr<GenericSkeletonEvent> generic_skeleton_event_;
-    const DataTypeMetaInfo size_info_{10U, 8U};
+    const memory::DataTypeSizeInfo size_info_{16U, 8U};
 };
 
 // TODO: Fix requirement linkage as soon as requirements are matured in S-CORE.
@@ -123,8 +123,8 @@ TEST_F(GenericSkeletonEventFixture, GetSizeInfo)
     auto size_info = generic_skeleton_event_->GetSizeInfo();
 
     // Then we get the correct size and alignment
-    EXPECT_EQ(size_info.first, size_info_.size);
-    EXPECT_EQ(size_info.second, size_info_.alignment);
+    EXPECT_EQ(size_info.first, size_info_.Size());
+    EXPECT_EQ(size_info.second, size_info_.Alignment());
 }
 
 // Test: GetMaxSize
@@ -148,7 +148,7 @@ TEST_F(GenericSkeletonEventFixture, GetMaxSize)
     auto max_size = generic_skeleton_event_->GetMaxSize();
 
     // Then we get the correct size
-    EXPECT_EQ(max_size, size_info_.size);
+    EXPECT_EQ(max_size, size_info_.Size());
 }
 
 // Test: PrepareOffer

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

@@ -160,9 +160,9 @@ inline const std::uint8_t* ProxyEvent<SampleType>::InitialiseEventSlotsRawArray(
     const void* const event_slots_raw_array = meta_info_.event_slots_raw_array_.get(event_slots_raw_array_size);
 
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION_PRD_MESSAGE(nullptr != event_slots_raw_array, "Null event slot array");
-    SCORE_LANGUAGE_FUTURECPP_PRECONDITION_PRD_MESSAGE(meta_info_.data_type_info_.size == sizeof(SampleType),
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION_PRD_MESSAGE(meta_info_.data_type_info_.Size() == sizeof(SampleType),
                                                       "Event sample size mismatch");
-    SCORE_LANGUAGE_FUTURECPP_PRECONDITION_PRD_MESSAGE(meta_info_.data_type_info_.alignment == alignof(SampleType),
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION_PRD_MESSAGE(meta_info_.data_type_info_.Alignment() == alignof(SampleType),
                                                       "Event sample alignment mismatch");
 
     return static_cast<const std::uint8_t*>(event_slots_raw_array);

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

@@ -661,8 +661,8 @@ TEST_F(ProxyGetEventMetaInfoFixture, GetEventMetaInfoWillReturnDataForEventThatW
     const auto event_meta_info = proxy_->GetEventMetaInfo(kDummyElementFqId);
 
     // Then the EventMetaInfo will contain the meta info of the SkeletonEvent type
-    EXPECT_EQ(event_meta_info.data_type_info_.size, sizeof(ProxyMockedMemoryFixture::SampleType));
-    EXPECT_EQ(event_meta_info.data_type_info_.alignment, alignof(ProxyMockedMemoryFixture::SampleType));
+    EXPECT_EQ(event_meta_info.data_type_info_.Size(), sizeof(ProxyMockedMemoryFixture::SampleType));
+    EXPECT_EQ(event_meta_info.data_type_info_.Alignment(), alignof(ProxyMockedMemoryFixture::SampleType));
 }
 
 using ProxyGetEventMetaInfoDeathTest = ProxyGetEventMetaInfoFixture;

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

@@ -224,7 +224,7 @@ void* SkeletonMemoryManager::CreateGenericEventDataInCreatedSharedMemory(
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(inserted_data_slots.second,
                                                 "Couldn't register/emplace event-storage in data-section.");
 
-    const DataTypeMetaInfo sample_meta_info{sample_size, static_cast<std::uint8_t>(sample_alignment)};
+    const memory::DataTypeSizeInfo sample_meta_info{sample_size, sample_alignment};
     void* const event_data_raw_array = data_storage->data();
 
     auto inserted_meta_info =
@@ -247,8 +247,8 @@ void* SkeletonMemoryManager::RetrieveGenericEventDataFromOpenedSharedMemory(
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(event_meta_info_it != storage_->events_metainfo_.cend(),
                                                 "Could not find element fq id in meta info map");
 
-    const auto sample_size = event_meta_info_it->second.data_type_info_.size;
-    const auto sample_alignment = event_meta_info_it->second.data_type_info_.alignment;
+    const auto sample_size = event_meta_info_it->second.data_type_info_.Size();
+    const auto sample_alignment = event_meta_info_it->second.data_type_info_.Alignment();
     const auto aligned_sample_size =
         memory::shared::CalculateAlignedSize(sample_size, static_cast<std::size_t>(sample_alignment));
     const auto total_event_slots_size = safe_math::Multiply<safe_math::ReturnMode::kAbortOnError>(
@@ -743,7 +743,7 @@ EventControl& SkeletonMemoryManager::EmplaceEventControl(const QualityType asil_
 }
 
 EventMetaInfo& SkeletonMemoryManager::EmplaceEventMetaInfo(const ElementFqId element_fq_id,
-                                                           const DataTypeMetaInfo& sample_meta_info,
+                                                           const memory::DataTypeSizeInfo& sample_meta_info,
                                                            void* type_erased_event_data_storage)
 {
     auto inserted_meta_info =