Revise locking interface

source/RobotAPI/libraries/armem/server/MemoryRemoteGui.cpp

@@ -111,8 +111,10 @@ namespace armarx::armem::server
 
     MemoryRemoteGui::GroupBox MemoryRemoteGui::makeGroupBox(const armem::server::wm::CoreSegment& coreSegment) const
     {
-        std::scoped_lock lock(coreSegment.mutex());
-        return this->_makeGroupBox(coreSegment);
+        return coreSegment.doLocked([this, &coreSegment]()
+        {
+            return this->_makeGroupBox(coreSegment);
+        });
     }
 
 

source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp

@@ -60,20 +60,22 @@ namespace armarx::armem::server
 
         if (input.providerSegmentName.size() > 0)
         {
-            std::scoped_lock lock(coreSegment->mutex());
-            try
-            {
-                coreSegment->addProviderSegment(input.providerSegmentName);
-            }
-            catch (const armem::error::ContainerEntryAlreadyExists&)
+            coreSegment->doLocked([&coreSegment, &input]()
             {
-                // This is ok.
-                if (input.clearWhenExists)
+                try
                 {
-                    server::wm::ProviderSegment& provider = coreSegment->getProviderSegment(input.providerSegmentName);
-                    provider.clear();
+                    coreSegment->addProviderSegment(input.providerSegmentName);
                 }
-            }
+                catch (const armem::error::ContainerEntryAlreadyExists&)
+                {
+                    // This is ok.
+                    if (input.clearWhenExists)
+                    {
+                        server::wm::ProviderSegment& provider = coreSegment->getProviderSegment(input.providerSegmentName);
+                        provider.clear();
+                    }
+                }
+            });
         }
 
         armem::MemoryID segmentID;

source/RobotAPI/libraries/armem/server/query_proc/wm.cpp

@@ -55,8 +55,10 @@ namespace armarx::armem::server::query_proc::wm_server
         const armem::query::data::CoreSegmentQuery& query,
         const CoreSegment& coreSegment) const
     {
-        std::scoped_lock lock(coreSegment.mutex());
-        CoreSegmentQueryProcessorBase::process(result, query, coreSegment);
+        coreSegment.doLocked([&]()
+        {
+            CoreSegmentQueryProcessorBase::process(result, query, coreSegment);
+        });
     }
 
 

source/RobotAPI/libraries/armem/server/segment/Segment.cpp

@@ -48,14 +48,6 @@ namespace armarx::armem::server::segment
     }
 
 
-    std::mutex& wm::CoreSegmentBase::mutex() const
-    {
-        ARMARX_CHECK_NOT_NULL(segment);
-        return segment->mutex();
-    }
-
-
-
     wm::ProviderSegmentBase::ProviderSegmentBase(
         armem::server::MemoryToIceAdapter& iceMemory,
         const std::string& defaultProviderSegmentName,

source/RobotAPI/libraries/armem/server/segment/Segment.h

 #pragma once
 
-// STD/STL
-#include <mutex>
-#include <string>
+#include <RobotAPI/libraries/armem/server/forward_declarations.h>
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
 
-// ArmarX
 #include <ArmarXCore/core/logging/Logging.h>
 #include <ArmarXCore/core/application/properties/forward_declarations.h>
 
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <string>
 
 
-namespace armarx::armem
-{
-    namespace server
-    {
-        class MemoryToIceAdapter;
-
-        namespace wm
-        {
-            class CoreSegment;
-            class ProviderSegment;
-        }
-    }
-}
 namespace armarx::armem::server::segment
 {
     namespace detail
@@ -88,7 +75,11 @@ namespace armarx::armem::server::segment
             // virtual void onConnect() override;
 
 
-            std::mutex& mutex() const;
+            template <class FunctionT>
+            auto doLocked(FunctionT&& function)
+            {
+                return segment->doLocked(function);
+            }
 
 
         protected:

source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.cpp

@@ -12,11 +12,11 @@ namespace armarx::armem::server::segment
 {
 
     SpecializedSegment::SpecializedSegment(
-            server::MemoryToIceAdapter& iceMemory,
-            aron::typenavigator::ObjectNavigatorPtr aronType,
-            const std::string& defaultCoreSegmentName,
-            int64_t defaultMaxHistorySize
-            ) :
+        server::MemoryToIceAdapter& iceMemory,
+        aron::typenavigator::ObjectNavigatorPtr aronType,
+        const std::string& defaultCoreSegmentName,
+        int64_t defaultMaxHistorySize
+    ) :
         iceMemory(iceMemory), aronType(aronType)
     {
         setDefaultCoreSegmentName(defaultCoreSegmentName);
@@ -52,13 +52,6 @@ namespace armarx::armem::server::segment
     }
 
 
-    std::mutex& SpecializedSegment::mutex() const
-    {
-        ARMARX_CHECK_NOT_NULL(coreSegment);
-        return coreSegment->mutex();
-    }
-
-
     void SpecializedSegment::setDefaultCoreSegmentName(const std::string& coreSegmentName)
     {
         this->properties.coreSegmentName = coreSegmentName;

source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.h

 #pragma once
 
-#include <mutex>
-#include <string>
+#include <RobotAPI/libraries/armem/server/forward_declarations.h>
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
 
 #include <ArmarXCore/core/application/properties/forward_declarations.h>
 #include <ArmarXCore/core/logging/Logging.h>
 
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
-
-
-namespace armarx::armem
-{
-    namespace server
-    {
-        class MemoryToIceAdapter;
+#include <string>
 
-        namespace wm
-        {
-            class CoreSegment;
-        }
-    }
-}
 
 namespace armarx::armem::server::segment
 {
@@ -46,7 +34,12 @@ namespace armarx::armem::server::segment
         virtual void init();
         // void connect();
 
-        std::mutex& mutex() const;
+
+        template <class FunctionT>
+        auto doLocked(FunctionT&& function)
+        {
+            return coreSegment->doLocked(function);
+        }
 
 
     protected:

source/RobotAPI/libraries/armem/server/wm/memory_definitions.cpp

@@ -43,36 +43,6 @@ namespace armarx::armem::server::wm
     }
 
 
-
-    std::mutex& CoreSegment::mutex() const
-    {
-        return _mutex;
-    }
-
-
-
-    std::optional<wm::EntitySnapshot>
-    CoreSegment::getLatestEntitySnapshotLocking(const MemoryID& entityID) const
-    {
-        std::scoped_lock lock(_mutex);
-        return getLatestEntitySnapshot(entityID);
-    }
-
-    std::optional<wm::EntityInstance>
-    CoreSegment::getLatestEntityInstanceLocking(const MemoryID& entityID, int instanceIndex) const
-    {
-        std::scoped_lock lock(_mutex);
-        return getLatestEntityInstance(entityID, instanceIndex);
-    }
-
-    armarx::aron::datanavigator::DictNavigatorPtr
-    CoreSegment::getLatestEntityInstanceDataLocking(const MemoryID& entityID, int instanceIndex) const
-    {
-        std::scoped_lock lock(_mutex);
-        return getLatestEntityInstanceData(entityID, instanceIndex);
-    }
-
-
     // TODO: add core segment if param is set
     std::vector<Memory::Base::UpdateResult>
     Memory::updateLocking(const Commit& commit)
@@ -95,15 +65,16 @@ namespace armarx::armem::server::wm
                 CoreSegment& coreSegment = it->second;
 
                 // Lock the core segment for the whole batch.
-                std::scoped_lock lock(coreSegment.mutex());
-
-                for (const EntityUpdate* update : updates)
+                coreSegment.doLocked([&result, &coreSegment, updates = &updates]()
                 {
-                    auto r = coreSegment.update(*update);
-                    Base::UpdateResult ret { r };
-                    ret.memoryUpdateType = UpdateType::UpdatedExisting;
-                    result.push_back(ret);
-                }
+                    for (const EntityUpdate* update : *updates)
+                    {
+                        auto r = coreSegment.update(*update);
+                        Base::UpdateResult ret { r };
+                        ret.memoryUpdateType = UpdateType::UpdatedExisting;
+                        result.push_back(ret);
+                    }
+                });
             }
             else
             {
@@ -129,10 +100,10 @@ namespace armarx::armem::server::wm
 
         CoreSegment& segment = getCoreSegment(update.entityID.coreSegmentName);
         Base::UpdateResult result;
+        segment.doLocked([&result, &segment, &update]()
         {
-            std::scoped_lock lock(segment.mutex());
             result = segment.update(update);
-        }
+        });
         result.memoryUpdateType = UpdateType::UpdatedExisting;
         return result;
     }

source/RobotAPI/libraries/armem/server/wm/memory_definitions.h

@@ -10,6 +10,8 @@
 #include <RobotAPI/libraries/armem/core/base/CoreSegmentBase.h>
 #include <RobotAPI/libraries/armem/core/base/MemoryBase.h>
 
+#include <RobotAPI/libraries/armem/core/wm/detail/data_lookup_mixins.h>
+
 #include <mutex>
 #include <optional>
 
@@ -28,6 +30,7 @@ namespace armarx::armem::server::wm
     class Entity :
         public base::EntityBase<EntitySnapshot, Entity>
         , public detail::MaxHistorySize
+        , public armem::wm::detail::FindInstanceDataMixin<Entity>
     {
     public:
 
@@ -55,8 +58,9 @@ namespace armarx::armem::server::wm
 
     /// @see base::ProviderSegmentBase
     class ProviderSegment :
-        public base::ProviderSegmentBase<Entity, ProviderSegment>,
-        public detail::MaxHistorySizeParent<ProviderSegment>
+        public base::ProviderSegmentBase<Entity, ProviderSegment>
+        , public detail::MaxHistorySizeParent<ProviderSegment>
+        , public armem::wm::detail::FindInstanceDataMixin<ProviderSegment>
     {
     public:
 
@@ -81,6 +85,7 @@ namespace armarx::armem::server::wm
     class CoreSegment :
         public base::CoreSegmentBase<ProviderSegment, CoreSegment>,
         public detail::MaxHistorySizeParent<CoreSegment>
+        , public armem::wm::detail::FindInstanceDataMixin<CoreSegment>
     {
         using Base = base::CoreSegmentBase<ProviderSegment, CoreSegment>;
 
@@ -88,38 +93,6 @@ namespace armarx::armem::server::wm
 
         using Base::CoreSegmentBase;
 
-        // ToDo: Replace by runLocked()
-        std::mutex& mutex() const;
-
-
-        // Non-locking interface
-
-        std::optional<wm::EntitySnapshot> getLatestEntitySnapshot(
-            const MemoryID& entityID) const;
-        std::optional<wm::EntityInstance> getLatestEntityInstance(
-            const MemoryID& entityID, int instanceIndex = 0) const;
-        armarx::aron::datanavigator::DictNavigatorPtr getLatestEntityInstanceData(
-            const MemoryID& entityID, int instanceIndex = 0) const;
-
-
-        template <class AronDtoT>
-        std::optional<AronDtoT> getLatestEntityInstanceDataAs(
-            const MemoryID& entityID, int instanceIndex = 0) const
-        {
-            wm::EntityInstanceDataPtr data = getLatestEntityInstanceData(entityID, instanceIndex);
-            if (data)
-            {
-                AronDtoT aron;
-                aron.fromAron(data);
-                return aron;
-            }
-            else
-            {
-                return std::nullopt;
-            }
-        }
-
-
         /// @see base::CoreSegmentBase::addProviderSegment()
         using CoreSegmentBase::addProviderSegment;
         template <class ...Args>
@@ -133,38 +106,15 @@ namespace armarx::armem::server::wm
 
         // Locking interface
 
-        std::optional<wm::EntitySnapshot> getLatestEntitySnapshotLocking(
-            const MemoryID& entityID) const;
-        std::optional<wm::EntityInstance> getLatestEntityInstanceLocking(
-            const MemoryID& entityID, int instanceIndex = 0) const;
-        armarx::aron::datanavigator::DictNavigatorPtr getLatestEntityInstanceDataLocking(
-            const MemoryID& entityID, int instanceIndex = 0) const;
-
-
-        template <class AronDtoT>
-        std::optional<AronDtoT> getLatestEntityInstanceDataLockingAs(
-            const MemoryID& entityID, int instanceIndex = 0) const
+        template <class FunctionT>
+        auto doLocked(FunctionT&& function) const
         {
-            // Keep lock to a minimum.
-            wm::EntityInstanceDataPtr data = nullptr;
-            {
-                std::scoped_lock lock(_mutex);
-                data = getLatestEntityInstanceData(entityID, instanceIndex);
-            }
-            if (data)
-            {
-                AronDtoT aron;
-                aron.fromAron(data);
-                return aron;
-            }
-            else
-            {
-                return std::nullopt;
-            }
+            std::scoped_lock lock(_mutex);
+            return function();
         }
 
 
-    protected:
+    private:
 
         mutable std::mutex _mutex;
 
@@ -175,6 +125,7 @@ namespace armarx::armem::server::wm
     /// @see base::MemoryBase
     class Memory :
         public base::MemoryBase<CoreSegment, Memory>
+        , public armem::wm::detail::FindInstanceDataMixin<Memory>
     {
         using Base = base::MemoryBase<CoreSegment, Memory>;
 

source/RobotAPI/libraries/armem/test/ArMemForEachTest.cpp

@@ -27,6 +27,7 @@
 #include <RobotAPI/Test.h>
 #include <RobotAPI/libraries/armem/core/Commit.h>
 #include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+#include <RobotAPI/libraries/armem/core/operations.h>
 
 #include <iostream>
 #include <set>
@@ -98,7 +99,7 @@ BOOST_AUTO_TEST_CASE(test_forEach)
     BOOST_CHECK_GT(pids.size(), 0);
     BOOST_CHECK_GT(cids.size(), 0);
 
-    BOOST_TEST_MESSAGE("Memory: \n" << memory.dump());
+    BOOST_TEST_MESSAGE("Memory: \n" << armem::print(memory));
 
     memory.forEachInstance([&](const wm::EntityInstance & i) -> bool
     {

source/RobotAPI/libraries/armem/test/ArMemMemoryTest.cpp

@@ -499,7 +499,7 @@ struct CopyMoveCtorsOpsTest : public CopyMoveCtorsOpsTestBase
                      || std::is_same_v<T, armem::ltm::Memory>
                      || std::is_same_v<T, armem::d_ltm::Memory>)
         {
-            in._addMissingCoreSegmentDuringUpdate = true;
+            in.addCoreSegment("C");
         }
         {
             armem::EntityUpdate update;

source/RobotAPI/libraries/armem/test/ArMemQueryTest.cpp

@@ -123,8 +123,9 @@ BOOST_AUTO_TEST_CASE(test_entity_Single_latest)
     {
         BOOST_CHECK_EQUAL(result.name(), entity.name());
         BOOST_CHECK_EQUAL(result.size(), 1);
-        const armem::wm::EntitySnapshot& first = result.getFirstSnapshotAfterOrAt(armem::Time::microSeconds(0));
-        BOOST_CHECK_EQUAL(first.time(), armem::Time::microSeconds(5000));
+        const armem::wm::EntitySnapshot* first = result.findFirstSnapshotAfterOrAt(armem::Time::microSeconds(0));
+        BOOST_REQUIRE_NE(first, nullptr);
+        BOOST_CHECK_EQUAL(first->time(), armem::Time::microSeconds(5000));
     }
 }
 

source/RobotAPI/libraries/armem_objects/server/class/Segment.cpp

@@ -124,8 +124,11 @@ namespace armarx::armem::server::obj::clazz
         {
             try
             {
-                std::optional<arondto::ObjectClass> aron =
-                    coreSegment->getLatestEntityInstanceDataLockingAs<arondto::ObjectClass>(entityID, 0);
+                std::optional<arondto::ObjectClass> aron = coreSegment->doLocked([&coreSegment, &entity]()
+                {
+                    return coreSegment->findLatestInstanceDataAs<arondto::ObjectClass>(entityID, 0);
+                });
+
                 if (not aron.has_value())
                 {
                     return;