armem PSE updates and implementation of recording interface. Moved aron base...

armem PSE updates and implementation of recording interface. Moved aron base class to aron instead of codegeneration

source/RobotAPI/interface/CMakeLists.txt

@@ -112,7 +112,7 @@ set(SLICE_FILES
 
     armem.ice
     armem/actions.ice
-    armem/io.ice
+    armem/structure.ice
     armem/commit.ice
     armem/memory.ice
     armem/prediction.ice

source/RobotAPI/interface/armem/io.ice

-#pragma once
-
-#include <ArmarXCore/interface/core/PackagePath.ice>
-#include <RobotAPI/interface/armem/memory.ice>
-#include <RobotAPI/interface/armem/query.ice>
-
-module armarx
-{
-    module armem
-    {
-
-    };
-};

source/RobotAPI/interface/armem/query.ice

@@ -11,17 +11,18 @@ module armarx
         {
             module data
             {
-                enum QueryTarget
+                module QueryTarget
                 {
-                    WM,
-                    LTM
-                };
-                sequence<QueryTarget> QueryTargets;
+                    enum QueryTargetEnum
+                    {
+                        WM,
+                        WM_LTM
+                    };
+                }
 
                 /// Which entity snapshots to get from an entity?
                 class EntityQuery
                 {
-                    QueryTargets targets;
                 };
                 sequence<EntityQuery> EntityQuerySeq;
 
@@ -115,7 +116,6 @@ module armarx
                 class ProviderSegmentQuery
                 {
                     EntityQuerySeq entityQueries;
-                    QueryTargets targets;
                 };
                 sequence<ProviderSegmentQuery> ProviderSegmentQuerySeq;
                 module provider
@@ -138,7 +138,6 @@ module armarx
                 class CoreSegmentQuery
                 {
                     ProviderSegmentQuerySeq providerSegmentQueries;
-                    QueryTargets targets;
                 };
                 sequence<CoreSegmentQuery> CoreSegmentQuerySeq;
 
@@ -162,7 +161,7 @@ module armarx
                 class MemoryQuery
                 {
                     CoreSegmentQuerySeq coreSegmentQueries;
-                    QueryTargets targets;
+                    QueryTarget::QueryTargetEnum target = QueryTarget::QueryTargetEnum::WM;
                 };
                 sequence<MemoryQuery> MemoryQuerySeq;
                 dictionary<string, MemoryQuerySeq> MemoryQueriesDict;

source/RobotAPI/interface/armem/server/ReadingMemoryInterface.ice

 #pragma once
 
 #include <RobotAPI/interface/armem/query.ice>
+#include <RobotAPI/interface/armem/structure.ice>
 
 
 module armarx
@@ -9,9 +10,16 @@ module armarx
     {
         module server
         {
+            module dto
+            {
+
+            }
+
             interface ReadingMemoryInterface
             {
                 armem::query::data::Result query(armem::query::data::Input input);
+
+                armem::structure::data::GetServerStructureResult getServerStructure();
             };
         };
     };

source/RobotAPI/interface/armem/server/RecordingMemoryInterface.ice

 #pragma once
 
-#include <RobotAPI/interface/armem/io.ice>
-
+#include <RobotAPI/interface/armem/memory.ice>
 
 module armarx
 {
@@ -69,12 +68,6 @@ module armarx
                     string recordingID; //recordingID is formatted: timestamp_recordingName
                     Configuration configuration;
                 };
-
-                struct GetServerStructureResult {
-                    bool success;
-                    string errorMessage;
-                    armarx::armem::data::Memory serverStructure; //structure of the Server without data (all Segments...)
-                };
             }
 
             interface RecordingMemoryInterface
@@ -86,7 +79,6 @@ module armarx
                 dto::StartRecordResult startRecord(dto::StartRecordInput startRecordInput);
                 dto::StopRecordResult stopRecord();
                 dto::RecordStatusResult getRecordStatus();
-                dto::GetServerStructureResult getServerStructure();
             };
         };
     };

source/RobotAPI/interface/armem/server/ReplayingMemoryInterface.ice

 #pragma once
 
-#include <RobotAPI/interface/armem/io.ice>
+#include <RobotAPI/interface/armem/memory.ice>
 
 
 module armarx

source/RobotAPI/interface/armem/structure.ice

+#pragma once
+
+#include <RobotAPI/interface/armem/memory.ice>
+
+module armarx
+{
+    module armem
+    {
+        module structure
+        {
+            module data
+            {
+                struct GetServerStructureResult {
+                    bool success;
+                    string errorMessage;
+                    armarx::armem::data::Memory serverStructure; //structure of the Server without data (all Segments...)
+                };
+            };
+        };
+    };
+};

source/RobotAPI/libraries/armem/CMakeLists.txt

@@ -50,6 +50,8 @@ set(LIB_FILES
     core/error/ArMemError.cpp
     core/error/mns.cpp
 
+    core/query/DataMode.cpp
+    core/query/QueryTarget.cpp
 
     client/MemoryNameSystem.cpp
     client/Reader.cpp
@@ -83,7 +85,6 @@ set(LIB_HEADERS
     core/actions.h
     core/Commit.h
     core/container_maps.h
-    core/DataMode.h
     core/MemoryID.h
     core/MemoryID_operators.h
     core/operations.h
@@ -100,6 +101,10 @@ set(LIB_HEADERS
     core/error/ArMemError.h
     core/error/mns.h
 
+    core/query.h
+    core/query/DataMode.h
+    core/query/QueryTarget.h
+
     core/base/detail/MemoryItem.h
     core/base/detail/MemoryContainerBase.h
     core/base/detail/AronTyped.h

source/RobotAPI/libraries/armem/client/Query.cpp

@@ -47,13 +47,13 @@ namespace armarx::armem
     void client::toIce(armem::query::data::Input& ice, const QueryInput& input)
     {
         ice.memoryQueries = input.memoryQueries;
-        toIce(ice.withData, (input.dataMode == DataMode::WithData));
+        toIce(ice.withData, (input.dataMode == armem::query::DataMode::WithData));
     }
 
     void client::fromIce(const armem::query::data::Input& ice, QueryInput& input)
     {
         input.memoryQueries = ice.memoryQueries;
-        input.dataMode = (ice.withData ? DataMode::WithData : DataMode::NoData);
+        input.dataMode = (ice.withData ? armem::query::DataMode::WithData : armem::query::DataMode::NoData);
     }
 
     void client::toIce(armem::query::data::Result& ice, const QueryResult& result)

source/RobotAPI/libraries/armem/client/Query.h

@@ -5,7 +5,8 @@
 
 #include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
 #include <RobotAPI/libraries/armem/core/SuccessHeader.h>
-#include <RobotAPI/libraries/armem/core/DataMode.h>
+#include <RobotAPI/libraries/armem/core/query/DataMode.h>
+#include <RobotAPI/libraries/armem/core/query/QueryTarget.h>
 #include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
 
 
@@ -26,71 +27,7 @@ namespace armarx::armem::client
     struct QueryInput
     {
         armem::query::data::MemoryQuerySeq memoryQueries;
-        DataMode dataMode;
-
-        void addQueryTargetToAll(const armem::query::data::QueryTarget t)
-        {
-            for (const auto& memoryQuery : memoryQueries)
-            {
-                if (std::find(memoryQuery->targets.begin(), memoryQuery->targets.end(), t) == memoryQuery->targets.end())
-                {
-                    memoryQuery->targets.push_back(t);
-                }
-                for (const auto& coreSegmentQuery : memoryQuery->coreSegmentQueries)
-                {
-                    if (std::find(coreSegmentQuery->targets.begin(), coreSegmentQuery->targets.end(), t) == coreSegmentQuery->targets.end())
-                    {
-                        coreSegmentQuery->targets.push_back(t);
-                    }
-                    for (const auto& providerSegmentQuery : coreSegmentQuery->providerSegmentQueries)
-                    {
-                        if (std::find(providerSegmentQuery->targets.begin(), providerSegmentQuery->targets.end(), t) == providerSegmentQuery->targets.end())
-                        {
-                            providerSegmentQuery->targets.push_back(t);
-                        }
-                        for (const auto& entityQuery : providerSegmentQuery->entityQueries)
-                        {
-                            if (std::find(entityQuery->targets.begin(), entityQuery->targets.end(), t) == entityQuery->targets.end())
-                            {
-                                entityQuery->targets.push_back(t);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        void replaceQueryTarget(const armem::query::data::QueryTarget search, const armem::query::data::QueryTarget replace)
-        {
-            for (const auto& memoryQuery : memoryQueries)
-            {
-                if (auto it = std::find(memoryQuery->targets.begin(), memoryQuery->targets.end(), search); it != memoryQuery->targets.end())
-                {
-                    memoryQuery->targets.push_back(replace);
-                }
-                for (const auto& coreSegmentQuery : memoryQuery->coreSegmentQueries)
-                {
-                    if (auto it = std::find(coreSegmentQuery->targets.begin(), coreSegmentQuery->targets.end(), search); it != coreSegmentQuery->targets.end())
-                    {
-                        coreSegmentQuery->targets.push_back(replace);
-                    }
-                    for (const auto& providerSegmentQuery : coreSegmentQuery->providerSegmentQueries)
-                    {
-                        if (auto it = std::find(providerSegmentQuery->targets.begin(), providerSegmentQuery->targets.end(), search); it != providerSegmentQuery->targets.end())
-                        {
-                            providerSegmentQuery->targets.push_back(replace);
-                        }
-                        for (const auto& entityQuery : providerSegmentQuery->entityQueries)
-                        {
-                            if (auto it = std::find(entityQuery->targets.begin(), entityQuery->targets.end(), search); it != entityQuery->targets.end())
-                            {
-                                entityQuery->targets.push_back(replace);
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        armem::query::DataMode dataMode;
 
         static QueryInput fromIce(const armem::query::data::Input& ice);
         armem::query::data::Input toIce() const;

source/RobotAPI/libraries/armem/client/Reader.cpp

@@ -58,13 +58,13 @@ namespace armarx::armem::client
     }
 
 
-    QueryResult Reader::query(armem::query::data::MemoryQueryPtr query, DataMode dataMode) const
+    QueryResult Reader::query(armem::query::data::MemoryQueryPtr query, armem::query::DataMode dataMode) const
     {
         return this->query(armem::query::data::MemoryQuerySeq{query}, dataMode);
     }
 
 
-    QueryResult Reader::query(const armem::query::data::MemoryQuerySeq& queries, DataMode dataMode) const
+    QueryResult Reader::query(const armem::query::data::MemoryQuerySeq& queries, armem::query::DataMode dataMode) const
     {
         QueryInput input;
         input.memoryQueries = queries;
@@ -277,7 +277,7 @@ namespace armarx::armem::client
     }
 
 
-    QueryResult Reader::queryMemoryIDs(const std::vector<MemoryID>& ids, DataMode dataMode) const
+    QueryResult Reader::queryMemoryIDs(const std::vector<MemoryID>& ids, armem::query::DataMode dataMode) const
     {
         using namespace client::query_fns;
 
@@ -330,7 +330,7 @@ namespace armarx::armem::client
     }
 
 
-    QueryResult Reader::getLatestSnapshotsIn(const MemoryID& id, DataMode dataMode) const
+    QueryResult Reader::getLatestSnapshotsIn(const MemoryID& id, armem::query::DataMode dataMode) const
     {
         using namespace client::query_fns;
         if (!id.isWellDefined())
@@ -357,7 +357,7 @@ namespace armarx::armem::client
     }
 
 
-    std::optional<wm::EntitySnapshot> Reader::getLatestSnapshotIn(const MemoryID& id, DataMode dataMode) const
+    std::optional<wm::EntitySnapshot> Reader::getLatestSnapshotIn(const MemoryID& id, armem::query::DataMode dataMode) const
     {
         client::QueryResult result = getLatestSnapshotsIn(id, dataMode);
         if (result.success)
@@ -385,7 +385,7 @@ namespace armarx::armem::client
     }
 
 
-    QueryResult Reader::getAllLatestSnapshots(DataMode dataMode) const
+    QueryResult Reader::getAllLatestSnapshots(armem::query::DataMode dataMode) const
     {
         using namespace client::query_fns;
 
@@ -396,7 +396,7 @@ namespace armarx::armem::client
     }
 
 
-    QueryResult Reader::getAll(DataMode dataMode) const
+    QueryResult Reader::getAll(armem::query::DataMode dataMode) const
     {
         using namespace client::query_fns;
 

source/RobotAPI/libraries/armem/client/Reader.h

@@ -40,8 +40,8 @@ namespace armarx::armem::client
         QueryResult query(const QueryInput& input) const;
         armem::query::data::Result query(const armem::query::data::Input& input) const;
 
-        QueryResult query(armem::query::data::MemoryQueryPtr query, DataMode dataMode = DataMode::WithData) const;
-        QueryResult query(const armem::query::data::MemoryQuerySeq& queries, DataMode dataMode = DataMode::WithData) const;
+        QueryResult query(armem::query::data::MemoryQueryPtr query, armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
+        QueryResult query(const armem::query::data::MemoryQuerySeq& queries, armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
 
         QueryResult query(const QueryBuilder& queryBuilder) const;
 
@@ -113,7 +113,7 @@ namespace armarx::armem::client
          * @return The query result.
          */
         QueryResult
-        queryMemoryIDs(const std::vector<MemoryID>& ids, DataMode dataMode = DataMode::WithData) const;
+        queryMemoryIDs(const std::vector<MemoryID>& ids, armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
 
 
         /**
@@ -132,7 +132,7 @@ namespace armarx::armem::client
          * @return The query result.
          */
         QueryResult
-        getLatestSnapshotsIn(const MemoryID& id, DataMode dataMode = DataMode::WithData) const;
+        getLatestSnapshotsIn(const MemoryID& id, armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
 
         /**
          * @brief Get the latest snapshot under the given memory ID.
@@ -141,7 +141,7 @@ namespace armarx::armem::client
          * @return The latest contained snapshot, if any.
          */
         std::optional<wm::EntitySnapshot>
-        getLatestSnapshotIn(const MemoryID& id, DataMode dataMode = DataMode::WithData) const;
+        getLatestSnapshotIn(const MemoryID& id, armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
 
 
         /**
@@ -150,7 +150,7 @@ namespace armarx::armem::client
          * @return The query result.
          */
         QueryResult
-        getAllLatestSnapshots(DataMode dataMode = DataMode::WithData) const;
+        getAllLatestSnapshots(armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
 
 
         /**
@@ -159,7 +159,7 @@ namespace armarx::armem::client
          * @return The query result.
          */
         QueryResult
-        getAll(DataMode dataMode = DataMode::WithData) const;
+        getAll(armem::query::DataMode dataMode = armem::query::DataMode::WithData) const;
 
 
         server::dto::DirectlyStoreResult directlyStore(const server::dto::DirectlyStoreInput& input) const;

source/RobotAPI/libraries/armem/client/query/Builder.cpp

@@ -4,7 +4,7 @@
 namespace armarx::armem::client::query
 {
 
-    Builder::Builder(DataMode dataMode) : dataMode(dataMode)
+    Builder::Builder(armem::query::DataMode dataMode, armem::query::QueryTarget target) : dataMode(dataMode), queryTarget(target)
     {
     }
 
@@ -27,7 +27,7 @@ namespace armarx::armem::client::query
         {
             for (armem::query::data::MemoryQueryPtr& query : child.buildQueries())
             {
-                query->targets = _targets;
+                toIce(query->target, queryTarget);
                 memoryQueries.push_back(query);
             }
         }

source/RobotAPI/libraries/armem/client/query/Builder.h

 #pragma once
 
 #include <RobotAPI/interface/armem/query.h>
-
-#include <RobotAPI/libraries/armem/core/DataMode.h>
 #include <RobotAPI/libraries/armem/client/Query.h>
 
 #include "selectors.h"
@@ -10,7 +8,6 @@
 
 namespace armarx::armem::client::query
 {
-
     // ToDo: Make a memory selector (but this level is not in ice, yet)
     /**
      * @brief The query::Builder class provides a fluent-style specification of
@@ -27,7 +24,7 @@ namespace armarx::armem::client::query
     {
     public:
 
-        Builder(DataMode dataMode = DataMode::WithData);
+        Builder(armem::query::DataMode dataMode = armem::query::DataMode::WithData, armem::query::QueryTarget target = armem::query::QueryTarget::WM);
 
         /// Start specifying core segments.
         CoreSegmentSelector& coreSegments();
@@ -71,7 +68,8 @@ namespace armarx::armem::client::query
 
 
     public:
-        DataMode dataMode;
+        armem::query::DataMode dataMode;
+        armem::query::QueryTarget queryTarget;
 
     };
 

source/RobotAPI/libraries/armem/client/query/detail/NameSelectorOps.h

@@ -12,6 +12,7 @@ namespace armarx::armem::client::query::detail
     {
     public:
 
+        NameSelectorOps() = default;
         virtual ~NameSelectorOps() = default;
 
 

source/RobotAPI/libraries/armem/client/query/detail/SelectorOps.h

@@ -18,13 +18,9 @@ namespace armarx::armem::client::query::detail
         using DerivedT = _DerivedT;
         using QueryT = _QueryT;
 
-        ChildSelectorOps() = delete;
+        ChildSelectorOps() = default;
         virtual ~ChildSelectorOps() = default;
 
-        ChildSelectorOps(const armem::query::data::QueryTargets& p) :
-            _parentTargets(p)
-        {}
-
 
         virtual DerivedT& all() = 0;
         virtual DerivedT& withID(const MemoryID& id) = 0;
@@ -42,9 +38,6 @@ namespace armarx::armem::client::query::detail
             }
         }
 
-    protected:
-        armem::query::data::QueryTargets _parentTargets;
-
 
     protected:
 
@@ -93,18 +86,11 @@ namespace armarx::armem::client::query::detail
     public:
         virtual ~ParentSelectorOps() = default;
 
-        /// QueryTargets for this query
-        DerivedT& queryTargets(const armem::query::data::QueryTargets& targets)
-        {
-            this->_targets = targets;
-            return dynamic_cast<DerivedT&>(*this);
-        }
-
     protected:
 
         ChildT& _addChild()
         {
-            return _children.emplace_back(_targets);
+            return _children.emplace_back();
         }
         ChildT& _addChild(const ChildT& child)
         {
@@ -121,7 +107,6 @@ namespace armarx::armem::client::query::detail
 
 
         std::vector<ChildT> _children;
-        armem::query::data::QueryTargets _targets = {armem::query::data::QueryTarget::WM}; // if not specified we only query the WM
     };
 
 
@@ -133,27 +118,15 @@ namespace armarx::armem::client::query::detail
     {
     public:
 
-        InnerSelectorOps(const armem::query::data::QueryTargets& p) :
-            ChildSelectorOps<DerivedT, QueryT>(p)
-        {}
+        InnerSelectorOps() = default;
 
         virtual std::vector<QueryT> buildQueries() const
         {
-            // check own query targets and parent query targets
-            for (const auto& target : this->_targets)
-            {
-                if (std::find(this->_parentTargets.begin(), this->_parentTargets.end(), target) == this->_parentTargets.end())
-                {
-                    // TODO: Error, this makes no sense! or just ignore?
-                }
-            }
-
             std::vector<typename ChildT::QueryT> childQueries;
             for (const auto& child : this->_children)
             {
                 for (auto& query : child.buildQueries())
                 {
-                    query->targets = this->_targets;
                     childQueries.push_back(query);
                 }
             }

source/RobotAPI/libraries/armem/client/query/selectors.h

@@ -15,9 +15,7 @@ namespace armarx::armem::client::query
     {
     public:
 
-        SnapshotSelector(const armem::query::data::QueryTargets& p) :
-            detail::ChildSelectorOps<SnapshotSelector, armem::query::data::EntityQueryPtr>(p)
-        {}
+        SnapshotSelector() = default;
 
         armem::query::data::EntityQuerySeq buildQueries() const;
 
@@ -48,9 +46,7 @@ namespace armarx::armem::client::query
     {
     public:
 
-        EntitySelector(const armem::query::data::QueryTargets& p) :
-            detail::InnerSelectorOps<EntitySelector, armem::query::data::ProviderSegmentQueryPtr, SnapshotSelector>(p)
-        {}
+        EntitySelector() = default;
 
         /// Start specifying entity snapshots.
         SnapshotSelector& snapshots();
@@ -87,9 +83,7 @@ namespace armarx::armem::client::query
     {
     public:
 
-        ProviderSegmentSelector(const armem::query::data::QueryTargets& p) :
-            detail::InnerSelectorOps<ProviderSegmentSelector, armem::query::data::CoreSegmentQueryPtr, EntitySelector>(p)
-        {}
+        ProviderSegmentSelector() = default;
 
         /// Start specifying entities.
         EntitySelector& entities();
@@ -126,9 +120,7 @@ namespace armarx::armem::client::query
     {
     public:
 
-        CoreSegmentSelector(const armem::query::data::QueryTargets& p) :
-            detail::InnerSelectorOps<CoreSegmentSelector, armem::query::data::MemoryQueryPtr, ProviderSegmentSelector>(p)
-        {}
+        CoreSegmentSelector() = default;
 
         /// Start specifying provider segments.
         ProviderSegmentSelector& providerSegments();

source/RobotAPI/libraries/armem/core.h

@@ -2,7 +2,7 @@
 
 #include "core/error.h"
 #include "core/Commit.h"
-#include "core/DataMode.h"
+#include "core/query.h"
 #include "core/MemoryID.h"
 #include "core/Time.h"
 

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

+#pragma once
+
+#include "query/DataMode.h"
+#include "query/QueryTarget.h"
+
+
+namespace armarx::armem::query
+{
+
+
+}
+

source/RobotAPI/libraries/armem/core/query/DataMode.cpp

+#include "DataMode.h"
+
+namespace armarx::armem::query
+{
+    DataMode boolToDataMode(bool withData)
+    {
+        return withData ? DataMode::WithData : DataMode::NoData;
+    }
+}