Now able to send requests to memory. However: memory does not create core segment

source/RobotAPI/components/armem/client/TransformClient/TransformInterfaces.h

@@ -74,6 +74,8 @@ namespace armarx
     class TransformReaderInterface
     {
     public:
+        virtual ~TransformReaderInterface() = default;
+
         virtual TransformResult getGlobalPose(const std::string& agentName, const std::int64_t& timestamp) const = 0;
         virtual TransformResult lookupTransform(const TransformQuery& query) const = 0;
         // waitForTransform()
@@ -82,6 +84,9 @@ namespace armarx
     class TransformWriterInterface
     {
     public:
+        virtual ~TransformWriterInterface() = default;
+
+
         virtual void connect() = 0;
 
         virtual bool commitTransform(const Transform& transform) = 0;

source/RobotAPI/components/armem/client/TransformClient/TransformReaderClient.cpp

@@ -230,7 +230,6 @@ namespace armarx
         });
 
         return transforms;
-
     }
 
 

source/RobotAPI/components/armem/client/TransformClient/TransformWriter.cpp

@@ -30,6 +30,7 @@
 
 #include <IceUtil/Time.h>
 
+#include "ArmarXCore/core/application/properties/PropertyDefinitionContainer.h"
 #include "ArmarXCore/core/logging/Logging.h"
 #include "RobotAPI/components/armem/client/TransformClient/aron_conversions.h"
 #include "RobotAPI/libraries/armem/core/Memory.h"
@@ -54,13 +55,17 @@ namespace armarx
 
     void TransformWriter::createPropertyDefinitions(armarx::PropertyDefinitionsPtr& def)
     {
+        const std::string prefix("mem.write");
+
         def->topic(debugObserver);
 
-        def->optional(properties.memoryName, "mem.write.MemoryName", "Name of the memory to use.");
-        def->optional(properties.localizationMemoryName, "mem.write.LocalizationMemoryName", "Name of the localization memory core segment to use.");
-    }
+        // def->component(writingMemory);
+        def->component(memoryNameSystem, "ArMemMemoryNameSystem");
 
+        def->optional(properties.memoryName, prefix + "MemoryName", "Name of the memory to use.");
+        def->optional(properties.localizationMemoryName, prefix + "LocalizationMemoryName", "Name of the localization memory core segment to use.");
 
+    }
 
     void TransformWriter::connect()
     {
@@ -71,17 +76,42 @@ namespace armarx
         {
             ARMARX_ERROR << result.errorMessage;
         }
+
+        memoryWriter.setWritingMemory(result.proxy);
     }
 
 
-    std::string TransformWriter::getDefaultName() const
+    armem::data::WaitForMemoryResult TransformWriter::useMemory(const std::string& memoryName)
     {
-        return "TransformWriter";
+        armem::data::WaitForMemoryInput input;
+        input.name = memoryName;
+
+        ARMARX_INFO << "Waiting for memory ...";
+
+        ARMARX_CHECK_NOT_NULL(memoryNameSystem);
+
+        armem::data::WaitForMemoryResult result = memoryNameSystem->waitForMemory(input);
+        ARMARX_INFO << "Done";
+
+        if (result.success)
+        {
+            ARMARX_INFO << "Use memory: Success";
+
+            // Add dependency.
+            component.usingProxy(result.proxy->ice_getIdentity().name);
+        }
+        else
+        {
+            ARMARX_INFO << "Use memory: Failure";
+        }
+        return result;
     }
 
+
     bool TransformWriter::commitTransform(const Transform& transform)
     {
-        const auto result = memoryWriter.addSegment(properties.localizationMemoryName, transform.header.agent); //.getCoreSegment(properties.localizationMemoryName).getProviderSegment(agent);
+        ARMARX_INFO << "Trying to create core segment + provider segment";
+        const auto result = memoryWriter.addSegment(properties.localizationMemoryName, transform.header.agent);
 
         if (not result.success)
         {
@@ -106,7 +136,9 @@ namespace armarx
 
         ARMARX_IMPORTANT << "Committing " << update;
         armem::EntityUpdateResult updateResult = memoryWriter.commit(update);
+        
         ARMARX_INFO << updateResult;
+
         if (not updateResult.success)
         {
             ARMARX_ERROR << updateResult.errorMessage;

source/RobotAPI/components/armem/client/TransformClient/TransformWriter.h

@@ -57,21 +57,18 @@ namespace armarx
      * Detailed description of class ExampleClient.
      */
     class TransformWriter :
-        virtual public armarx::armem::client::WriterComponentPluginUser,
         virtual public armarx::TransformWriterInterface
     {
     public:
 
-        void createPropertyDefinitions(armarx::PropertyDefinitionsPtr& def);
-        TransformWriter() = default;
+        TransformWriter(Component& component)
+            : component(component)
+        {
 
-        ~TransformWriter() override;
+        }
 
+        ~TransformWriter() override;
 
-        void onInitComponent() override {}
-        void onConnectComponent() override {}
-        void onDisconnectComponent() override {}
-        void onExitComponent() override {}
 
         // TransformWriterInterface
         /// to be called in Component::onConnectComponent
@@ -79,7 +76,13 @@ namespace armarx
         bool commitTransform(const Transform& transform) override;
 
         /// @see armarx::ManagedIceObject::getDefaultName()
-        std::string getDefaultName() const override;
+        std::string getDefaultName() const;
+
+
+        armem::data::WaitForMemoryResult useMemory(const std::string& memoryName);
+        void createPropertyDefinitions(armarx::PropertyDefinitionsPtr& def);
+
+    protected:
 
     private:
 
@@ -87,6 +90,12 @@ namespace armarx
 
         DebugObserverInterfacePrx debugObserver;
 
+        // armem::server::WritingMemoryInterfacePrx writingMemory;
+        armem::client::Writer memoryWriter;
+
+        armem::mns::MemoryNameSystemInterfacePrx memoryNameSystem;
+
+
         // Properties
         struct Properties
         {
@@ -94,5 +103,7 @@ namespace armarx
             std::string localizationMemoryName = "Localization";
         } properties;
 
+        Component& component;
+
     };
 }