Fix empty provider name in ArticulatedObject Example

source/RobotAPI/components/ArticulatedObjectLocalizerExample/ArticulatedObjectLocalizerExample.cpp

@@ -66,6 +66,7 @@ namespace armarx::articulated_object
 
         defs->optional(p.updateFrequency, "updateFrequency", "Memory update frequency (write).");
 
+        // Reader will override some properties of writer.
         articulatedObjectWriter->registerPropertyDefinitions(defs);
         articulatedObjectReader->registerPropertyDefinitions(defs);
 
@@ -77,7 +78,11 @@ namespace armarx::articulated_object
         return "ArticulatedObjectLocalizerExample";
     }
 
-    void ArticulatedObjectLocalizerExample::onInitComponent() {}
+    void ArticulatedObjectLocalizerExample::onInitComponent()
+    {
+        // Reader overwrote property registered property of articulatedObjectWriter.
+        articulatedObjectWriter->setProviderName(articulatedObjectReader->getProviderName());
+    }
 
     void ArticulatedObjectLocalizerExample::onConnectComponent()
     {

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

@@ -162,6 +162,16 @@ namespace armarx::armem::articulated_object
         return getRobotDescriptions(qResult.memory);
     }
 
+    std::string Reader::getProviderName() const
+    {
+        return properties.providerName;
+    }
+
+    void Reader::setProviderName(const std::string& providerName)
+    {
+        this->properties.providerName = providerName;
+    }
+
     std::optional<robot::RobotDescription> Reader::queryDescription(const std::string& name,
             const armem::Time& timestamp)
     {

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

@@ -54,6 +54,9 @@ namespace armarx::armem::articulated_object
 
         std::vector<robot::RobotDescription> queryDescriptions(const armem::Time& timestamp);
 
+        std::string getProviderName() const;
+        void setProviderName(const std::string& providerName);
+
         // TODO(fabian.reister): register property defs
 
     protected:

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

@@ -38,6 +38,8 @@ namespace armarx::armem::articulated_object
         def->optional(properties.coreClassSegmentName,
                       prefix + "CoreSegment",
                       "Name of the memory core segment to use for object classes.");
+
+        ARMARX_IMPORTANT << "Writer: add property '" << prefix << "ProviderName'";
         def->required(properties.providerName, prefix + "ProviderName", "Name of this provider");
     }
 
@@ -159,31 +161,51 @@ namespace armarx::armem::articulated_object
         return updateResult.snapshotID;
     }
 
+    std::string Writer::getProviderName() const
+    {
+        return properties.providerName;
+    }
+
+    void Writer::setProviderName(const std::string& providerName)
+    {
+        this->properties.providerName = providerName;
+    }
+
     bool Writer::storeInstance(const ArticulatedObject& obj)
     {
         std::lock_guard g{memoryWriterMutex};
 
         ARMARX_DEBUG << "Trying to create core segment + provider segment";
 
-        const auto result =
-            memoryWriter.addSegment(properties.coreInstanceSegmentName, properties.providerName);
-
-        if (not result.success)
+        // Provider segments are now added when necessary.
+        // Adding them explicitly is only needed to set a deriving provider segment type.
+        if (false)
         {
-            ARMARX_ERROR << "Creating core segment failed. Reason: " << result.errorMessage;
-            return false;
+            const auto result =
+                memoryWriter.addSegment(properties.coreInstanceSegmentName, properties.providerName);
+
+            if (not result.success)
+            {
+                ARMARX_ERROR << "Creating core segment failed. Reason: " << result.errorMessage;
+                return false;
+            }
+            else
+            {
+                ARMARX_IMPORTANT << VAROUT(result.segmentID);
+            }
         }
 
         const auto& timestamp = obj.timestamp;
 
-        const auto providerId = armem::MemoryID(result.segmentID);
-        const auto entityID =
-            providerId
-            .withEntityName(obj.description.name)
-            .withTimestamp(timestamp);
+        const auto providerId = armem::MemoryID()
+                                .withMemoryName(properties.memoryName)
+                                .withCoreSegmentName(properties.coreInstanceSegmentName)
+                                .withProviderSegmentName(properties.providerName);
+        ARMARX_IMPORTANT << VAROUT(providerId) << " | " << VAROUT(properties.providerName);
 
         armem::EntityUpdate update;
-        update.entityID = entityID;
+        update.entityID = providerId.withEntityName(obj.description.name);
+        // .withTimestamp(timestamp); // You only need to specify the entity ID, not the snapshot ID
 
         arondto::Robot aronArticulatedObject;
         robot::toAron(aronArticulatedObject, obj);

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

@@ -42,7 +42,6 @@ namespace armarx::armem::articulated_object
         Writer(armem::client::MemoryNameSystem& memoryNameSystem);
         virtual ~Writer() = default;
 
-
         void registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def);
         void connect();
 
@@ -54,7 +53,12 @@ namespace armarx::armem::articulated_object
 
         // const std::string& getPropertyPrefix() const override;
 
+        std::string getProviderName() const;
+        void setProviderName(const std::string& providerName);
+
+
     private:
+
         std::optional<armem::MemoryID> storeOrGetClass(const ArticulatedObject& obj);
 
         void updateKnownObjects(const armem::MemoryID& subscriptionID, const std::vector<armem::MemoryID>& snapshotIDs);
@@ -72,7 +76,7 @@ namespace armarx::armem::articulated_object
             std::string memoryName              = "Object";
             std::string coreInstanceSegmentName = "ArticulatedObjectInstance";
             std::string coreClassSegmentName    = "ArticulatedObjectClass";
-            std::string providerName;
+            std::string providerName            = "";
 
             bool allowClassCreation             = false;
         } properties;