From 42d2aa93e8b06ab861354cad1f7860a26f37682b Mon Sep 17 00:00:00 2001
From: Fabian Reister <fabian.reister@kit.edu>
Date: Fri, 16 Feb 2024 08:47:36 +0100
Subject: [PATCH] adapting articulated object reader and writer

---
 .../libraries/armem/client/Writer.cpp         | 82 +++++++++++--------
 .../RobotAPI/libraries/armem/client/Writer.h  | 20 ++---
 .../ArticulatedObjectReader.h                 |  7 +-
 .../client/articulated_object/Reader.cpp      | 13 ++-
 .../client/articulated_object/Reader.h        | 24 +++---
 .../client/articulated_object/Writer.cpp      |  8 +-
 .../client/articulated_object/Writer.h        | 16 ++--
 .../client/articulated_object/interfaces.h    | 21 +++--
 8 files changed, 108 insertions(+), 83 deletions(-)

diff --git a/source/RobotAPI/libraries/armem/client/Writer.cpp b/source/RobotAPI/libraries/armem/client/Writer.cpp
index e9b06f66e..727c1ff19 100644
--- a/source/RobotAPI/libraries/armem/client/Writer.cpp
+++ b/source/RobotAPI/libraries/armem/client/Writer.cpp
@@ -5,7 +5,6 @@
 
 #include "../error.h"
 
-
 namespace armarx::armem::client
 {
 
@@ -13,7 +12,10 @@ namespace armarx::armem::client
     {
     }
 
-    data::AddSegmentResult Writer::addSegment(const std::string& coreSegmentName, const std::string& providerSegmentName, bool clearWhenExists)
+    data::AddSegmentResult
+    Writer::addSegment(const std::string& coreSegmentName,
+                       const std::string& providerSegmentName,
+                       bool clearWhenExists) const
     {
         data::AddSegmentInput input;
         input.coreSegmentName = coreSegmentName;
@@ -22,24 +24,30 @@ namespace armarx::armem::client
         return addSegment(input);
     }
 
-    data::AddSegmentResult Writer::addSegment(const MemoryID& providerSegmentID, bool clearWhenExists)
+    data::AddSegmentResult
+    Writer::addSegment(const MemoryID& providerSegmentID, bool clearWhenExists) const
     {
-        return addSegment(providerSegmentID.coreSegmentName, providerSegmentID.providerSegmentName, clearWhenExists);
+        return addSegment(providerSegmentID.coreSegmentName,
+                          providerSegmentID.providerSegmentName,
+                          clearWhenExists);
     }
 
-    data::AddSegmentResult Writer::addSegment(const std::pair<std::string, std::string>& names, bool clearWhenExists)
+    data::AddSegmentResult
+    Writer::addSegment(const std::pair<std::string, std::string>& names, bool clearWhenExists) const
     {
         return addSegment(names.first, names.second, clearWhenExists);
     }
 
-    data::AddSegmentResult Writer::addSegment(const data::AddSegmentInput& input)
+    data::AddSegmentResult
+    Writer::addSegment(const data::AddSegmentInput& input) const
     {
         data::AddSegmentsResult results = addSegments({input});
         ARMARX_CHECK_EQUAL(results.size(), 1);
         return results.at(0);
     }
 
-    data::AddSegmentsResult Writer::addSegments(const data::AddSegmentsInput& inputs)
+    data::AddSegmentsResult
+    Writer::addSegments(const data::AddSegmentsInput& inputs) const
     {
         ARMARX_CHECK_NOT_NULL(memory);
         data::AddSegmentsResult results = memory->addSegments(inputs);
@@ -47,8 +55,8 @@ namespace armarx::armem::client
         return results;
     }
 
-
-    CommitResult Writer::commit(const Commit& commit)
+    CommitResult
+    Writer::commit(const Commit& commit) const
     {
         ARMARX_CHECK_NOT_NULL(memory);
 
@@ -63,15 +71,15 @@ namespace armarx::armem::client
         return result;
     }
 
-
-    data::CommitResult Writer::commit(const data::Commit& _commit)
+    data::CommitResult
+    Writer::commit(const data::Commit& _commit) const
     {
         data::Commit commit = _commit;
         return this->_commit(commit);
     }
 
-
-    EntityUpdateResult Writer::commit(const EntityUpdate& update)
+    EntityUpdateResult
+    Writer::commit(const EntityUpdate& update) const
     {
         armem::Commit commit;
         commit.updates.push_back(update);
@@ -81,10 +89,10 @@ namespace armarx::armem::client
         return result.results.at(0);
     }
 
-    EntityUpdateResult Writer::commit(
-        const MemoryID& entityID,
-        const std::vector<aron::data::DictPtr>& instancesData,
-        Time referencedTime)
+    EntityUpdateResult
+    Writer::commit(const MemoryID& entityID,
+                   const std::vector<aron::data::DictPtr>& instancesData,
+                   Time referencedTime) const
     {
         EntityUpdate update;
         update.entityID = entityID;
@@ -99,7 +107,8 @@ namespace armarx::armem::client
         this->memory = memory;
     }
 
-    data::CommitResult Writer::_commit(data::Commit& commit)
+    data::CommitResult
+    Writer::_commit(data::Commit& commit) const
     {
         ARMARX_CHECK_NOT_NULL(memory);
 
@@ -119,11 +128,11 @@ namespace armarx::armem::client
         }
 
         data::CommitResult result;
-        auto handleError = [&commit, &result](const std::string & what)
+        auto handleError = [&commit, &result](const std::string& what)
         {
             for (const auto& _ : commit.updates)
             {
-                (void) _;
+                (void)_;
                 data::EntityUpdateResult& r = result.results.emplace_back();
                 r.success = false;
                 r.errorMessage = "Memory component not registered.\n" + std::string(what);
@@ -149,18 +158,20 @@ namespace armarx::armem::client
 
         return result;
     }
-}
+} // namespace armarx::armem::client
 
-
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentInput& rhs)
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentInput& rhs)
 {
     return os << "AddSegmentInput: "
-           << "\n- core segment:     \t'" << rhs.coreSegmentName << "'"
-           << "\n- provider segment: \t'" << rhs.providerSegmentName << "'"
-           << "\n- clear when exists:\t"  << rhs.clearWhenExists << ""
-           << "\n";
+              << "\n- core segment:     \t'" << rhs.coreSegmentName << "'"
+              << "\n- provider segment: \t'" << rhs.providerSegmentName << "'"
+              << "\n- clear when exists:\t" << rhs.clearWhenExists << ""
+              << "\n";
 }
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsInput& rhs)
+
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsInput& rhs)
 {
     for (size_t i = 0; i < rhs.size(); ++i)
     {
@@ -168,15 +179,18 @@ std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegment
     }
     return os;
 }
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentResult& rhs)
+
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentResult& rhs)
 {
     return os << "AddSegmentResult:"
-           << "\n- success:       \t" << rhs.success
-           << "\n- segment ID:    \t'" << rhs.segmentID << "'"
-           << "\n- error message: \t"  << rhs.errorMessage
-           << "\n";
+              << "\n- success:       \t" << rhs.success << "\n- segment ID:    \t'" << rhs.segmentID
+              << "'"
+              << "\n- error message: \t" << rhs.errorMessage << "\n";
 }
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsResult& rhs)
+
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsResult& rhs)
 {
     for (size_t i = 0; i < rhs.size(); ++i)
     {
diff --git a/source/RobotAPI/libraries/armem/client/Writer.h b/source/RobotAPI/libraries/armem/client/Writer.h
index 61eeef93b..65d405a37 100644
--- a/source/RobotAPI/libraries/armem/client/Writer.h
+++ b/source/RobotAPI/libraries/armem/client/Writer.h
@@ -32,28 +32,28 @@ namespace armarx::armem::client
 
         data::AddSegmentResult addSegment(const std::string& coreSegmentName,
                                           const std::string& providerSegmentName,
-                                          bool clearWhenExists = false);
+                                          bool clearWhenExists = false) const;
         data::AddSegmentResult addSegment(const MemoryID& providerSegmentID,
-                                          bool clearWhenExists = false);
+                                          bool clearWhenExists = false) const;
         data::AddSegmentResult addSegment(const std::pair<std::string, std::string>& names,
-                                          bool clearWhenExists = false);
-        data::AddSegmentResult addSegment(const data::AddSegmentInput& input);
-        data::AddSegmentsResult addSegments(const data::AddSegmentsInput& input);
+                                          bool clearWhenExists = false) const;
+        data::AddSegmentResult addSegment(const data::AddSegmentInput& input) const;
+        data::AddSegmentsResult addSegments(const data::AddSegmentsInput& input) const;
 
 
         /**
          * @brief Writes a `Commit` to the memory.
          */
-        CommitResult commit(const Commit& commit);
+        CommitResult commit(const Commit& commit) const;
         /// Commit a single entity update.
-        EntityUpdateResult commit(const EntityUpdate& update);
+        EntityUpdateResult commit(const EntityUpdate& update) const;
         /// Commit a single entity update.
         EntityUpdateResult commit(const MemoryID& entityID,
                                   const std::vector<aron::data::DictPtr>& instancesData,
-                                  Time referencedTime);
+                                  Time referencedTime) const;
 
         // with bare-ice types
-        data::CommitResult commit(const data::Commit& commit);
+        data::CommitResult commit(const data::Commit& commit) const;
 
 
         void setWritingMemory(server::WritingMemoryInterfacePrx memory);
@@ -65,7 +65,7 @@ namespace armarx::armem::client
 
     private:
         /// Sets `timeSent` on all entity updates and performs the commit,
-        data::CommitResult _commit(data::Commit& commit);
+        data::CommitResult _commit(data::Commit& commit) const;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h
index ab0c5aa6d..4bdcaac5b 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h
@@ -15,8 +15,9 @@ namespace armarx::armem::articulated_object
                                                     const std::optional<std::string>& providerName,
                                                     const std::string& instanceName = "");
 
-        bool synchronizeArticulatedObject(VirtualRobot::Robot& object,
-                                          const armem::Time& timestamp,
-                                          const std::optional<std::string>& providerName);
+        [[nodiscard]] bool
+        synchronizeArticulatedObject(VirtualRobot::Robot& object,
+                                     const armem::Time& timestamp,
+                                     const std::optional<std::string>& providerName);
     };
 } // namespace armarx::armem::articulated_object
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp
index 16c83498c..f21151f19 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp
@@ -26,7 +26,6 @@
 
 #include "utils.h"
 
-namespace fs = ::std::filesystem;
 
 namespace armarx::armem::articulated_object
 {
@@ -100,7 +99,7 @@ namespace armarx::armem::articulated_object
     std::optional<ArticulatedObject>
     Reader::get(const std::string& name,
                 const armem::Time& timestamp,
-                const std::optional<std::string>& providerName)
+                const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -125,7 +124,7 @@ namespace armarx::armem::articulated_object
     Reader::get(const ArticulatedObjectDescription& description,
                 const armem::Time& timestamp,
                 const std::string& instanceName,
-                const std::optional<std::string>& providerName)
+                const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -142,7 +141,7 @@ namespace armarx::armem::articulated_object
     bool
     Reader::synchronize(ArticulatedObject& obj,
                         const armem::Time& timestamp,
-                        const std::optional<std::string>& providerName)
+                        const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -164,7 +163,7 @@ namespace armarx::armem::articulated_object
 
     std::vector<robot::RobotDescription>
     Reader::queryDescriptions(const armem::Time& timestamp,
-                              const std::optional<std::string>& providerName)
+                              const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
         // Query all entities from provider.
@@ -209,7 +208,7 @@ namespace armarx::armem::articulated_object
     std::optional<robot::RobotDescription>
     Reader::queryDescription(const std::string& name,
                              const armem::Time& timestamp,
-                             const std::optional<std::string>& providerName)
+                             const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -256,7 +255,7 @@ namespace armarx::armem::articulated_object
     std::optional<robot::RobotState>
     Reader::queryState(const std::string& instanceName,
                        const armem::Time& timestamp,
-                       const std::optional<std::string>& providerName)
+                       const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h
index 0eb5bd104..50c342c0c 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h
@@ -26,13 +26,17 @@
 
 #include <VirtualRobot/VirtualRobot.h>
 
-#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>
+#include <RobotAPI/libraries/armem/client/forward_declarations.h>
 
 #include "interfaces.h"
 
+// #include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
+// #include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
+
+
 namespace armarx::armem::articulated_object
 {
 
@@ -40,7 +44,7 @@ namespace armarx::armem::articulated_object
     {
     public:
         Reader() = default;
-        virtual ~Reader() = default;
+        ~Reader() override = default;
 
         void
         registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def)
@@ -49,30 +53,30 @@ namespace armarx::armem::articulated_object
 
         void connect(armem::client::MemoryNameSystem& memoryNameSystem);
 
-        bool synchronize(ArticulatedObject& obj,
+        [[nodiscard]] bool synchronize(ArticulatedObject& obj,
                          const armem::Time& timestamp,
-                         const std::optional<std::string>& providerName) override;
+                         const std::optional<std::string>& providerName) const override;
 
         std::optional<ArticulatedObject>
         get(const std::string& name,
             const armem::Time& timestamp,
-            const std::optional<std::string>& providerName) override;
+            const std::optional<std::string>& providerName) const override;
         ArticulatedObject get(const ArticulatedObjectDescription& description,
                               const armem::Time& timestamp,
                               const std::string& instanceName,
-                              const std::optional<std::string>& providerName) override;
+                              const std::optional<std::string>& providerName) const override;
 
         std::optional<robot::RobotState> queryState(const std::string& instanceName,
                                                     const armem::Time& timestamp,
-                                                    const std::optional<std::string>& providerName);
+                                                    const std::optional<std::string>& providerName) const;
         std::optional<robot::RobotDescription>
         queryDescription(const std::string& name,
                          const armem::Time& timestamp,
-                         const std::optional<std::string>& providerName);
+                         const std::optional<std::string>& providerName) const;
 
         std::vector<robot::RobotDescription>
         queryDescriptions(const armem::Time& timestamp,
-                          const std::optional<std::string>& providerName);
+                          const std::optional<std::string>& providerName) const;
 
         std::string getProviderName() const;
         void setProviderName(const std::string& providerName);
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp
index c507fd905..4df792102 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp
@@ -103,7 +103,7 @@ namespace armarx::armem::articulated_object
     }
 
     std::optional<armem::MemoryID>
-    Writer::storeOrGetClass(const ArticulatedObject& obj)
+    Writer::storeOrGetClass(const ArticulatedObject& obj) const
     {
         ARMARX_TRACE;
 
@@ -129,7 +129,7 @@ namespace armarx::armem::articulated_object
     }
 
     std::optional<armem::MemoryID>
-    Writer::storeClass(const ArticulatedObject& obj)
+    Writer::storeClass(const ArticulatedObject& obj) const
     {
         std::lock_guard g{memoryWriterMutex};
 
@@ -190,7 +190,7 @@ namespace armarx::armem::articulated_object
     }
 
     bool
-    Writer::storeInstance(const ArticulatedObject& obj)
+    Writer::storeInstance(const ArticulatedObject& obj) const
     {
         std::lock_guard g{memoryWriterMutex};
 
@@ -259,7 +259,7 @@ namespace armarx::armem::articulated_object
     }
 
     bool
-    Writer::store(const ArticulatedObject& obj)
+    Writer::store(const ArticulatedObject& obj) const
     {
         const std::optional<armem::MemoryID> classId = storeOrGetClass(obj);
 
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h
index 6245ef374..bf1c7d945 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h
@@ -39,16 +39,16 @@ namespace armarx::armem::articulated_object
     {
     public:
         Writer() = default;
-        virtual ~Writer() = default;
+        ~Writer() override = default;
 
         void registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def);
         void connect(armem::client::MemoryNameSystem& memoryNameSystem);
 
 
-        bool store(const ArticulatedObject& obj) override;
+        bool store(const ArticulatedObject& obj) const override;
 
-        bool storeInstance(const ArticulatedObject& obj);
-        std::optional<armem::MemoryID> storeClass(const ArticulatedObject& obj);
+        bool storeInstance(const ArticulatedObject& obj) const;
+        std::optional<armem::MemoryID> storeClass(const ArticulatedObject& obj) const;
 
         // const std::string& getPropertyPrefix() const override;
 
@@ -57,7 +57,7 @@ namespace armarx::armem::articulated_object
 
 
     private:
-        std::optional<armem::MemoryID> storeOrGetClass(const ArticulatedObject& obj);
+        std::optional<armem::MemoryID> storeOrGetClass(const ArticulatedObject& obj) const;
 
         void updateKnownObjects(const armem::MemoryID& subscriptionID,
                                 const std::vector<armem::MemoryID>& snapshotIDs);
@@ -85,13 +85,13 @@ namespace armarx::armem::articulated_object
         const std::string propertyPrefix = "mem.obj.articulated.";
 
         armem::client::Writer memoryWriter;
-        std::mutex memoryWriterMutex;
+        mutable std::mutex memoryWriterMutex;
 
         armem::client::Reader memoryReader;
-        std::mutex memoryReaderMutex;
+        mutable std::mutex memoryReaderMutex;
 
         // key: name of object: RobotDescription::name
-        std::unordered_map<std::string, MemoryID> knownObjects;
+        mutable std::unordered_map<std::string, MemoryID> knownObjects;
     };
 
 
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h
index 6031eba4b..899cb1e79 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h
@@ -11,19 +11,26 @@ namespace armarx::armem::articulated_object
     public:
         virtual ~ReaderInterface() = default;
 
-        virtual bool synchronize(ArticulatedObject& obj, const armem::Time& timestamp, const std::optional<std::string>& providerName) = 0;
-
-        virtual ArticulatedObject get(const ArticulatedObjectDescription& description, const armem::Time& timestamp, const std::string& instanceName, const std::optional<std::string>& providerName) = 0;
-        virtual std::optional<ArticulatedObject> get(const std::string& name, const armem::Time& timestamp, const std::optional<std::string>& providerName) = 0;
+        virtual bool synchronize(ArticulatedObject& obj,
+                                 const armem::Time& timestamp,
+                                 const std::optional<std::string>& providerName) const = 0;
+
+        virtual ArticulatedObject get(const ArticulatedObjectDescription& description,
+                                      const armem::Time& timestamp,
+                                      const std::string& instanceName,
+                                      const std::optional<std::string>& providerName) const = 0;
+        virtual std::optional<ArticulatedObject>
+        get(const std::string& name,
+            const armem::Time& timestamp,
+            const std::optional<std::string>& providerName) const = 0;
     };
 
-
     class WriterInterface
     {
     public:
         virtual ~WriterInterface() = default;
 
-        virtual bool store(const ArticulatedObject& obj) = 0;
+        virtual bool store(const ArticulatedObject& obj) const = 0;
     };
 
-}  // namespace armarx::armem::articulated_object
+} // namespace armarx::armem::articulated_object
-- 
GitLab