From 448e0e12f6d7945509acf0c21bd7a3859e74bd8e Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Mon, 16 Mar 2026 16:35:46 +0100
Subject: [PATCH 1/7] mw/com/impl: adds GetLatestSlot function

- Adds GetLatestSlot function to EventDataControlComposite

Issue: SWP-249517
---
 .../lola/event_data_control_composite.cpp     | 95 +++++++++++++++++++
 .../lola/event_data_control_composite.h       |  4 +
 .../event_data_control_composite_test.cpp     | 67 +++++++++++++
 3 files changed, 166 insertions(+)

diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
index f124db121..c894fe256 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
@@ -38,6 +38,54 @@ EventDataControlCompositeImpl<AtomicIndirectorType>::EventDataControlCompositeIm
     CheckForValidDataControls();
 }
 
+template <template <class> class AtomicIndirectorType>
+score::cpp::optional<SlotIndexType>
+EventDataControlCompositeImpl<AtomicIndirectorType>::FindLatestReadableSlotIndex(const EventDataControl& control) const noexcept
+{
+    EventSlotStatus::EventTimeStamp latest_time_stamp{1U};
+    score::cpp::optional<SlotIndexType> latest_slot_index{};
+
+    for (SlotIndexType slot_index = 0U;
+         // Suppress "AUTOSAR C++14 A4-7-1" rule finding. This rule states: "An integer expression shall not lead
+         // to loss.". As the maximum number of slots is std::uint16_t, so there is no case for a data loss here.
+         // coverity[autosar_cpp14_a4_7_1_violation]
+         slot_index < static_cast<SlotIndexType>(control.state_slots_.size());
+         ++slot_index)
+    {
+        SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(static_cast<std::size_t>(slot_index) < control.state_slots_.size());
+        const EventSlotStatus slot{control.state_slots_[slot_index].load(std::memory_order_acquire)};
+        if (!slot.IsInvalid() && !slot.IsInWriting())
+        {
+            const auto slot_time_stamp = slot.GetTimeStamp();
+            if (latest_time_stamp < slot_time_stamp)
+            {
+                latest_time_stamp = slot_time_stamp;
+                latest_slot_index = slot_index;
+            }
+        }
+    }
+
+    return latest_slot_index;
+}
+
+template <template <class> class AtomicIndirectorType>
+bool EventDataControlCompositeImpl<AtomicIndirectorType>::TryIncreaseReferenceCount(ControlSlotType& slot) const noexcept
+{
+    EventSlotStatus slot_old{slot.load(std::memory_order_acquire)};
+    if (slot_old.IsInvalid() || slot_old.IsInWriting())
+    {
+        return false;
+    }
+
+    const auto new_refcount = static_cast<EventSlotStatus::SubscriberCount>(slot_old.GetReferenceCount() + 1U);
+    EventSlotStatus slot_new{slot_old.GetTimeStamp(), new_refcount};
+
+    auto slot_old_value = static_cast<EventSlotStatus::value_type&>(slot_old);
+    auto slot_new_value = static_cast<EventSlotStatus::value_type&>(slot_new);
+    return AtomicIndirectorType<EventSlotStatus::value_type>::compare_exchange_weak(
+        slot, slot_old_value, slot_new_value, std::memory_order_acq_rel);
+}
+
 template <template <class> class AtomicIndirectorType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
@@ -303,6 +351,53 @@ EventSlotStatus::EventTimeStamp EventDataControlCompositeImpl<AtomicIndirectorTy
     }
 }
 
+template <template <class> class AtomicIndirectorType>
+ControlSlotCompositeIndicator EventDataControlCompositeImpl<AtomicIndirectorType>::GetLatestSlot() const noexcept
+{
+    EventDataControl* control = (asil_b_control_ != nullptr) ? asil_b_control_ : asil_qm_control_;
+
+    for (std::size_t retry_counter{0U}; retry_counter < MAX_MULTI_ALLOCATE_RETRY_COUNT; ++retry_counter)
+    {
+        const auto latest_slot_index = FindLatestReadableSlotIndex(*control);
+
+        if (!latest_slot_index.has_value())
+        {
+            return {};
+        }
+
+        const auto slot_index = latest_slot_index.value();
+
+        if (asil_b_control_ != nullptr)
+        {
+            auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+            auto& slot_asil_b = asil_b_control_->state_slots_[slot_index];
+
+            if (!TryIncreaseReferenceCount(slot_qm))
+            {
+                continue;
+            }
+
+            if (!TryIncreaseReferenceCount(slot_asil_b))
+            {
+                score::cpp::ignore = slot_qm.fetch_sub(1U, std::memory_order_acq_rel);
+                continue;
+            }
+
+            return {slot_index, slot_qm, slot_asil_b};
+        }
+
+        auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+        if (!TryIncreaseReferenceCount(slot_qm))
+        {
+            continue;
+        }
+
+        return {slot_index, slot_qm, ControlSlotCompositeIndicator::CompositeSlotTagType::QM};
+    }
+
+    return {};
+}
+
 template <template <class> class AtomicIndirectorType>
 void EventDataControlCompositeImpl<AtomicIndirectorType>::CheckForValidDataControls() const noexcept
 {
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.h b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
index c052bedf0..5efba2cf1 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.h
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
@@ -98,6 +98,8 @@ class EventDataControlCompositeImpl
     /// \brief Returns the timestamp of the provided slot index
     EventSlotStatus::EventTimeStamp GetEventSlotTimestamp(const SlotIndexType slot) const noexcept;
 
+    ControlSlotCompositeIndicator GetLatestSlot() const noexcept;
+
     EventSlotStatus::EventTimeStamp GetLatestTimestamp() const noexcept;
 
   private:
@@ -110,8 +112,10 @@ class EventDataControlCompositeImpl
 
     // Algorithms that operate on multiple control blocks
     ControlSlotCompositeIndicator GetNextFreeMultiSlot() const noexcept;
+    score::cpp::optional<SlotIndexType> FindLatestReadableSlotIndex(const EventDataControl& control) const noexcept;
 
     bool TryLockSlot(ControlSlotCompositeIndicator slot_indicator) noexcept;
+    bool TryIncreaseReferenceCount(ControlSlotType& slot) const noexcept;
     ControlSlotCompositeIndicator AllocateNextMultiSlot() noexcept;
     void CheckForValidDataControls() const noexcept;
 };
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
index 3f046d58f..7ca576cf3 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
@@ -202,6 +202,73 @@ TEST_F(EventDataControlCompositeFixture, GetLatestTimeStampReturnCorrectValue)
     EXPECT_EQ(time_stamp_obtained, time_stamp);
 }
 
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsLatestReadySlotForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and two ready slots
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto first_slot = unit_->AllocateNextSlot();
+    auto second_slot = unit_->AllocateNextSlot();
+    unit_->EventReady(first_slot, 2U);
+    unit_->EventReady(second_slot, 3U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot with the highest timestamp is returned
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    EXPECT_EQ(latest_slot.GetIndex(), second_slot.GetIndex());
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and one ready slot
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot is referenced once
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    const EventSlotStatus slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    EXPECT_EQ(slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmAndAsilB)
+{
+    // Given an EventDataControlComposite with QM and ASIL-B controls and one ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then both control parts are referenced once
+    ASSERT_TRUE(latest_slot.IsValidQmAndAsilB());
+    const EventSlotStatus qm_slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    const EventSlotStatus asil_b_slot_status{latest_slot.GetSlotAsilB().load(std::memory_order_acquire)};
+    EXPECT_EQ(qm_slot_status.GetReferenceCount(), 1U);
+    EXPECT_EQ(asil_b_slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsInvalidIndicatorIfNoReadableSlotExists)
+{
+    // Given an EventDataControlComposite with no ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then no valid slot is returned
+    EXPECT_FALSE(latest_slot.IsValidQM());
+    EXPECT_FALSE(latest_slot.IsValidAsilB());
+}
+
 TEST_F(EventDataControlCompositeFixture, CanAllocateMultipleSlots)
 {
     // Given an EventDataControlComposite with zero used slots

From 775168ebcf97bc4131e1683c13f5f8d37b1a4495 Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Mon, 16 Mar 2026 17:51:42 +0100
Subject: [PATCH 2/7] mw/com/impl: adds GetLatestSample function

- Adds GetLatestSampleFunction to SkeletonEvent
Issue: SWP-249517
---
 .../com/impl/bindings/lola/skeleton_event.h   | 35 ++++++++++-
 .../bindings/lola/skeleton_event_test.cpp     | 50 ++++++++++++++++
 .../bindings/mock_binding/skeleton_event.h    |  5 ++
 score/mw/com/impl/skeleton_event.h            |  5 ++
 score/mw/com/impl/skeleton_event_binding.h    |  2 +
 .../com/impl/skeleton_event_binding_test.cpp  |  4 ++
 score/mw/com/impl/skeleton_event_test.cpp     | 58 +++++++++++++++++++
 7 files changed, 158 insertions(+), 1 deletion(-)

diff --git a/score/mw/com/impl/bindings/lola/skeleton_event.h b/score/mw/com/impl/bindings/lola/skeleton_event.h
index c0bca4719..0a1ff08e6 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event.h
@@ -91,6 +91,8 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
 
     Result<impl::SampleAllocateePtr<SampleType>> Allocate() noexcept override;
 
+    Result<SampleType> GetLatestSample() noexcept override;
+
     /// @requirement SWS_CM_00700
     ResultBlank PrepareOffer() noexcept override;
 
@@ -233,7 +235,7 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
 {
     if (event_data_control_composite_.has_value() == false)
     {
-        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControl does not exist!";
+        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControlComposite does not exist!";
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     const auto slot = event_data_control_composite_->AllocateNextSlot();
@@ -272,6 +274,37 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
     }
 }
 
+template <typename SampleType>
+Result<SampleType> SkeletonEvent<SampleType>::GetLatestSample() noexcept
+{
+    if (event_data_control_composite_.has_value() == false)
+    {
+        ::score::mw::log::LogError("lola") << "Tried to get the latest sample, but the EventDataControlComposite does not exist!";
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+    auto slot = event_data_control_composite_->GetLatestSlot();
+
+    if (slot.IsValidQM() || slot.IsValidAsilB())
+    {
+        const auto sample = event_data_storage_->at(static_cast<std::uint64_t>(slot.GetIndex()));
+
+        if (slot.IsValidQM())
+        {
+            score::cpp::ignore = slot.GetSlotQM().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+        if (slot.IsValidAsilB())
+        {
+            score::cpp::ignore = slot.GetSlotAsilB().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+
+        return sample;
+    }
+    else
+    {
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+}
+
 template <typename SampleType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
index 8827bfa08..e07306e15 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
@@ -318,6 +318,56 @@ TEST_F(SkeletonEventPrepareStopOfferFixture, StopOfferSkeletonEvent)
     skeleton_event_->PrepareStopOffer();
 }
 
+using SkeletonEventGetLatestSampleFixture = SkeletonEventFixture;
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsBeforePrepareOffer)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsIfNoSampleWasSent)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleReturnsMostRecentlySentSample)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    auto first_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(first_allocated_slot_result.has_value());
+    auto first_allocated_slot = std::move(first_allocated_slot_result).value();
+    *first_allocated_slot = static_cast<test::TestSampleType>(11U);
+    auto first_send_result = skeleton_event_->Send(std::move(first_allocated_slot), score::cpp::nullopt);
+    ASSERT_TRUE(first_send_result.has_value());
+
+    auto second_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(second_allocated_slot_result.has_value());
+    auto second_allocated_slot = std::move(second_allocated_slot_result).value();
+    *second_allocated_slot = static_cast<test::TestSampleType>(42U);
+    auto second_send_result = skeleton_event_->Send(std::move(second_allocated_slot), score::cpp::nullopt);
+    ASSERT_TRUE(second_send_result.has_value());
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_TRUE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.value(), static_cast<test::TestSampleType>(42U));
+}
+
 using SkeletonEventTimestampFixture = SkeletonEventFixture;
 TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
 {
diff --git a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
index c08e21d16..b6f089a74 100644
--- a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
@@ -48,6 +48,7 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
                  score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<SampleAllocateePtr<SampleType>>, Allocate, (), (noexcept, override));
+    MOCK_METHOD(Result<SampleType>, GetLatestSample, (), (noexcept, override));
     MOCK_METHOD(ResultBlank, PrepareOffer, (), (noexcept, override));
     MOCK_METHOD(void, PrepareStopOffer, (), (noexcept, override));
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
@@ -83,6 +84,10 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     {
         return skeleton_event_.Allocate();
     };
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return skeleton_event_.GetLatestSample();
+    }
     ResultBlank PrepareOffer() noexcept override
     {
         return skeleton_event_.PrepareOffer();
diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index 2face4332..722b9fc1f 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -313,6 +313,11 @@ class SkeletonEventView
         return skeleton_event_.GetTypedEventBinding();
     }
 
+    Result<SampleType> GetLatestSample() noexcept
+    {
+        return GetBinding()->GetLatestSample();
+    }
+
   private:
     SkeletonEvent<SampleType>& skeleton_event_;
 };
diff --git a/score/mw/com/impl/skeleton_event_binding.h b/score/mw/com/impl/skeleton_event_binding.h
index 7255ab8f1..198f7d153 100644
--- a/score/mw/com/impl/skeleton_event_binding.h
+++ b/score/mw/com/impl/skeleton_event_binding.h
@@ -89,6 +89,8 @@ class SkeletonEventBinding : public SkeletonEventBindingBase
     /// implementations.
     virtual Result<SampleAllocateePtr<SampleType>> Allocate() noexcept = 0;
 
+    virtual Result<SampleType> GetLatestSample() noexcept = 0;
+
     std::size_t GetMaxSize() const noexcept override
     {
         return sizeof(SampleType);
diff --git a/score/mw/com/impl/skeleton_event_binding_test.cpp b/score/mw/com/impl/skeleton_event_binding_test.cpp
index cb32d56e1..5e0461eac 100644
--- a/score/mw/com/impl/skeleton_event_binding_test.cpp
+++ b/score/mw/com/impl/skeleton_event_binding_test.cpp
@@ -48,6 +48,10 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
     {
         return MakeSampleAllocateePtr(std::make_unique<SampleType>());
     }
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return SampleType{};
+    }
     BindingType GetBindingType() const noexcept override
     {
         return BindingType::kFake;
diff --git a/score/mw/com/impl/skeleton_event_test.cpp b/score/mw/com/impl/skeleton_event_test.cpp
index 1db0646b6..af4afdff1 100644
--- a/score/mw/com/impl/skeleton_event_test.cpp
+++ b/score/mw/com/impl/skeleton_event_test.cpp
@@ -653,5 +653,63 @@ TEST(SkeletonEventTest, MovingAssigningSkeletonUpdatesEventMapReference)
     EXPECT_EQ(&event, &unit2.my_dummy_event_);
 }
 
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleDispatchesToBinding)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+
+    // and that GetLatestSample() is called once on the event binding which returns a valid sample
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
+        .WillOnce(Return(ByMove(static_cast<TestSampleType>(42U))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result = SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample();
+
+    // Then the result is valid and contains the sample from the binding
+    ASSERT_TRUE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.value(), static_cast<TestSampleType>(42U));
+}
+
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleWhenBindingFailsReturnsError)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+
+    // and that GetLatestSample() is called once on the event binding which returns an error
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
+        .WillOnce(Return(ByMove(MakeUnexpected(ComErrc::kBindingFailure))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result = SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample();
+
+    // Then the result contains an error that the binding failed
+    ASSERT_FALSE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.error(), ComErrc::kBindingFailure);
+}
+
 }  // namespace
 }  // namespace score::mw::com::impl

From be13cb9d15b6643898e08d1058d21aa43b69b6d7 Mon Sep 17 00:00:00 2001
From: Sunil Yadav <Sunil.Yadav@bti.bmwgroup.com>
Date: Tue, 10 Mar 2026 11:41:58 +0530
Subject: [PATCH 3/7] Add SetHandler support for SkeletonField

Implement RegisterSetHandler() method to allow users to register
callbacks for handling remote Set requests on skeleton fields.
The Set handler wraps user-provided validation/modification logic
and automatically broadcasts accepted values to all field
subscribers via Update().

Configuration support is stubbed with TODO - requires extension of
LolaFieldInstanceDeployment to include has_setter flag.

Issue: SWP-249527
---
 score/mw/com/impl/skeleton_field.h      | 66 +++++++++++++++++++++++--
 score/mw/com/impl/skeleton_field_base.h |  7 +++
 2 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/score/mw/com/impl/skeleton_field.h b/score/mw/com/impl/skeleton_field.h
index b364d93f2..558d071f0 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -17,6 +17,7 @@
 #include "score/mw/com/impl/plumbing/skeleton_field_binding_factory.h"
 #include "score/mw/com/impl/skeleton_event.h"
 #include "score/mw/com/impl/skeleton_field_base.h"
+#include "score/mw/com/impl/methods/skeleton_method.h"
 
 #include "score/mw/com/impl/mocking/i_skeleton_field.h"
 
@@ -92,6 +93,38 @@ class SkeletonField : public SkeletonFieldBase
         skeleton_field_mock_ = &skeleton_field_mock;
     }
 
+    // Set handler registration
+    template <typename Callable>
+    ResultBlank RegisterSetHandler(Callable&& callback) {
+        if (!is_setter_) {
+            return MakeUnexpected(ComErrc::kNotImplemented,
+                                 "Field not configured with setter");
+        }
+
+        // Wrap user callback to also call Update() after user validation
+        auto wrapped_callback = [this, user_callback = std::move(callback)]
+                                (FieldType new_value) -> Result<FieldType> {
+            // 1. Call user's validation/modification handler
+            auto result = user_callback(new_value);
+
+            if (!result.has_value()) {
+                return result;  // User rejected the value, propagate the error
+            }
+
+            // 2. User accepted (possibly modified) - update the field
+            auto update_result = this->Update(result.value());
+            if (!update_result.has_value()) {
+                return MakeUnexpected(update_result.error());
+            }
+
+            // 3. Return the actual value that was set
+            return result;
+        };
+
+        // Register with underlying method infrastructure
+        return GetTypedSetMethod()->RegisterHandler(std::move(wrapped_callback));
+    }
+
   private:
     bool IsInitialValueSaved() const noexcept override
     {
@@ -107,6 +140,18 @@ class SkeletonField : public SkeletonFieldBase
 
     std::unique_ptr<FieldType> initial_field_value_;
     ISkeletonField<FieldType>* skeleton_field_mock_;
+
+    // Store unique_ptr to the actual method object
+    std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method_;
+
+    auto* GetTypedSetMethod() -> SkeletonMethod<Result<FieldType>(FieldType)>*
+    {
+        if (skeleton_method_set_dispatch_.has_value()) {
+            return dynamic_cast<SkeletonMethod<Result<FieldType>(FieldType)>*>(
+                skeleton_method_set_dispatch_.value());
+        }
+        return nullptr;
+    }
 };
 
 template <typename SampleDataType>
@@ -126,6 +171,21 @@ SkeletonField<SampleDataType>::SkeletonField(SkeletonBase& parent, const std::st
 {
     SkeletonBaseView skeleton_base_view{parent};
     skeleton_base_view.RegisterField(field_name, *this);
+
+    // TODO: Get configuration from deployment/configuration system
+    // For now, assume setter is disabled by default
+    constexpr bool has_setter_config = false;  // TODO: Read from configuration
+
+    // Check configuration and create Set method if needed
+    if (has_setter_config) {
+        set_method_ = std::make_unique<
+            SkeletonMethod<Result<FieldType>(FieldType)>>(
+                parent,
+                std::string(field_name) + "_Set"  // Method name
+            );
+        skeleton_method_set_dispatch_ = set_method_.get();
+        is_setter_ = true;
+    }
 }
 
 template <typename SampleDataType>
@@ -148,13 +208,12 @@ SkeletonField<SampleDataType>::SkeletonField(SkeletonField&& other) noexcept
       // so it's still valid to access it here for moving into our own member.
       // coverity[autosar_cpp14_a12_8_3_violation] This is a false-positive.
       initial_field_value_{std::move(other.initial_field_value_)},
-      skeleton_field_mock_{other.skeleton_field_mock_}
+      skeleton_field_mock_{other.skeleton_field_mock_},
+      set_method_{std::move(other.set_method_)}
 {
     // Since the address of this event has changed, we need update the address stored in the parent skeleton.
     SkeletonBaseView skeleton_base_view{skeleton_base_.get()};
     skeleton_base_view.UpdateField(field_name_, *this);
-}
-
 template <typename SampleDataType>
 auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept -> SkeletonField<SampleDataType>&
 {
@@ -164,6 +223,7 @@ auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept
 
         initial_field_value_ = std::move(other.initial_field_value_);
         skeleton_field_mock_ = std::move(other.skeleton_field_mock_);
+        set_method_ = std::move(other.set_method_);
 
         // Since the address of this event has changed, we need update the address stored in the parent skeleton.
         SkeletonBaseView skeleton_base_view{skeleton_base_.get()};
diff --git a/score/mw/com/impl/skeleton_field_base.h b/score/mw/com/impl/skeleton_field_base.h
index b38974f13..eb17b2296 100644
--- a/score/mw/com/impl/skeleton_field_base.h
+++ b/score/mw/com/impl/skeleton_field_base.h
@@ -15,6 +15,7 @@
 
 #include "score/mw/com/impl/com_error.h"
 #include "score/mw/com/impl/skeleton_event_base.h"
+#include "score/mw/com/impl/methods/skeleton_method_base.h"
 
 #include "score/mw/log/logging.h"
 #include "score/result/result.h"
@@ -117,6 +118,12 @@ class SkeletonFieldBase
     // coverity[autosar_cpp14_m11_0_1_violation]
     std::string_view field_name_;
 
+    // Add method dispatcher for Set (optional because not all fields have it)
+    std::optional<SkeletonMethodBase*> skeleton_method_set_dispatch_;
+
+    // Configuration flag to indicate if field has setter
+    bool is_setter_ = false;
+
   private:
     /// \brief Returns whether the initial value has been saved by the user to be used by DoDeferredUpdate
     virtual bool IsInitialValueSaved() const noexcept = 0;

From fde416d134784395d5235066c999fa3d73b0af5b Mon Sep 17 00:00:00 2001
From: Sunil Yadav <Sunil.Yadav@bti.bmwgroup.com>
Date: Fri, 13 Mar 2026 18:02:39 +0530
Subject: [PATCH 4/7] mw/com/impl: mirror proxy field style template arg for
 setHandle

Replace runtime is_setter_ guard with EnableSet/EnableNotifier
template bool parameters on SkeletonField.

Issue: SWP-249527
---
 score/mw/com/impl/BUILD                 |   2 +
 score/mw/com/impl/skeleton_event.h      |   7 +-
 score/mw/com/impl/skeleton_field.h      | 222 ++++++++++++++++--------
 score/mw/com/impl/skeleton_field_base.h |   6 -
 score/mw/com/impl/traits.h              |   4 +-
 5 files changed, 161 insertions(+), 80 deletions(-)

diff --git a/score/mw/com/impl/BUILD b/score/mw/com/impl/BUILD
index 1f78b91aa..3bfce3095 100644
--- a/score/mw/com/impl/BUILD
+++ b/score/mw/com/impl/BUILD
@@ -147,6 +147,7 @@ cc_library(
     deps = [
         ":skeleton_event",
         ":skeleton_field_base",
+        "//score/mw/com/impl/methods:skeleton_method",
         "//score/mw/com/impl/mocking:i_skeleton_field",
         "//score/mw/com/impl/plumbing:field",
         "//score/mw/com/impl/plumbing:sample_allocatee_ptr",
@@ -246,6 +247,7 @@ cc_library(
     deps = [
         ":error",
         ":skeleton_event_base",
+        "//score/mw/com/impl/methods:skeleton_method_base",
         "@score_baselibs//score/language/futurecpp",
         "@score_baselibs//score/result",
         "@score_logging//score/mw/log",
diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index 722b9fc1f..e8a4fe46c 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -36,7 +36,9 @@ namespace score::mw::com::impl
 
 // False Positive: this is a normal forward declaration.
 // coverity[autosar_cpp14_m3_2_3_violation]
-template <typename>
+template <typename SampleDataType,
+        const bool EnableSet,
+        const bool EnableNotifier>
 class SkeletonField;
 
 template <typename SampleDataType>
@@ -51,7 +53,8 @@ class SkeletonEvent : public SkeletonEventBase
     // SkeletonField uses composition pattern to reuse code from SkeletonEvent. These two classes also have shared
     // private APIs which necessitates the use of the friend keyword.
     // coverity[autosar_cpp14_a11_3_1_violation]
-    friend class SkeletonField<SampleDataType>;
+    template <typename T, bool ES, bool EN>
+    friend class SkeletonField;
 
     // Empty struct that is used to make the second constructor only accessible to SkeletonEvent and SkeletonField (as
     // the latter is a friend).
diff --git a/score/mw/com/impl/skeleton_field.h b/score/mw/com/impl/skeleton_field.h
index 558d071f0..856884e41 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -28,18 +28,49 @@
 
 #include <memory>
 #include <string_view>
+#include <type_traits>
 #include <utility>
 
 namespace score::mw::com::impl
 {
 
-template <typename SampleDataType>
+namespace detail
+{
+/// Tag types for constructor overload disambiguation based on EnableSet template parameter.
+struct EnableSetOnlyTag
+{
+};
+struct EnableNeitherTag
+{
+};
+}  // namespace detail
+
+template <typename SampleDataType,
+        const bool EnableSet = false,
+        const bool EnableNotifier = false>
 class SkeletonField : public SkeletonFieldBase
 {
   public:
     using FieldType = SampleDataType;
 
-    SkeletonField(SkeletonBase& parent, const std::string_view field_name);
+    /// \brief Constructs a SkeletonField with setter enabled. Normal ctor used in production code.
+    ///
+    /// \param parent Skeleton that contains this field.
+    /// \param field_name Field name of the field.
+    /// \param detail::EnableSetOnlyTag This parameter is only used for constructor overload disambiguation and
+    /// has no semantic meaning. The tag disambiguates the setter-enabled ctor from the no-setter ctor, as
+    /// otherwise both would have the same signature.
+    template <bool ES = EnableSet, typename = std::enable_if_t<ES>>
+    SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableSetOnlyTag = {});
+
+    /// \brief Constructs a SkeletonField with no setter. Normal ctor used in production code.
+    ///
+    /// \param parent Skeleton that contains this field.
+    /// \param field_name Field name of the field.
+    /// \param detail::EnableNeitherTag This parameter is only used for constructor overload disambiguation and
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, typename = std::enable_if_t<!ES>>
+    SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableNeitherTag = {});
 
     /// Constructor that allows to set the binding directly.
     ///
@@ -94,13 +125,11 @@ class SkeletonField : public SkeletonFieldBase
     }
 
     // Set handler registration
-    template <typename Callable>
+    // SFINAE-gated: only exists when EnableSet == true
+    template <typename Callable,
+              bool ES = EnableSet,
+              typename std::enable_if<ES, int>::type = 0>
     ResultBlank RegisterSetHandler(Callable&& callback) {
-        if (!is_setter_) {
-            return MakeUnexpected(ComErrc::kNotImplemented,
-                                 "Field not configured with setter");
-        }
-
         // Wrap user callback to also call Update() after user validation
         auto wrapped_callback = [this, user_callback = std::move(callback)]
                                 (FieldType new_value) -> Result<FieldType> {
@@ -121,8 +150,8 @@ class SkeletonField : public SkeletonFieldBase
             return result;
         };
 
-        // Register with underlying method infrastructure
-        return GetTypedSetMethod()->RegisterHandler(std::move(wrapped_callback));
+        // set_method_ is guaranteed to be unique_ptr here since RegisterSetHandler is SFINAE-gated on EnableSet=true.
+        return set_method_.get()->RegisterHandler(std::move(wrapped_callback));
     }
 
   private:
@@ -141,66 +170,117 @@ class SkeletonField : public SkeletonFieldBase
     std::unique_ptr<FieldType> initial_field_value_;
     ISkeletonField<FieldType>* skeleton_field_mock_;
 
-    // Store unique_ptr to the actual method object
-    std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method_;
-
-    auto* GetTypedSetMethod() -> SkeletonMethod<Result<FieldType>(FieldType)>*
-    {
-        if (skeleton_method_set_dispatch_.has_value()) {
-            return dynamic_cast<SkeletonMethod<Result<FieldType>(FieldType)>*>(
-                skeleton_method_set_dispatch_.value());
-        }
-        return nullptr;
-    }
+    // Zero-cost storage: when EnableSet=false the member has type 'detail::EnableSetOnlyTag', which is a zero-size
+    // type, so it doesn't actually take up any space in the class. When EnableSet=true, the member has the actual
+    // type and stores the set method.
+    using SetMethodType = std::conditional_t<EnableSet,
+                                             std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>>,
+                                             detail::EnableSetOnlyTag>;
+    SetMethodType set_method_;
+
+    /// \brief Private delegating constructor used by the setter-enabled public ctor.
+    /// Receives already-constructed objects so that we can pass the event pointer to SkeletonFieldBase before
+    /// storing it here, mirroring the ProxyField pattern.
+    template <bool ES = EnableSet, typename = std::enable_if_t<ES>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+                  const std::string_view field_name);
+
+    /// \brief Private delegating constructor used by the no-setter public ctor.
+    template <bool ES = EnableSet, typename = std::enable_if_t<!ES>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  const std::string_view field_name);
 };
 
-template <typename SampleDataType>
-SkeletonField<SampleDataType>::SkeletonField(SkeletonBase& parent, const std::string_view field_name)
-    : SkeletonFieldBase{parent,
+/// \brief Public ctor � EnableSet=true: delegates to the private ctor that also creates the set method.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+template <bool ES, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& parent,
+                                                                        const std::string_view field_name,
+                                                                        detail::EnableSetOnlyTag)
+    : SkeletonField{parent,
+                    std::make_unique<SkeletonEvent<FieldType>>(
+                        parent,
                         field_name,
-                        std::make_unique<SkeletonEvent<FieldType>>(
+                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                             parent,
-                            field_name,
-                            SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
-                                SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
-                                parent,
-                                field_name),
-                            typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{})},
-      initial_field_value_{nullptr},
-      skeleton_field_mock_{nullptr}
+                            field_name),
+                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+                    std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(
+                        parent, std::string(field_name) + "_Set"),
+                    field_name}
 {
-    SkeletonBaseView skeleton_base_view{parent};
-    skeleton_base_view.RegisterField(field_name, *this);
+}
 
-    // TODO: Get configuration from deployment/configuration system
-    // For now, assume setter is disabled by default
-    constexpr bool has_setter_config = false;  // TODO: Read from configuration
-
-    // Check configuration and create Set method if needed
-    if (has_setter_config) {
-        set_method_ = std::make_unique<
-            SkeletonMethod<Result<FieldType>(FieldType)>>(
-                parent,
-                std::string(field_name) + "_Set"  // Method name
-            );
-        skeleton_method_set_dispatch_ = set_method_.get();
-        is_setter_ = true;
-    }
+/// \brief Public ctor � EnableSet=false: delegates to the private ctor with no set method.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+template <bool ES, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& parent,
+                                                                        const std::string_view field_name,
+                                                                        detail::EnableNeitherTag)
+    : SkeletonField{parent,
+                    std::make_unique<SkeletonEvent<FieldType>>(
+                        parent,
+                        field_name,
+                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                            parent,
+                            field_name),
+                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+                    field_name}
+{
 }
 
-template <typename SampleDataType>
-SkeletonField<SampleDataType>::SkeletonField(SkeletonBase& skeleton_base,
+/// \brief Testing ctor: binding is provided directly (used with mock bindings in tests).
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& skeleton_base,
                                              const std::string_view field_name,
                                              std::unique_ptr<SkeletonEventBinding<FieldType>> binding)
-    : SkeletonFieldBase{skeleton_base,
-                        field_name,
-                        std::make_unique<SkeletonEvent<FieldType>>(skeleton_base, field_name, std::move(binding))},
+    : SkeletonField{skeleton_base,
+                    std::make_unique<SkeletonEvent<FieldType>>(skeleton_base, field_name, std::move(binding)),
+                    field_name}
+{
+}
+
+/// \brief Private delegating ctor � setter enabled. Receives fully-constructed objects.
+/// By constructing set_method_ here and passing the event pointer to SkeletonFieldBase first,
+/// we guarantee the base class pointer is stable before we store set_method_.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+template <bool ES, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
+      skeleton_field_mock_{nullptr},
+      set_method_{std::move(set_method)}
+{
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
+}
+
+/// \brief Private delegating ctor � no setter. Receives the already-constructed event.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+template <bool ES, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
       skeleton_field_mock_{nullptr}
 {
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
 }
 
-template <typename SampleDataType>
-SkeletonField<SampleDataType>::SkeletonField(SkeletonField&& other) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonField&& other) noexcept
     : SkeletonFieldBase(static_cast<SkeletonFieldBase&&>(other)),
       // known llvm bug (https://github.com/llvm/llvm-project/issues/63202)
       // This usage is safe because the previous line only moves the base class portion via static_cast.
@@ -214,8 +294,10 @@ SkeletonField<SampleDataType>::SkeletonField(SkeletonField&& other) noexcept
     // Since the address of this event has changed, we need update the address stored in the parent skeleton.
     SkeletonBaseView skeleton_base_view{skeleton_base_.get()};
     skeleton_base_view.UpdateField(field_name_, *this);
-template <typename SampleDataType>
-auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept -> SkeletonField<SampleDataType>&
+}
+
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(SkeletonField&& other) & noexcept -> SkeletonField<SampleDataType, EnableSet, EnableNotifier>&
 {
     if (this != &other)
     {
@@ -239,8 +321,8 @@ auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept
 /// field cannot be set until the Skeleton has been set up via Skeleton::OfferService(). Therefore, we create a
 /// callback that will update the field value with sample_value which will be called in the first call to
 /// SkeletonFieldBase::PrepareOffer().
-template <typename SampleDataType>
-ResultBlank SkeletonField<SampleDataType>::Update(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(const FieldType& sample_value) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -257,8 +339,8 @@ ResultBlank SkeletonField<SampleDataType>::Update(const FieldType& sample_value)
 
 /// \brief FieldType is previously allocated by middleware and provided by the user to indicate that he is finished
 /// filling the provided pointer with live data. Dispatches to SkeletonEvent::Send()
-template <typename SampleDataType>
-ResultBlank SkeletonField<SampleDataType>::Update(SampleAllocateePtr<FieldType> sample) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(SampleAllocateePtr<FieldType> sample) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -273,8 +355,8 @@ ResultBlank SkeletonField<SampleDataType>::Update(SampleAllocateePtr<FieldType>
 ///
 /// This function cannot be currently called to set the initial value of a field as the shared memory must be first
 /// set up in the Skeleton::PrepareOffer() before the user can obtain / use a SampleAllocateePtr.
-template <typename SampleDataType>
-Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType>::Allocate() noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Allocate() noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -292,12 +374,12 @@ Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType>::Alloca
     return GetTypedEvent()->Allocate();
 }
 
-template <typename SampleDataType>
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
 // Suppress "AUTOSAR C++14 A0-1-3" rule finding. This rule states: "Every function defined in an anonymous
 // namespace, or static function with internal linkage, or private member function shall be used.".
 // False-positive, method is used in the base class in PrepareOffer().
 // coverity[autosar_cpp14_a0_1_3_violation : FALSE]
-ResultBlank SkeletonField<SampleDataType>::DoDeferredUpdate() noexcept
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::DoDeferredUpdate() noexcept
 {
     SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(
         initial_field_value_ != nullptr,
@@ -313,14 +395,14 @@ ResultBlank SkeletonField<SampleDataType>::DoDeferredUpdate() noexcept
     return ResultBlank{};
 }
 
-template <typename SampleDataType>
-ResultBlank SkeletonField<SampleDataType>::UpdateImpl(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::UpdateImpl(const FieldType& sample_value) noexcept
 {
     return GetTypedEvent()->Send(sample_value);
 }
 
-template <typename SampleDataType>
-auto SkeletonField<SampleDataType>::GetTypedEvent() const noexcept -> SkeletonEvent<SampleDataType>*
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::GetTypedEvent() const noexcept -> SkeletonEvent<SampleDataType>*
 {
     auto* const typed_event = dynamic_cast<SkeletonEvent<FieldType>*>(skeleton_event_dispatch_.get());
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(typed_event != nullptr, "Downcast to SkeletonEvent<FieldType> failed!");
diff --git a/score/mw/com/impl/skeleton_field_base.h b/score/mw/com/impl/skeleton_field_base.h
index eb17b2296..6ecff3fd2 100644
--- a/score/mw/com/impl/skeleton_field_base.h
+++ b/score/mw/com/impl/skeleton_field_base.h
@@ -118,12 +118,6 @@ class SkeletonFieldBase
     // coverity[autosar_cpp14_m11_0_1_violation]
     std::string_view field_name_;
 
-    // Add method dispatcher for Set (optional because not all fields have it)
-    std::optional<SkeletonMethodBase*> skeleton_method_set_dispatch_;
-
-    // Configuration flag to indicate if field has setter
-    bool is_setter_ = false;
-
   private:
     /// \brief Returns whether the initial value has been saved by the user to be used by DoDeferredUpdate
     virtual bool IsInitialValueSaved() const noexcept = 0;
diff --git a/score/mw/com/impl/traits.h b/score/mw/com/impl/traits.h
index 5f2ce1b94..5727d3111 100644
--- a/score/mw/com/impl/traits.h
+++ b/score/mw/com/impl/traits.h
@@ -150,8 +150,8 @@ class SkeletonTrait
     template <typename SampleType>
     using Event = SkeletonEvent<SampleType>;
 
-    template <typename SampleType>
-    using Field = SkeletonField<SampleType>;
+    template <typename SampleType, bool EnableSet = false, bool EnableNotifier = false>
+    using Field = SkeletonField<SampleType, EnableSet, EnableNotifier>;
 
     template <typename MethodSignature>
     using Method = SkeletonMethod<MethodSignature>;

From 6e0efe1a8c955b1a756534a0bceb9c11c9a27410 Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Tue, 17 Mar 2026 14:56:31 +0100
Subject: [PATCH 5/7] mw/com/impl: introduces EnableGet flag

- SkeletonField now includes a new template parameter, EnableGet.
- When EnableGet is true, a skeleton Get method attribute is added to SkeletonField.
- Constructors were updated to support all relevant EnableSet and EnableGet combinations.
Issue: SWP-249517
---
 score/mw/com/impl/skeleton_event.h        |   6 +-
 score/mw/com/impl/skeleton_field.h        | 247 +++++++++++++++++-----
 score/mw/com/impl/skeleton_field_test.cpp |  56 +++++
 score/mw/com/impl/traits.h                |   4 +-
 4 files changed, 250 insertions(+), 63 deletions(-)

diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index e8a4fe46c..1f8d0fa9a 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -36,9 +36,7 @@ namespace score::mw::com::impl
 
 // False Positive: this is a normal forward declaration.
 // coverity[autosar_cpp14_m3_2_3_violation]
-template <typename SampleDataType,
-        const bool EnableSet,
-        const bool EnableNotifier>
+template <typename SampleDataType, const bool EnableSet, const bool EnableNotifier, const bool EnableGet>
 class SkeletonField;
 
 template <typename SampleDataType>
@@ -53,7 +51,7 @@ class SkeletonEvent : public SkeletonEventBase
     // SkeletonField uses composition pattern to reuse code from SkeletonEvent. These two classes also have shared
     // private APIs which necessitates the use of the friend keyword.
     // coverity[autosar_cpp14_a11_3_1_violation]
-    template <typename T, bool ES, bool EN>
+    template <typename T, bool ES, bool EN, bool EG>
     friend class SkeletonField;
 
     // Empty struct that is used to make the second constructor only accessible to SkeletonEvent and SkeletonField (as
diff --git a/score/mw/com/impl/skeleton_field.h b/score/mw/com/impl/skeleton_field.h
index 856884e41..9fc357a1c 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -36,7 +36,13 @@ namespace score::mw::com::impl
 
 namespace detail
 {
-/// Tag types for constructor overload disambiguation based on EnableSet template parameter.
+/// Tag types for constructor overload disambiguation based on EnableGet/EnableSet template parameters
+struct EnableBothTag
+{
+};
+struct EnableGetOnlyTag
+{
+};
 struct EnableSetOnlyTag
 {
 };
@@ -47,29 +53,47 @@ struct EnableNeitherTag
 
 template <typename SampleDataType,
         const bool EnableSet = false,
-        const bool EnableNotifier = false>
+        const bool EnableNotifier = false,
+        const bool EnableGet = false>
 class SkeletonField : public SkeletonFieldBase
 {
   public:
     using FieldType = SampleDataType;
 
-    /// \brief Constructs a SkeletonField with setter enabled. Normal ctor used in production code.
+    /// \brief Constructs a SkeletonField for EnableSet=true, EnableGet=true. Normal ctor used in production code.
+    ///
+    /// \param parent Skeleton that contains this field.
+    /// \param field_name Field name of the field.
+    /// \param detail::EnableBothTag This parameter is only used for constructor overload disambiguation and
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && EG>>
+    SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableBothTag = {});
+
+    /// \brief Constructs a SkeletonField for EnableSet=false, EnableGet=true. Normal ctor used in production code.
+    ///
+    /// \param parent Skeleton that contains this field.
+    /// \param field_name Field name of the field.
+    /// \param detail::EnableGetOnlyTag This parameter is only used for constructor overload disambiguation and
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && EG>>
+    SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableGetOnlyTag = {});
+
+    /// \brief Constructs a SkeletonField for EnableSet=true, EnableGet=false. Normal ctor used in production code.
     ///
     /// \param parent Skeleton that contains this field.
     /// \param field_name Field name of the field.
     /// \param detail::EnableSetOnlyTag This parameter is only used for constructor overload disambiguation and
-    /// has no semantic meaning. The tag disambiguates the setter-enabled ctor from the no-setter ctor, as
-    /// otherwise both would have the same signature.
-    template <bool ES = EnableSet, typename = std::enable_if_t<ES>>
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && !EG>>
     SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableSetOnlyTag = {});
 
-    /// \brief Constructs a SkeletonField with no setter. Normal ctor used in production code.
+    /// \brief Constructs a SkeletonField for EnableSet=false, EnableGet=false. Normal ctor used in production code.
     ///
     /// \param parent Skeleton that contains this field.
     /// \param field_name Field name of the field.
     /// \param detail::EnableNeitherTag This parameter is only used for constructor overload disambiguation and
     /// has no semantic meaning.
-    template <bool ES = EnableSet, typename = std::enable_if_t<!ES>>
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && !EG>>
     SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableNeitherTag = {});
 
     /// Constructor that allows to set the binding directly.
@@ -178,28 +202,93 @@ class SkeletonField : public SkeletonFieldBase
                                              detail::EnableSetOnlyTag>;
     SetMethodType set_method_;
 
-    /// \brief Private delegating constructor used by the setter-enabled public ctor.
-    /// Receives already-constructed objects so that we can pass the event pointer to SkeletonFieldBase before
-    /// storing it here, mirroring the ProxyField pattern.
-    template <bool ES = EnableSet, typename = std::enable_if_t<ES>>
+    using GetMethodType = std::conditional_t<EnableGet,
+                                             std::unique_ptr<SkeletonMethod<Result<FieldType>()>>,
+                                             detail::EnableGetOnlyTag>;
+    GetMethodType get_method_;
+
+    /// \brief Private delegating constructor: EnableSet=true, EnableGet=true.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && EG>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+                  const std::string_view field_name);
+
+    /// \brief Private delegating constructor: EnableSet=false, EnableGet=true.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && EG>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+                  const std::string_view field_name);
+
+    /// \brief Private delegating constructor: EnableSet=true, EnableGet=false.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && !EG>>
     SkeletonField(SkeletonBase& parent,
                   std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
                   std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
                   const std::string_view field_name);
 
-    /// \brief Private delegating constructor used by the no-setter public ctor.
-    template <bool ES = EnableSet, typename = std::enable_if_t<!ES>>
+    /// \brief Private delegating constructor: EnableSet=false, EnableGet=false.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && !EG>>
     SkeletonField(SkeletonBase& parent,
                   std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
                   const std::string_view field_name);
 };
 
-/// \brief Public ctor � EnableSet=true: delegates to the private ctor that also creates the set method.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-template <bool ES, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& parent,
-                                                                        const std::string_view field_name,
-                                                                        detail::EnableSetOnlyTag)
+/// \brief Public ctor - EnableSet=true, EnableGet=true.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    const std::string_view field_name,
+    detail::EnableBothTag)
+    : SkeletonField{parent,
+                    std::make_unique<SkeletonEvent<FieldType>>(
+                        parent,
+                        field_name,
+                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                            parent,
+                            field_name),
+                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+                    std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(
+                        parent, std::string(field_name) + "_Set"),
+                    std::make_unique<SkeletonMethod<Result<FieldType>()>>(
+                        parent, std::string(field_name) + "_Get"),
+                    field_name}
+{
+}
+
+/// \brief Public ctor - EnableSet=false, EnableGet=true.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    const std::string_view field_name,
+    detail::EnableGetOnlyTag)
+    : SkeletonField{parent,
+                    std::make_unique<SkeletonEvent<FieldType>>(
+                        parent,
+                        field_name,
+                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                            parent,
+                            field_name),
+                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+                    std::make_unique<SkeletonMethod<Result<FieldType>()>>(
+                        parent, std::string(field_name) + "_Get"),
+                    field_name}
+{
+}
+
+/// \brief Public ctor - EnableSet=true, EnableGet=false.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    const std::string_view field_name,
+    detail::EnableSetOnlyTag)
     : SkeletonField{parent,
                     std::make_unique<SkeletonEvent<FieldType>>(
                         parent,
@@ -215,12 +304,13 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
 {
 }
 
-/// \brief Public ctor � EnableSet=false: delegates to the private ctor with no set method.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-template <bool ES, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& parent,
-                                                                        const std::string_view field_name,
-                                                                        detail::EnableNeitherTag)
+/// \brief Public ctor - EnableSet=false, EnableGet=false.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    const std::string_view field_name,
+    detail::EnableNeitherTag)
     : SkeletonField{parent,
                     std::make_unique<SkeletonEvent<FieldType>>(
                         parent,
@@ -235,22 +325,57 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
 }
 
 /// \brief Testing ctor: binding is provided directly (used with mock bindings in tests).
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& skeleton_base,
-                                             const std::string_view field_name,
-                                             std::unique_ptr<SkeletonEventBinding<FieldType>> binding)
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& skeleton_base,
+    const std::string_view field_name,
+    std::unique_ptr<SkeletonEventBinding<FieldType>> binding)
     : SkeletonField{skeleton_base,
                     std::make_unique<SkeletonEvent<FieldType>>(skeleton_base, field_name, std::move(binding)),
                     field_name}
 {
 }
 
-/// \brief Private delegating ctor � setter enabled. Receives fully-constructed objects.
-/// By constructing set_method_ here and passing the event pointer to SkeletonFieldBase first,
-/// we guarantee the base class pointer is stable before we store set_method_.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-template <bool ES, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
+/// \brief Private delegating ctor - EnableSet=true, EnableGet=true.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
+      skeleton_field_mock_{nullptr},
+      set_method_{std::move(set_method)},
+      get_method_{std::move(get_method)}
+{
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
+}
+
+/// \brief Private delegating ctor - EnableSet=false, EnableGet=true.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
+      skeleton_field_mock_{nullptr},
+      get_method_{std::move(get_method)}
+{
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
+}
+
+/// \brief Private delegating ctor - EnableSet=true, EnableGet=false.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
     SkeletonBase& parent,
     std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
     std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
@@ -264,10 +389,10 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
     skeleton_base_view.RegisterField(field_name, *this);
 }
 
-/// \brief Private delegating ctor � no setter. Receives the already-constructed event.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-template <bool ES, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
+/// \brief Private delegating ctor - EnableSet=false, EnableGet=false.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
     SkeletonBase& parent,
     std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
     const std::string_view field_name)
@@ -279,8 +404,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
     skeleton_base_view.RegisterField(field_name, *this);
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonField&& other) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonField&& other) noexcept
     : SkeletonFieldBase(static_cast<SkeletonFieldBase&&>(other)),
       // known llvm bug (https://github.com/llvm/llvm-project/issues/63202)
       // This usage is safe because the previous line only moves the base class portion via static_cast.
@@ -289,15 +414,17 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
       // coverity[autosar_cpp14_a12_8_3_violation] This is a false-positive.
       initial_field_value_{std::move(other.initial_field_value_)},
       skeleton_field_mock_{other.skeleton_field_mock_},
-      set_method_{std::move(other.set_method_)}
+      set_method_{std::move(other.set_method_)},
+      get_method_{std::move(other.get_method_)}
 {
     // Since the address of this event has changed, we need update the address stored in the parent skeleton.
     SkeletonBaseView skeleton_base_view{skeleton_base_.get()};
     skeleton_base_view.UpdateField(field_name_, *this);
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(SkeletonField&& other) & noexcept -> SkeletonField<SampleDataType, EnableSet, EnableNotifier>&
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+auto SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::operator=(SkeletonField&& other) & noexcept
+    -> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>&
 {
     if (this != &other)
     {
@@ -306,6 +433,7 @@ auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(Skeleto
         initial_field_value_ = std::move(other.initial_field_value_);
         skeleton_field_mock_ = std::move(other.skeleton_field_mock_);
         set_method_ = std::move(other.set_method_);
+        get_method_ = std::move(other.get_method_);
 
         // Since the address of this event has changed, we need update the address stored in the parent skeleton.
         SkeletonBaseView skeleton_base_view{skeleton_base_.get()};
@@ -321,8 +449,9 @@ auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(Skeleto
 /// field cannot be set until the Skeleton has been set up via Skeleton::OfferService(). Therefore, we create a
 /// callback that will update the field value with sample_value which will be called in the first call to
 /// SkeletonFieldBase::PrepareOffer().
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Update(
+    const FieldType& sample_value) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -339,8 +468,9 @@ ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(con
 
 /// \brief FieldType is previously allocated by middleware and provided by the user to indicate that he is finished
 /// filling the provided pointer with live data. Dispatches to SkeletonEvent::Send()
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(SampleAllocateePtr<FieldType> sample) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Update(
+    SampleAllocateePtr<FieldType> sample) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -355,8 +485,9 @@ ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(Sam
 ///
 /// This function cannot be currently called to set the initial value of a field as the shared memory must be first
 /// set up in the Skeleton::PrepareOffer() before the user can obtain / use a SampleAllocateePtr.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Allocate() noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::
+    Allocate() noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -374,12 +505,12 @@ Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableS
     return GetTypedEvent()->Allocate();
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
 // Suppress "AUTOSAR C++14 A0-1-3" rule finding. This rule states: "Every function defined in an anonymous
 // namespace, or static function with internal linkage, or private member function shall be used.".
 // False-positive, method is used in the base class in PrepareOffer().
 // coverity[autosar_cpp14_a0_1_3_violation : FALSE]
-ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::DoDeferredUpdate() noexcept
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::DoDeferredUpdate() noexcept
 {
     SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(
         initial_field_value_ != nullptr,
@@ -395,14 +526,16 @@ ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::DoDeferred
     return ResultBlank{};
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier>::UpdateImpl(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::UpdateImpl(
+    const FieldType& sample_value) noexcept
 {
     return GetTypedEvent()->Send(sample_value);
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::GetTypedEvent() const noexcept -> SkeletonEvent<SampleDataType>*
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+auto SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::GetTypedEvent() const noexcept
+    -> SkeletonEvent<SampleDataType>*
 {
     auto* const typed_event = dynamic_cast<SkeletonEvent<FieldType>*>(skeleton_event_dispatch_.get());
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(typed_event != nullptr, "Downcast to SkeletonEvent<FieldType> failed!");
diff --git a/score/mw/com/impl/skeleton_field_test.cpp b/score/mw/com/impl/skeleton_field_test.cpp
index 8510c500c..47265ddc8 100644
--- a/score/mw/com/impl/skeleton_field_test.cpp
+++ b/score/mw/com/impl/skeleton_field_test.cpp
@@ -109,6 +109,62 @@ TEST(SkeletonFieldTest, SkeletonFieldContainsPublicSampleType)
                   "Incorrect FieldType.");
 }
 
+TEST(SkeletonFieldTest, CtorBothEnabledAcceptsEnableBothTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, true>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableBothTag>,
+                  "Constructor should accept EnableBothTag when ES=true and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorGetOnlyAcceptsEnableGetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, true>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableGetOnlyTag>,
+                  "Constructor should accept EnableGetOnlyTag when ES=false and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorSetOnlyAcceptsEnableSetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, false>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableSetOnlyTag>,
+                  "Constructor should accept EnableSetOnlyTag when ES=true and EG=false");
+}
+
+TEST(SkeletonFieldTest, CtorNeitherEnabledAcceptsEnableNeitherTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, false>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableNeitherTag>,
+                  "Constructor should accept EnableNeitherTag when ES=false and EG=false");
+}
+
+TEST(SkeletonFieldTest, CtorBothEnabledRejectsEnableGetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, true>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableGetOnlyTag>,
+                  "Constructor should reject EnableGetOnlyTag when ES=true and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorGetOnlyRejectsEnableSetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, true>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableSetOnlyTag>,
+                  "Constructor should reject EnableSetOnlyTag when ES=false and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorSetOnlyRejectsEnableBothTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, false>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableBothTag>,
+                  "Constructor should reject EnableBothTag when ES=true and EG=false");
+}
+
+TEST(SkeletonFieldTest, CtorNeitherEnabledRejectsEnableBothTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, false>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableBothTag>,
+                  "Constructor should reject EnableBothTag when ES=false and EG=false");
+}
+
 // When Ticket-104261 is implemented, the Update call does not have to be deferred until OfferService is called. This
 // test can be reworked to remove the call to PrepareOffer() and simply test Update() before PrepareOffer() is called.
 TEST(SkeletonFieldCopyUpdateTest, CallingUpdateBeforeOfferServiceDefersCallToOfferService)
diff --git a/score/mw/com/impl/traits.h b/score/mw/com/impl/traits.h
index 5727d3111..c3f570562 100644
--- a/score/mw/com/impl/traits.h
+++ b/score/mw/com/impl/traits.h
@@ -150,8 +150,8 @@ class SkeletonTrait
     template <typename SampleType>
     using Event = SkeletonEvent<SampleType>;
 
-    template <typename SampleType, bool EnableSet = false, bool EnableNotifier = false>
-    using Field = SkeletonField<SampleType, EnableSet, EnableNotifier>;
+    template <typename SampleType, bool EnableSet = false, bool EnableNotifier = false, bool EnableGet = false>
+    using Field = SkeletonField<SampleType, EnableSet, EnableNotifier, EnableGet>;
 
     template <typename MethodSignature>
     using Method = SkeletonMethod<MethodSignature>;

From 97b2a2fcc0d10f1cf977689830d4cc95fdfc4595 Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Tue, 17 Mar 2026 16:59:37 +0100
Subject: [PATCH 6/7] mw/com/impl: adds functionality for SkeletonField::Get

- Automatically register a Get handler for fields with EnableGet.
- Serve Get requests by reading the latest field value and returning it through the Get method.
- Update the required slot calculation.
- Add a test covering this behavior.
Issue: SWP-249517
---
 score/mw/com/impl/skeleton_field.h        | 179 ++++++++++++----------
 score/mw/com/impl/skeleton_field_test.cpp |  33 ++++
 2 files changed, 131 insertions(+), 81 deletions(-)

diff --git a/score/mw/com/impl/skeleton_field.h b/score/mw/com/impl/skeleton_field.h
index 9fc357a1c..1e7e22346 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -13,11 +13,11 @@
 #ifndef SCORE_MW_COM_IMPL_SKELETON_FIELD_H
 #define SCORE_MW_COM_IMPL_SKELETON_FIELD_H
 
+#include "score/mw/com/impl/methods/skeleton_method.h"
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
 #include "score/mw/com/impl/plumbing/skeleton_field_binding_factory.h"
 #include "score/mw/com/impl/skeleton_event.h"
 #include "score/mw/com/impl/skeleton_field_base.h"
-#include "score/mw/com/impl/methods/skeleton_method.h"
 
 #include "score/mw/com/impl/mocking/i_skeleton_field.h"
 
@@ -27,6 +27,7 @@
 #include <score/assert.hpp>
 
 #include <memory>
+#include <mutex>
 #include <string_view>
 #include <type_traits>
 #include <utility>
@@ -52,9 +53,9 @@ struct EnableNeitherTag
 }  // namespace detail
 
 template <typename SampleDataType,
-        const bool EnableSet = false,
-        const bool EnableNotifier = false,
-        const bool EnableGet = false>
+          const bool EnableSet = false,
+          const bool EnableNotifier = false,
+          const bool EnableGet = false>
 class SkeletonField : public SkeletonFieldBase
 {
   public:
@@ -150,23 +151,23 @@ class SkeletonField : public SkeletonFieldBase
 
     // Set handler registration
     // SFINAE-gated: only exists when EnableSet == true
-    template <typename Callable,
-              bool ES = EnableSet,
-              typename std::enable_if<ES, int>::type = 0>
-    ResultBlank RegisterSetHandler(Callable&& callback) {
+    template <typename Callable, bool ES = EnableSet, typename std::enable_if<ES, int>::type = 0>
+    ResultBlank RegisterSetHandler(Callable&& callback)
+    {
         // Wrap user callback to also call Update() after user validation
-        auto wrapped_callback = [this, user_callback = std::move(callback)]
-                                (FieldType new_value) -> Result<FieldType> {
+        auto wrapped_callback = [this, user_callback = std::move(callback)](FieldType new_value) -> Result<FieldType> {
             // 1. Call user's validation/modification handler
             auto result = user_callback(new_value);
 
-            if (!result.has_value()) {
+            if (!result.has_value())
+            {
                 return result;  // User rejected the value, propagate the error
             }
 
             // 2. User accepted (possibly modified) - update the field
             auto update_result = this->Update(result.value());
-            if (!update_result.has_value()) {
+            if (!update_result.has_value())
+            {
                 return MakeUnexpected(update_result.error());
             }
 
@@ -191,9 +192,32 @@ class SkeletonField : public SkeletonFieldBase
 
     SkeletonEvent<FieldType>* GetTypedEvent() const noexcept;
 
+    // Get handler registration
+    // SFINAE-gated: only exists when EnableGet == true
+    template <bool EG = EnableGet, typename std::enable_if<EG, int>::type = 0>
+    void RegisterGetHandler()
+    {
+        // get_method_ is guaranteed to be unique_ptr here since RegisterGetHandler is SFINAE-gated on EnableGet=true.
+        const auto result = get_method_.get()->RegisterHandler([this]() -> Result<FieldType> {
+            // need to serialize access to Get. In case of concurrent Get calls,
+            // we want to ensure that they are processed sequentially.
+            std::lock_guard<std::mutex> lock{get_handler_mutex_};
+            return SkeletonEventView<FieldType>{*GetTypedEvent()}.GetLatestSample();
+        });
+        if (!result.has_value())
+        {
+            score::mw::log::LogError("lola")
+                << "RegisterGetHandler: failed to register get handler: " << result.error();
+        }
+    }
+
     std::unique_ptr<FieldType> initial_field_value_;
     ISkeletonField<FieldType>* skeleton_field_mock_;
 
+    // Zero-cost storage: only a real mutex when EnableGet=true, otherwise an empty zero-size type.
+    using GetHandlerMutexType = std::conditional_t<EnableGet, std::mutex, detail::EnableNeitherTag>;
+    GetHandlerMutexType get_handler_mutex_{};
+
     // Zero-cost storage: when EnableSet=false the member has type 'detail::EnableSetOnlyTag', which is a zero-size
     // type, so it doesn't actually take up any space in the class. When EnableSet=true, the member has the actual
     // type and stores the set method.
@@ -202,9 +226,8 @@ class SkeletonField : public SkeletonFieldBase
                                              detail::EnableSetOnlyTag>;
     SetMethodType set_method_;
 
-    using GetMethodType = std::conditional_t<EnableGet,
-                                             std::unique_ptr<SkeletonMethod<Result<FieldType>()>>,
-                                             detail::EnableGetOnlyTag>;
+    using GetMethodType =
+        std::conditional_t<EnableGet, std::unique_ptr<SkeletonMethod<Result<FieldType>()>>, detail::EnableGetOnlyTag>;
     GetMethodType get_method_;
 
     /// \brief Private delegating constructor: EnableSet=true, EnableGet=true.
@@ -239,88 +262,80 @@ class SkeletonField : public SkeletonFieldBase
 /// \brief Public ctor - EnableSet=true, EnableGet=true.
 template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
 template <bool ES, bool EG, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
-    SkeletonBase& parent,
-    const std::string_view field_name,
-    detail::EnableBothTag)
-    : SkeletonField{parent,
-                    std::make_unique<SkeletonEvent<FieldType>>(
-                        parent,
-                        field_name,
-                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
-                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
-                            parent,
-                            field_name),
-                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
-                    std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(
-                        parent, std::string(field_name) + "_Set"),
-                    std::make_unique<SkeletonMethod<Result<FieldType>()>>(
-                        parent, std::string(field_name) + "_Get"),
-                    field_name}
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableBothTag)
+    : SkeletonField{
+          parent,
+          std::make_unique<SkeletonEvent<FieldType>>(parent,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(parent, std::string(field_name) + "_Set"),
+          std::make_unique<SkeletonMethod<Result<FieldType>()>>(parent, std::string(field_name) + "_Get"),
+          field_name}
 {
 }
 
 /// \brief Public ctor - EnableSet=false, EnableGet=true.
 template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
 template <bool ES, bool EG, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
-    SkeletonBase& parent,
-    const std::string_view field_name,
-    detail::EnableGetOnlyTag)
-    : SkeletonField{parent,
-                    std::make_unique<SkeletonEvent<FieldType>>(
-                        parent,
-                        field_name,
-                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
-                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
-                            parent,
-                            field_name),
-                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
-                    std::make_unique<SkeletonMethod<Result<FieldType>()>>(
-                        parent, std::string(field_name) + "_Get"),
-                    field_name}
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableGetOnlyTag)
+    : SkeletonField{
+          parent,
+          std::make_unique<SkeletonEvent<FieldType>>(parent,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          std::make_unique<SkeletonMethod<Result<FieldType>()>>(parent, std::string(field_name) + "_Get"),
+          field_name}
 {
 }
 
 /// \brief Public ctor - EnableSet=true, EnableGet=false.
 template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
 template <bool ES, bool EG, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
-    SkeletonBase& parent,
-    const std::string_view field_name,
-    detail::EnableSetOnlyTag)
-    : SkeletonField{parent,
-                    std::make_unique<SkeletonEvent<FieldType>>(
-                        parent,
-                        field_name,
-                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
-                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
-                            parent,
-                            field_name),
-                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
-                    std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(
-                        parent, std::string(field_name) + "_Set"),
-                    field_name}
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableSetOnlyTag)
+    : SkeletonField{
+          parent,
+          std::make_unique<SkeletonEvent<FieldType>>(parent,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(parent, std::string(field_name) + "_Set"),
+          field_name}
 {
 }
 
 /// \brief Public ctor - EnableSet=false, EnableGet=false.
 template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
 template <bool ES, bool EG, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
-    SkeletonBase& parent,
-    const std::string_view field_name,
-    detail::EnableNeitherTag)
-    : SkeletonField{parent,
-                    std::make_unique<SkeletonEvent<FieldType>>(
-                        parent,
-                        field_name,
-                        SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
-                            SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
-                            parent,
-                            field_name),
-                        typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
-                    field_name}
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableNeitherTag)
+    : SkeletonField{
+          parent,
+          std::make_unique<SkeletonEvent<FieldType>>(parent,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          field_name}
 {
 }
 
@@ -353,6 +368,7 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonFie
 {
     SkeletonBaseView skeleton_base_view{parent};
     skeleton_base_view.RegisterField(field_name, *this);
+    RegisterGetHandler();
 }
 
 /// \brief Private delegating ctor - EnableSet=false, EnableGet=true.
@@ -370,6 +386,7 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonFie
 {
     SkeletonBaseView skeleton_base_view{parent};
     skeleton_base_view.RegisterField(field_name, *this);
+    RegisterGetHandler();
 }
 
 /// \brief Private delegating ctor - EnableSet=true, EnableGet=false.
@@ -486,8 +503,8 @@ ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>:
 /// This function cannot be currently called to set the initial value of a field as the shared memory must be first
 /// set up in the Skeleton::PrepareOffer() before the user can obtain / use a SampleAllocateePtr.
 template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
-Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::
-    Allocate() noexcept
+Result<SampleAllocateePtr<SampleDataType>>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Allocate() noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
diff --git a/score/mw/com/impl/skeleton_field_test.cpp b/score/mw/com/impl/skeleton_field_test.cpp
index 47265ddc8..b084f36a6 100644
--- a/score/mw/com/impl/skeleton_field_test.cpp
+++ b/score/mw/com/impl/skeleton_field_test.cpp
@@ -12,6 +12,7 @@
  ********************************************************************************/
 #include "score/mw/com/impl/skeleton_field.h"
 
+#include "score/mw/com/impl/bindings/mock_binding/skeleton_method.h"
 #include "score/mw/com/impl/runtime.h"
 #include "score/mw/com/impl/runtime_mock.h"
 #include "score/mw/com/impl/test/binding_factory_resources.h"
@@ -19,6 +20,7 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <array>
 #include <cstdint>
 #include <memory>
 #include <string_view>
@@ -64,6 +66,14 @@ class MyDummySkeleton : public SkeletonBase
     SkeletonField<TestSampleType> my_dummy_field_{*this, kFieldName};
 };
 
+class MyGetEnabledSkeleton : public SkeletonBase
+{
+  public:
+    using SkeletonBase::SkeletonBase;
+
+    SkeletonField<TestSampleType, false, false, true> my_get_field_{*this, kFieldName};
+};
+
 TEST(SkeletonFieldTest, NotCopyable)
 {
     RecordProperty("Verifies", "SCR-18221574");
@@ -165,6 +175,29 @@ TEST(SkeletonFieldTest, CtorNeitherEnabledRejectsEnableBothTag)
                   "Constructor should reject EnableBothTag when ES=false and EG=false");
 }
 
+TEST(SkeletonFieldGetHandlerTest, RegisterGetHandlerInvokesGetLatestSampleOnBinding)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+
+    // Set up event binding mock
+    SkeletonFieldBindingFactoryMockGuard<TestSampleType> skeleton_field_binding_factory_mock_guard{};
+    auto skeleton_field_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    EXPECT_CALL(skeleton_field_binding_factory_mock_guard.factory_mock_,
+                CreateEventBinding(kInstanceIdWithLolaBinding, _, kFieldName))
+        .WillOnce(Return(ByMove(std::move(skeleton_field_binding_mock_ptr))));
+
+    // Set up method binding mock to verify RegisterHandler is called during construction
+    SkeletonMethodBindingFactoryMockGuard skeleton_method_binding_factory_mock_guard{};
+    mock_binding::SkeletonMethod skeleton_method_binding_mock{};
+    EXPECT_CALL(skeleton_method_binding_mock, RegisterHandler(_)).WillOnce(Return(ResultBlank{}));
+    EXPECT_CALL(skeleton_method_binding_factory_mock_guard.factory_mock_, Create(kInstanceIdWithLolaBinding, _, _))
+        .WillOnce(Return(ByMove(std::make_unique<mock_binding::SkeletonMethodFacade>(skeleton_method_binding_mock))));
+
+    // When a skeleton with EnableGet=true field is constructed, RegisterHandler is called automatically
+    MyGetEnabledSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+}
+
 // When Ticket-104261 is implemented, the Update call does not have to be deferred until OfferService is called. This
 // test can be reworked to remove the call to PrepareOffer() and simply test Update() before PrepareOffer() is called.
 TEST(SkeletonFieldCopyUpdateTest, CallingUpdateBeforeOfferServiceDefersCallToOfferService)

From 6db7b14e6d58aed30e74cfcb7fa4f4633430ce56 Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Thu, 19 Mar 2026 12:58:22 +0100
Subject: [PATCH 7/7] mw/com/impl: adds extra field slot when getter/setter is
 enabled

- pass additional_slots through field binding creation
- compute additional_slots from EnableSet || EnableGet
- use configured_slots + additional_slots in event properties
- add unit tests for +1 and default (unchanged) slot count
---
 .../i_skeleton_field_binding_factory.h        |  9 ++++---
 .../plumbing/skeleton_field_binding_factory.h |  6 +++--
 .../skeleton_field_binding_factory_impl.h     | 20 +++++++++------
 .../skeleton_field_binding_factory_mock.h     | 14 ++++++++++-
 ...ton_service_element_binding_factory_impl.h | 18 +++++++++----
 ...n_service_element_binding_factory_test.cpp | 25 +++++++++++++++++++
 score/mw/com/impl/skeleton_field.h            | 12 ++++++---
 7 files changed, 82 insertions(+), 22 deletions(-)

diff --git a/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h b/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h
index 053898253..063ab2164 100644
--- a/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h
+++ b/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h
@@ -18,6 +18,7 @@
 #include "score/mw/com/impl/skeleton_base.h"
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
+#include <cstddef>
 #include <memory>
 #include <string_view>
 
@@ -44,11 +45,13 @@ class ISkeletonFieldBindingFactory
     /// \param identifier The instance identifier containing the binding information.
     /// \param parent A reference to the Skeleton which owns this event.
     /// \param field_name The binding unspecific name of the field inside the skeleton denoted by instance identifier.
+    /// \param additional_slots_for_field_get_set Additional slots to reserve on top of configured sample slots.
     /// \return An instance of SkeletonEventBinding or nullptr in case of an error.
     virtual auto CreateEventBinding(const InstanceIdentifier& identifier,
-                                    SkeletonBase& parent,
-                                    const std::string_view field_name) noexcept
-        -> std::unique_ptr<SkeletonEventBinding<SampleType>> = 0;
+                    SkeletonBase& parent,
+                    const std::string_view field_name,
+                std::size_t additional_slots_for_field_get_set = 0U) noexcept
+      -> std::unique_ptr<SkeletonEventBinding<SampleType>> = 0;
 };
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h b/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h
index 1473748cd..d50aa06df 100644
--- a/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h
+++ b/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h
@@ -23,6 +23,7 @@
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
 #include <functional>
+#include <cstddef>
 #include <memory>
 #include <string_view>
 #include <utility>
@@ -39,9 +40,10 @@ class SkeletonFieldBindingFactory final
     /// \brief See documentation in ISkeletonFieldBindingFactory.
     static std::unique_ptr<SkeletonEventBinding<SampleType>> CreateEventBinding(const InstanceIdentifier& identifier,
                                                                                 SkeletonBase& parent,
-                                                                                const std::string_view field_name)
+                                                                                const std::string_view field_name,
+                                                                                std::size_t additional_slots_for_field_get_set = 0U)
     {
-        return instance().CreateEventBinding(identifier, parent, field_name);
+        return instance().CreateEventBinding(identifier, parent, field_name, additional_slots_for_field_get_set);
     }
 
     /// \brief Inject a mock ISkeletonFieldBindingFactory. If a mock is injected, then all calls on
diff --git a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h
index 34dd2b44a..4edc06c14 100644
--- a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h
+++ b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h
@@ -21,6 +21,7 @@
 #include "score/mw/com/impl/skeleton_base.h"
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
+#include <cstddef>
 #include <memory>
 #include <string_view>
 
@@ -36,7 +37,8 @@ class SkeletonFieldBindingFactoryImpl : public ISkeletonFieldBindingFactory<Samp
     std::unique_ptr<SkeletonEventBinding<SampleType>> CreateEventBinding(
         const InstanceIdentifier& identifier,
         SkeletonBase& parent,
-        const std::string_view field_name) noexcept override;
+        const std::string_view field_name,
+      std::size_t additional_slots_for_field_get_set = 0U) noexcept override;
 };
 
 template <typename SampleType>
@@ -49,13 +51,17 @@ template <typename SampleType>
 // This suppression should be removed after fixing [Ticket-173043](broken_link_j/Ticket-173043)
 // coverity[autosar_cpp14_a15_5_3_violation : FALSE]
 auto SkeletonFieldBindingFactoryImpl<SampleType>::CreateEventBinding(const InstanceIdentifier& identifier,
-                                                                     SkeletonBase& parent,
-                                                                     const std::string_view field_name) noexcept
-    -> std::unique_ptr<SkeletonEventBinding<SampleType>>
+                                   SkeletonBase& parent,
+                                   const std::string_view field_name,
+                                   std::size_t additional_slots_for_field_get_set) noexcept
+  -> std::unique_ptr<SkeletonEventBinding<SampleType>>
 {
-    return CreateSkeletonServiceElement<SkeletonEventBinding<SampleType>,
-                                        lola::SkeletonEvent<SampleType>,
-                                        ServiceElementType::FIELD>(identifier, parent, field_name);
+  return CreateSkeletonServiceElement<SkeletonEventBinding<SampleType>,
+                    lola::SkeletonEvent<SampleType>,
+                    ServiceElementType::FIELD>(identifier,
+                                   parent,
+                                   field_name,
+                                   additional_slots_for_field_get_set);
 }
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h
index 6e9197cb7..1ab93a8ca 100644
--- a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h
+++ b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h
@@ -17,6 +17,8 @@
 
 #include <gmock/gmock.h>
 
+#include <cstddef>
+
 namespace score::mw::com::impl
 {
 
@@ -27,7 +29,17 @@ class SkeletonFieldBindingFactoryMock : public ISkeletonFieldBindingFactory<Samp
     MOCK_METHOD(std::unique_ptr<SkeletonEventBinding<SampleType>>,
                 CreateEventBinding,
                 (const InstanceIdentifier&, SkeletonBase&, const std::string_view),
-                (noexcept, override));
+                (noexcept));
+
+    auto CreateEventBinding(const InstanceIdentifier& identifier,
+                            SkeletonBase& parent,
+                            const std::string_view field_name,
+                std::size_t additional_slots_for_field_get_set) noexcept
+        -> std::unique_ptr<SkeletonEventBinding<SampleType>> override
+    {
+      static_cast<void>(additional_slots_for_field_get_set);
+        return CreateEventBinding(identifier, parent, field_name);
+    }
 };
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h
index 8e776377b..c8a0c5795 100644
--- a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h
+++ b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h
@@ -29,6 +29,7 @@
 #include <score/overload.hpp>
 
 #include <chrono>
+#include <cstddef>
 #include <exception>
 #include <memory>
 #include <string>
@@ -44,7 +45,8 @@ namespace detail
 
 template <typename LolaServiceElementInstanceDeployment>
 lola::SkeletonEventProperties GetSkeletonEventProperties(
-    const LolaServiceElementInstanceDeployment& lola_service_element_instance_deployment)
+    const LolaServiceElementInstanceDeployment& lola_service_element_instance_deployment,
+    std::size_t additional_slots_for_field_get_set = 0U)
 {
     if (!lola_service_element_instance_deployment.GetNumberOfSampleSlots().has_value())
     {
@@ -61,7 +63,11 @@ lola::SkeletonEventProperties GetSkeletonEventProperties(
                "not specified in the configuration. Terminating.";
         std::terminate();
     }
-    return lola::SkeletonEventProperties{lola_service_element_instance_deployment.GetNumberOfSampleSlots().value(),
+    const auto number_of_slots = static_cast<std::size_t>(
+        lola_service_element_instance_deployment.GetNumberOfSampleSlots().value()) +
+        additional_slots_for_field_get_set;
+
+    return lola::SkeletonEventProperties{number_of_slots,
                                          lola_service_element_instance_deployment.max_subscribers_.value(),
                                          lola_service_element_instance_deployment.enforce_max_samples_};
 }
@@ -79,7 +85,8 @@ template <typename SkeletonServiceElementBinding, typename SkeletonServiceElemen
 // coverity[autosar_cpp14_a15_5_3_violation : FALSE]
 auto CreateSkeletonServiceElement(const InstanceIdentifier& identifier,
                                   SkeletonBase& parent,
-                                  const std::string_view service_element_name) noexcept
+                                  const std::string_view service_element_name,
+                                  std::size_t additional_slots_for_field_get_set = 0U) noexcept
     -> std::unique_ptr<SkeletonServiceElementBinding>
 {
     static_assert(element_type != ServiceElementType::INVALID);
@@ -88,7 +95,7 @@ auto CreateSkeletonServiceElement(const InstanceIdentifier& identifier,
 
     using ReturnType = std::unique_ptr<SkeletonServiceElementBinding>;
     auto visitor = score::cpp::overload(
-        [identifier_view, &parent, &service_element_name](
+        [identifier_view, &parent, &service_element_name, additional_slots_for_field_get_set](
             const LolaServiceTypeDeployment& lola_service_type_deployment) -> ReturnType {
             auto* const lola_parent = dynamic_cast<lola::Skeleton*>(SkeletonBaseView{parent}.GetBinding());
             if (lola_parent == nullptr)
@@ -106,7 +113,8 @@ auto CreateSkeletonServiceElement(const InstanceIdentifier& identifier,
             const auto& lola_service_element_instance_deployment = GetServiceElementInstanceDeployment<element_type>(
                 lola_service_instance_deployment, service_element_name_str);
             const auto skeleton_event_properties =
-                detail::GetSkeletonEventProperties(lola_service_element_instance_deployment);
+                detail::GetSkeletonEventProperties(lola_service_element_instance_deployment,
+                                                   additional_slots_for_field_get_set);
 
             const auto lola_service_element_id =
                 GetServiceElementId<element_type>(lola_service_type_deployment, service_element_name_str);
diff --git a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp
index 218192c5b..bd4692ed3 100644
--- a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp
+++ b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp
@@ -138,6 +138,31 @@ INSTANTIATE_TEST_CASE_P(SkeletonServiceElementBindingFactoryParamaterisedDeathTe
 
 TEST_P(SkeletonServiceElementBindingFactoryParamaterisedFixture, CanConstructFixture) {}
 
+class SkeletonServiceElementBindingFactoryFixture : public ::testing::Test
+{
+  protected:
+    const LolaFieldInstanceDeployment field_deployment_{{2U}, {3U}, 1U, true, 0U};
+
+    auto GetSkeletonEventProperties(const std::size_t additional_slots_for_field_get_set = 0U) const
+    {
+        return detail::GetSkeletonEventProperties(field_deployment_, additional_slots_for_field_get_set);
+    }
+};
+
+TEST_F(SkeletonServiceElementBindingFactoryFixture, AdditionalSlotsAreAddedToConfiguredNumberOfSlots)
+{
+    const auto skeleton_event_properties = GetSkeletonEventProperties(1U);
+
+    EXPECT_EQ(skeleton_event_properties.number_of_slots, 3U);
+}
+
+TEST_F(SkeletonServiceElementBindingFactoryFixture, DefaultAdditionalSlotsKeepsConfiguredNumberOfSlots)
+{
+    const auto skeleton_event_properties = GetSkeletonEventProperties();
+
+    EXPECT_EQ(skeleton_event_properties.number_of_slots, 2U);
+}
+
 TEST_P(SkeletonServiceElementBindingFactoryParamaterisedFixture, CanConstructServiceElement)
 {
     RecordProperty("Verifies", "SCR-21803701, SCR-21803702, SCR-5898925");
diff --git a/score/mw/com/impl/skeleton_field.h b/score/mw/com/impl/skeleton_field.h
index 1e7e22346..a949788ed 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -272,7 +272,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonFie
                                                      SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
                                                          SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                                                          parent,
-                                                         field_name),
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
                                                      typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
           std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(parent, std::string(field_name) + "_Set"),
           std::make_unique<SkeletonMethod<Result<FieldType>()>>(parent, std::string(field_name) + "_Get"),
@@ -293,7 +294,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonFie
                                                      SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
                                                          SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                                                          parent,
-                                                         field_name),
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
                                                      typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
           std::make_unique<SkeletonMethod<Result<FieldType>()>>(parent, std::string(field_name) + "_Get"),
           field_name}
@@ -313,7 +315,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonFie
                                                      SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
                                                          SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                                                          parent,
-                                                         field_name),
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
                                                      typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
           std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(parent, std::string(field_name) + "_Set"),
           field_name}
@@ -333,7 +336,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonFie
                                                      SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
                                                          SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                                                          parent,
-                                                         field_name),
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
                                                      typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
           field_name}
 {