Fix deprecation warning

source/RobotAPI/libraries/armem/core/operations.h

@@ -17,11 +17,14 @@ namespace armarx::armem
     std::vector<aron::datanavigator::DictNavigatorPtr>
     getAronData(const wm::EntitySnapshot& snapshot);
 
-    EntityUpdate toEntityUpdate(const wm::EntitySnapshot& snapshot);
+
+    EntityUpdate
+    toEntityUpdate(const wm::EntitySnapshot& snapshot);
 
 
     template <class ContainerT>
-    Commit toCommit(const ContainerT& container)
+    Commit
+    toCommit(const ContainerT& container)
     {
         Commit commit;
         container.forEachSnapshot([&commit](const wm::EntitySnapshot & snapshot)
@@ -33,6 +36,20 @@ namespace armarx::armem
     }
 
 
+    template <class ContainerT>
+    const typename ContainerT::EntityInstanceT*
+    findFirstInstance(const ContainerT& container)
+    {
+        const typename ContainerT::EntityInstanceT* instance = nullptr;
+        container.forEachInstance([&instance](const wm::EntityInstance & i)
+        {
+            instance = &i;
+            return false;
+        });
+        return instance;
+    }
+
+
     std::string print(const wm::Memory& data, int maxDepth = -1, int depth = 0);
     std::string print(const wm::CoreSegment& data, int maxDepth = -1, int depth = 0);
     std::string print(const wm::ProviderSegment& data, int maxDepth = -1, int depth = 0);

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

 #pragma once
 
+#include "detail/data_lookup_mixins.h"
+
 #include <RobotAPI/libraries/armem/core/base/EntityInstanceBase.h>
 #include <RobotAPI/libraries/armem/core/base/EntitySnapshotBase.h>
 #include <RobotAPI/libraries/armem/core/base/EntityBase.h>
@@ -7,7 +9,7 @@
 #include <RobotAPI/libraries/armem/core/base/CoreSegmentBase.h>
 #include <RobotAPI/libraries/armem/core/base/MemoryBase.h>
 
-#include "detail/data_lookup_mixins.h"
+#include <RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h>
 
 
 namespace armarx::armem::wm

source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp

 #include "Writer.h"
 
-#include <mutex>
-#include <optional>
-
-#include <IceUtil/Time.h>
-
 #include <SimoxUtility/algorithm/get_map_keys_values.h>
 
-#include "ArmarXCore/core/exceptions/LocalException.h"
+#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
 #include <ArmarXCore/core/logging/Logging.h>
 
-#include "RobotAPI/libraries/ArmarXObjects/ObjectID.h"
-#include "RobotAPI/libraries/ArmarXObjects/ObjectInfo.h"
+#include <RobotAPI/libraries/ArmarXObjects/ObjectID.h>
+#include <RobotAPI/libraries/ArmarXObjects/ObjectInfo.h>
 #include <RobotAPI/libraries/ArmarXObjects/aron/ObjectID.aron.generated.h>
 #include <RobotAPI/libraries/armem/client/query.h>
 #include <RobotAPI/libraries/armem/core/MemoryID.h>
 #include <RobotAPI/libraries/armem/core/aron_conversions.h>
 #include <RobotAPI/libraries/armem/core/error.h>
+#include <RobotAPI/libraries/armem/core/operations.h>
 #include <RobotAPI/libraries/armem_objects/aron/ObjectClass.aron.generated.h>
 #include <RobotAPI/libraries/armem_objects/aron/ObjectInstance.aron.generated.h>
-#include <RobotAPI/libraries/armem_objects/aron_conversions.h>
 #include <RobotAPI/libraries/armem_robot/aron/Robot.aron.generated.h>
 #include <RobotAPI/libraries/armem_robot/aron/RobotDescription.aron.generated.h>
 #include <RobotAPI/libraries/armem_robot/aron_conversions.h>
@@ -27,6 +22,7 @@
 
 #include "utils.h"
 
+
 namespace armarx::armem::articulated_object
 {
     Writer::Writer(armem::client::MemoryNameSystem& memoryNameSystem) :
@@ -86,7 +82,6 @@ namespace armarx::armem::articulated_object
 
     void Writer::updateKnownObject(const armem::MemoryID& snapshotId)
     {
-
         arondto::RobotDescription aronArticulatedObjectDescription;
         // aronArticulatedObjectDescription.fromAron(snapshotId.ent);
 
@@ -269,59 +264,41 @@ namespace armarx::armem::articulated_object
                 .getCoreSegment(properties.coreClassSegmentName)
                 .getProviderSegment(properties.providerName); // TODO(fabian.reister): all
         // clang-format on
-        const auto entities = simox::alg::get_values(providerSegment.entities());
 
-        if (entities.empty())
+        if (const armem::wm::EntityInstance* instance = findFirstInstance(providerSegment))
         {
-            ARMARX_WARNING << "No entity found";
-            return std::nullopt;
+            return convertRobotDescription(*instance);
         }
-
-        const auto entitySnapshots = simox::alg::get_values(entities.front().history());
-
-        if (entitySnapshots.empty())
+        else
         {
             ARMARX_WARNING << "No entity snapshots found";
             return std::nullopt;
         }
-
-        // TODO(fabian.reister): check if 0 available
-        const armem::wm::EntityInstance& instance = entitySnapshots.front().getInstance(0);
-
-        return convertRobotDescription(instance);
     }
 
     std::unordered_map<std::string, armem::MemoryID>
     Writer::getRobotDescriptions(const armarx::armem::wm::Memory& memory) const
     {
-        std::unordered_map<std::string, armem::MemoryID> descriptions;
-
         const armem::wm::CoreSegment& coreSegment =
             memory.getCoreSegment(properties.coreClassSegmentName);
 
-        for (const auto& [providerName, providerSegment] : coreSegment.providerSegments())
+        std::unordered_map<std::string, armem::MemoryID> descriptions;
+        coreSegment.forEachEntity([&descriptions](const wm::Entity & entity)
         {
-            for (const auto& [name, entity] : providerSegment.entities())
+            if (entity.empty())
             {
-                if (entity.empty())
-                {
-                    ARMARX_WARNING << "No entity found";
-                    continue;
-                }
-
-                const auto entitySnapshots          = simox::alg::get_values(entity.history());
-                const armem::wm::EntitySnapshot& sn = entitySnapshots.front();
-                const armem::wm::EntityInstance& instance = sn.getInstance(0);
-
-                const auto robotDescription = convertRobotDescription(instance);
-
-                if (robotDescription)
-                {
-                    const armem::MemoryID snapshotID(sn.id());
-                    descriptions.insert({robotDescription->name, snapshotID});
-                }
+                ARMARX_WARNING << "No entity found";
+                return true;
             }
-        }
+
+            const armem::wm::EntitySnapshot& sn = entity.getFirstSnapshot();
+            if (const auto robotDescription = convertRobotDescription(sn.getInstance(0)))
+            {
+                const armem::MemoryID snapshotID(sn.id());
+                descriptions.insert({robotDescription->name, snapshotID});
+            }
+            return true;
+        });
 
         return descriptions;
     }

source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h

@@ -22,8 +22,9 @@
 #pragma once
 
 #include <mutex>
+#include <optional>
 
-#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
+#include <ArmarXCore/core/application/properties/forward_declarations.h>
 
 #include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
 #include <RobotAPI/libraries/armem/client/Reader.h>
@@ -39,7 +40,7 @@ namespace armarx::armem::articulated_object
         virtual public WriterInterface
     {
     public:
-        Writer(armem::client::MemoryNameSystem& memoryNameSystem);
+        Writer(armem::client::MemoryNameSystem& memoryNameSystemopti);
         virtual ~Writer() = default;
 
         void registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def);