refactor: update score/mw/com includes and namespaces for local memory

Update #include paths and namespace references in score/mw/com sources to
reflect that AtomicIndirector and related types are now accessed via
concurrency::atomic:: rather than memory::shared:: following the in-tree
copy of the score/memory library.

Author: KrishaDeshkool

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

@@ -142,12 +142,12 @@ std::optional<pid_t> RegisterPid(score::containers::DynamicArray<ApplicationIdPi
 
 /// Instantiate the method templates once for AtomicIndirectorReal (production use) and AtomicIndirectorMock (testing)
 /// Those are all instantiations we need, so we are able to put the template definitions into the .cpp file.
-template std::optional<pid_t> RegisterPid<memory::shared::AtomicIndirectorMock>(
+template std::optional<pid_t> RegisterPid<concurrency::atomic::AtomicIndirectorMock>(
     score::containers::DynamicArray<ApplicationIdPidMappingEntry>::iterator entries_begin,
     score::containers::DynamicArray<ApplicationIdPidMappingEntry>::iterator entries_end,
     const std::uint32_t application_id,
     const pid_t pid);
-template std::optional<pid_t> RegisterPid<memory::shared::AtomicIndirectorReal>(
+template std::optional<pid_t> RegisterPid<concurrency::atomic::AtomicIndirectorReal>(
     score::containers::DynamicArray<ApplicationIdPidMappingEntry>::iterator entries_begin,
     score::containers::DynamicArray<ApplicationIdPidMappingEntry>::iterator entries_end,
     const std::uint32_t application_id,

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

@@ -17,7 +17,7 @@
 #include "score/mw/com/impl/bindings/lola/register_pid_fake.h"
 
 #include "score/containers/dynamic_array.h"
-#include "score/memory/shared/atomic_indirector.h"
+#include "score/concurrency/atomic/atomic_indirector.h"
 
 #include <sys/types.h>
 #include <cstdint>
@@ -38,7 +38,7 @@ namespace detail
 // Suppress "AUTOSAR C++14 M3-2-3" rule finding. This rule states: "A type, object or function that is used in multiple
 // translation units shall be declared in one and only one file.".
 // coverity[autosar_cpp14_m3_2_3_violation] This is false positive. Function is declared only once.
-template <template <class> class AtomicIndirectorType = memory::shared::AtomicIndirectorReal>
+template <template <class> class AtomicIndirectorType = concurrency::atomic::AtomicIndirectorReal>
 // coverity[autosar_cpp14_m3_2_3_violation] This is false positive. Function is declared only once.
 std::optional<pid_t> RegisterPid(score::containers::DynamicArray<ApplicationIdPidMappingEntry>::iterator entries_begin,
                                  score::containers::DynamicArray<ApplicationIdPidMappingEntry>::iterator entries_end,
@@ -111,7 +111,7 @@ class ApplicationIdPidMapping
         // element. Therefore, the provided assertions check this rule requirement, whether the iterators return a
         // result other than nullptr.
         // coverity[autosar_cpp14_a5_3_2_violation]
-        return detail::RegisterPid<memory::shared::AtomicIndirectorReal>(
+        return detail::RegisterPid<concurrency::atomic::AtomicIndirectorReal>(
             mapping_entries_.begin(), mapping_entries_.end(), application_id, pid);
     };
 

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

@@ -12,8 +12,8 @@
  ********************************************************************************/
 #include "score/mw/com/impl/bindings/lola/application_id_pid_mapping.h"
 
-#include "score/memory/shared/atomic_indirector.h"
-#include "score/memory/shared/atomic_mock.h"
+#include "score/concurrency/atomic/atomic_indirector.h"
+#include "score/concurrency/atomic/atomic_mock.h"
 
 #include <gtest/gtest.h>
 
@@ -71,15 +71,15 @@ TEST(ApplicationIdPidMapping, RegisterMaxRetryFailure)
         }
     }
 
-    memory::shared::AtomicMock<ApplicationIdPidMappingEntry::key_type> atomic_mock{};
-    memory::shared::AtomicIndirectorMock<ApplicationIdPidMappingEntry::key_type>::SetMockObject(&atomic_mock);
+    concurrency::atomic::AtomicMock<ApplicationIdPidMappingEntry::key_type> atomic_mock{};
+    concurrency::atomic::AtomicIndirectorMock<ApplicationIdPidMappingEntry::key_type>::SetMockObject(&atomic_mock);
 
     const std::size_t kMaxRetries{50};
     // Given the operation to update the mapping entry fails kMaxRetries times
     EXPECT_CALL(atomic_mock, compare_exchange_weak(_, _, _)).Times(kMaxRetries).WillRepeatedly(Return(false));
 
     // when trying to register a new application_id 42 (not among the registered application_ids)
-    auto result = lola::detail::RegisterPid<memory::shared::AtomicIndirectorMock>(
+    auto result = lola::detail::RegisterPid<concurrency::atomic::AtomicIndirectorMock>(
         mapping_entries.begin(), mapping_entries.end(), 42, 142);
     // expect, that an empty optional is returned.
     EXPECT_FALSE(result.has_value());

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

@@ -449,7 +449,7 @@ auto EventDataControlImpl<AtomicIndirectorType>::ResetPerformanceCounters() -> v
     num_ref_retries.store(0U);
 }
 
-template class EventDataControlImpl<memory::shared::AtomicIndirectorReal>;
-template class EventDataControlImpl<memory::shared::AtomicIndirectorMock>;
+template class EventDataControlImpl<concurrency::atomic::AtomicIndirectorReal>;
+template class EventDataControlImpl<concurrency::atomic::AtomicIndirectorMock>;
 
 }  // namespace score::mw::com::impl::lola::detail_event_data_control

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

@@ -23,7 +23,7 @@
 #include "score/memory/shared/memory_resource_proxy.h"
 #include "score/memory/shared/polymorphic_offset_ptr_allocator.h"
 
-#include "score/memory/shared/atomic_indirector.h"
+#include "score/concurrency/atomic/atomic_indirector.h"
 
 #include "score/containers/dynamic_array.h"
 
@@ -65,7 +65,7 @@ namespace detail_event_data_control
 /// a process).
 ///
 /// It is one of the corner stone elements of our LoLa IPC for Events!
-template <template <class> class AtomicIndirectorType = memory::shared::AtomicIndirectorReal>
+template <template <class> class AtomicIndirectorType = concurrency::atomic::AtomicIndirectorReal>
 class EventDataControlImpl final
 {
     // Suppress "AUTOSAR C++14 A11-3-1", The rule declares: "Friend declarations shall not be used".

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

@@ -342,7 +342,7 @@ EventSlotStatus::EventTimeStamp EventDataControlComposite<AtomicIndirectorType>:
     return latest_time_stamp;
 }
 
-template class EventDataControlComposite<memory::shared::AtomicIndirectorReal>;
-template class EventDataControlComposite<memory::shared::AtomicIndirectorMock>;
+template class EventDataControlComposite<concurrency::atomic::AtomicIndirectorReal>;
+template class EventDataControlComposite<concurrency::atomic::AtomicIndirectorMock>;
 
 }  // namespace score::mw::com::impl::lola

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

@@ -18,7 +18,7 @@
 #include "score/mw/com/impl/bindings/lola/event_data_control.h"
 #include "score/mw/com/impl/bindings/lola/event_slot_status.h"
 
-#include "score/memory/shared/atomic_indirector.h"
+#include "score/concurrency/atomic/atomic_indirector.h"
 
 #include <optional>
 #include <tuple>
@@ -36,7 +36,7 @@ class EventDataControlCompositeAttorney;
 /// whole codebase, we implemented this composite which takes care of setting the status correctly in all underlying
 /// control structures. Please be aware that the control structures will live in different shared memory segments, thus
 /// it is not possible to store them by value, but rather as pointer.
-template <template <class> class AtomicIndirectorType = memory::shared::AtomicIndirectorReal>
+template <template <class> class AtomicIndirectorType = concurrency::atomic::AtomicIndirectorReal>
 class EventDataControlComposite
 {
     // Suppress "AUTOSAR C++14 A11-3-1", The rule declares: "Friend declarations shall not be used".

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

@@ -16,8 +16,8 @@
 #include "score/mw/com/impl/bindings/lola/transaction_log_set.h"
 #include "score/mw/com/impl/instance_specifier.h"
 
-#include "score/memory/shared/atomic_indirector.h"
-#include "score/memory/shared/atomic_mock.h"
+#include "score/concurrency/atomic/atomic_indirector.h"
+#include "score/concurrency/atomic/atomic_mock.h"
 #include "score/memory/shared/new_delete_delegate_resource.h"
 
 #include <score/assert.hpp>
@@ -104,12 +104,12 @@ class EventDataControlCompositeFixture : public ::testing::Test
     {
         SCORE_LANGUAGE_FUTURECPP_ASSERT(qm_ != nullptr);
 
-        atomic_mock_ = std::make_unique<memory::shared::AtomicMock<EventSlotStatus::value_type>>();
-        memory::shared::AtomicIndirectorMock<EventSlotStatus::value_type>::SetMockObject(atomic_mock_.get());
+        atomic_mock_ = std::make_unique<concurrency::atomic::AtomicMock<EventSlotStatus::value_type>>();
+        concurrency::atomic::AtomicIndirectorMock<EventSlotStatus::value_type>::SetMockObject(atomic_mock_.get());
 
         auto* const asil_control = asil_ != nullptr ? asil_.get() : nullptr;
-        unit_mock_ =
-            std::make_unique<EventDataControlComposite<memory::shared::AtomicIndirectorMock>>(qm_.get(), asil_control);
+        unit_mock_ = std::make_unique<EventDataControlComposite<concurrency::atomic::AtomicIndirectorMock>>(
+            qm_.get(), asil_control);
 
         return *this;
     }
@@ -160,8 +160,8 @@ class EventDataControlCompositeFixture : public ::testing::Test
     std::unique_ptr<EventDataControl> qm_{nullptr};
     std::unique_ptr<EventDataControlComposite<>> unit_{nullptr};
 
-    std::unique_ptr<memory::shared::AtomicMock<EventSlotStatus::value_type>> atomic_mock_{nullptr};
-    std::unique_ptr<EventDataControlComposite<memory::shared::AtomicIndirectorMock>> unit_mock_{nullptr};
+    std::unique_ptr<concurrency::atomic::AtomicMock<EventSlotStatus::value_type>> atomic_mock_{nullptr};
+    std::unique_ptr<EventDataControlComposite<concurrency::atomic::AtomicIndirectorMock>> unit_mock_{nullptr};
 
     std::unique_ptr<TransactionLogSet::TransactionLogIndex> transaction_log_index_qm_{nullptr};
     std::unique_ptr<TransactionLogSet::TransactionLogIndex> transaction_log_index_asil_{nullptr};

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

@@ -17,8 +17,8 @@
 #include "score/mw/com/impl/bindings/lola/test_doubles/fake_memory_resource.h"
 #include "score/mw/com/impl/instance_specifier.h"
 
-#include "score/memory/shared/atomic_indirector.h"
-#include "score/memory/shared/atomic_mock.h"
+#include "score/concurrency/atomic/atomic_indirector.h"
+#include "score/concurrency/atomic/atomic_mock.h"
 
 #include <score/utility.hpp>
 
@@ -88,7 +88,7 @@ class EventDataControlFixture : public ::testing::Test
 
     void TearDown() override
     {
-        memory::shared::AtomicIndirectorMock<EventSlotStatus::value_type>::SetMockObject(nullptr);
+        concurrency::atomic::AtomicIndirectorMock<EventSlotStatus::value_type>::SetMockObject(nullptr);
     }
 
     EventDataControlFixture& GivenARealEventDataControl(
@@ -104,12 +104,12 @@ class EventDataControlFixture : public ::testing::Test
         const SlotIndexType max_slots,
         const LolaEventInstanceDeployment::SubscriberCountType max_subscribers)
     {
-        atomic_mock_ = std::make_unique<memory::shared::AtomicMock<EventSlotStatus::value_type>>();
-        memory::shared::AtomicIndirectorMock<EventSlotStatus::value_type>::SetMockObject(atomic_mock_.get());
+        atomic_mock_ = std::make_unique<concurrency::atomic::AtomicMock<EventSlotStatus::value_type>>();
+        concurrency::atomic::AtomicIndirectorMock<EventSlotStatus::value_type>::SetMockObject(atomic_mock_.get());
 
-        unit_mock_ =
-            std::make_unique<detail_event_data_control::EventDataControlImpl<memory::shared::AtomicIndirectorMock>>(
-                max_slots, memory_, max_subscribers);
+        unit_mock_ = std::make_unique<
+            detail_event_data_control::EventDataControlImpl<concurrency::atomic::AtomicIndirectorMock>>(
+            max_slots, memory_, max_subscribers);
 
         return *this;
     }
@@ -124,9 +124,9 @@ class EventDataControlFixture : public ::testing::Test
     }
 
     FakeMemoryResource memory_{};
-    std::unique_ptr<memory::shared::AtomicMock<EventSlotStatus::value_type>> atomic_mock_{nullptr};
-    std::unique_ptr<detail_event_data_control::EventDataControlImpl<memory::shared::AtomicIndirectorMock>> unit_mock_{
-        nullptr};
+    std::unique_ptr<concurrency::atomic::AtomicMock<EventSlotStatus::value_type>> atomic_mock_{nullptr};
+    std::unique_ptr<detail_event_data_control::EventDataControlImpl<concurrency::atomic::AtomicIndirectorMock>>
+        unit_mock_{nullptr};
     std::unique_ptr<EventDataControl> unit_{nullptr};
 };
 

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

@@ -164,8 +164,8 @@ auto EventSubscriptionControlImpl<AtomicIndirectorType>::Unsubscribe(SlotNumberT
     std::terminate();
 }
 
-template class EventSubscriptionControlImpl<memory::shared::AtomicIndirectorReal>;
-template class EventSubscriptionControlImpl<memory::shared::AtomicIndirectorMock>;
+template class EventSubscriptionControlImpl<concurrency::atomic::AtomicIndirectorReal>;
+template class EventSubscriptionControlImpl<concurrency::atomic::AtomicIndirectorMock>;
 
 }  // namespace detail_event_subscription_control