Add BaseQueryProcessor, ProviderSegmentQueryProcessor

source/RobotAPI/libraries/armem/CMakeLists.txt

@@ -40,8 +40,10 @@ set(LIB_FILES
     component/MemoryComponentPlugin.cpp
     component/MemoryRemoteGui.cpp
 
-    query/EntityQueryProcessor.cpp
     query/ice_conversions.cpp
+    query/BaseQueryProcessor.cpp
+    query/EntityQueryProcessor.cpp
+    query/ProviderSegmentQueryProcessor.cpp
 
     legacy/ArMemBase.cpp
 )
@@ -77,8 +79,10 @@ set(LIB_HEADERS
     component/MemoryRemoteGui.h
 
     query.h
-    query/EntityQueryProcessor.h
     query/ice_conversions.h
+    query/BaseQueryProcessor.h
+    query/EntityQueryProcessor.h
+    query/ProviderSegmentQueryProcessor.h
 
     legacy/ArMemBase.h
 )

source/RobotAPI/libraries/armem/query/BaseQueryProcessor.cpp

+#include "BaseQueryProcessor.h"
+
+#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+#include "../error/ArMemError.h"
+
+#include "../core/ice_conversions.h"
+
+
+namespace armarx::armem
+{
+
+}

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

+#pragma once
+
+#include <RobotAPI/interface/armem/query.h>
+
+#include "../memory/Memory.h"
+
+
+namespace armarx::armem
+{
+
+    /**
+     * @brief Handles memory queries.
+     */
+    template <class DataT, class QueryT>
+    class BaseQueryProcessor
+    {
+    public:
+
+        using DataPtrT = std::unique_ptr<DataT>;
+        using QueryPtrT = ::IceInternal::Handle<QueryT>;
+        using QuerySeqT = std::vector<QueryPtrT>;
+
+
+    public:
+
+
+        virtual ~BaseQueryProcessor()
+        {}
+
+
+        DataPtrT process(const QueryT& query, const DataT& data) const
+        {
+            DataPtrT result = data.getEmptyCopy();
+            this->process(*result, query, data);
+            return result;
+        }
+        DataPtrT process(const QueryPtrT& query, const DataPtrT& data) const
+        {
+            return this->process(*query, *data);
+        }
+
+        DataPtrT process(const QuerySeqT& queries, const DataT& data) const
+        {
+            DataPtrT result = data.getEmptyCopy();
+            this->process(*result, queries, data);
+            return result;
+        }
+
+
+        void process(DataT& result, const QuerySeqT& queries, const DataT& data) const
+        {
+            for (const auto& query : queries)
+            {
+                this->process(result, *query, data);
+            }
+        }
+
+        virtual void process(DataT& result, const QueryT& query, const DataT& data) const = 0;
+
+    };
+
+}

source/RobotAPI/libraries/armem/query/EntityQueryProcessor.cpp

@@ -10,50 +10,25 @@
 
 namespace armarx::armem
 {
-    EntityPtr EntityQueryProcessor::process(
-        const query::EntityQuery& query, const Entity& entity) const
-    {
-        EntityPtr result = entity.getEmptyCopy();
 
+    void EntityQueryProcessor::process(Entity& result, const query::EntityQuery& query, const Entity& entity) const
+    {
         if (auto q = dynamic_cast<const query::entity::AllSnapshotsQuery*>(&query))
         {
-            process(*result, *q, entity);
+            process(result, *q, entity);
         }
         else if (auto q = dynamic_cast<const query::entity::SingleSnapshotQuery*>(&query))
         {
-            process(*result, *q, entity);
+            process(result, *q, entity);
         }
         else if (auto q = dynamic_cast<const query::entity::SnapshotRangeQuery*>(&query))
         {
-            process(*result, *q, entity);
+            process(result, *q, entity);
         }
         else
         {
             throw armem::error::UnknownQueryType("entity snapshot", query);
         }
-
-        return result;
-    }
-
-    data::Entity EntityQueryProcessor::processToIce(const query::EntityQuery& query, const Entity& entity) const
-    {
-        return toIce<data::Entity>(process(query, entity));
-    }
-
-    EntityPtr EntityQueryProcessor::process(const std::vector<query::EntityQuery>& queries, const Entity& entity) const
-    {
-        EntityPtr result = entity.getEmptyCopy();
-
-        for (const auto& query : queries)
-        {
-            EntityPtr result = process(query, entity);
-            for (const auto& [time, snapshot] : entity.history)
-            {
-                result->addSnapshot(*snapshot);
-            }
-        }
-
-        return result;
     }
 
     void EntityQueryProcessor::process(Entity& result, const query::entity::AllSnapshotsQuery& query, const Entity& entity) const
@@ -107,4 +82,8 @@ namespace armarx::armem
         }
     }
 
+    data::Entity EntityQueryProcessor::processToIce(const query::EntityQuery& query, const Entity& entity) const
+    {
+        return toIce<data::Entity>(process(query, entity));
+    }
 }

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

@@ -2,9 +2,11 @@
 
 #include <RobotAPI/interface/armem/query.h>
 
-#include "ice_conversions.h"
 #include "../memory/Memory.h"
 
+#include "ice_conversions.h"
+#include "BaseQueryProcessor.h"
+
 
 namespace armarx::armem
 {
@@ -12,21 +14,23 @@ namespace armarx::armem
     /**
      * @brief Handles memory queries.
      */
-    class EntityQueryProcessor
+    class EntityQueryProcessor : public BaseQueryProcessor<Entity, query::EntityQuery>
     {
     public:
 
-        EntityPtr process(const query::EntityQuery& query, const Entity& entity) const;
-        data::Entity processToIce(const query::EntityQuery& query, const Entity& entity) const;
-
-        EntityPtr process(const std::vector<query::EntityQuery>& queries, const Entity& entity) const;
+        using BaseQueryProcessor::process;
 
+        void process(Entity& result, const query::EntityQuery& query, const Entity& entity) const override;
 
         void process(Entity& result, const query::entity::AllSnapshotsQuery& query, const Entity& entity) const;
         void process(Entity& result, const query::entity::SingleSnapshotQuery& query, const Entity& entity) const;
         void process(Entity& result, const query::entity::SnapshotRangeQuery& query, const Entity& entity) const;
 
         void process(Entity& result, const Time& min, const Time& max, const Entity& entity) const;
+
+
+        data::Entity processToIce(const query::EntityQuery& query, const Entity& entity) const;
+
     };
 
 }

source/RobotAPI/libraries/armem/query/ProviderSegmentQueryProcessor.cpp

+#include "ProviderSegmentQueryProcessor.h"
+
+#include <regex>
+
+#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+#include "../error/ArMemError.h"
+
+#include "../core/ice_conversions.h"
+
+
+namespace armarx::armem
+{
+
+    void ProviderSegmentQueryProcessor::process(ProviderSegment& result, const query::ProviderSegmentQuery& query, const ProviderSegment& providerSegment) const
+    {
+        if (auto q = dynamic_cast<const query::provider::AllEntitiesQuery*>(&query))
+        {
+            process(result, *q, providerSegment);
+        }
+        else if (auto q = dynamic_cast<const query::provider::SingleEntitiesQuery*>(&query))
+        {
+            process(result, *q, providerSegment);
+        }
+        else if (auto q = dynamic_cast<const query::provider::RegexEntityQuery*>(&query))
+        {
+            process(result, *q, providerSegment);
+        }
+        else
+        {
+            throw armem::error::UnknownQueryType("provider segment", query);
+        }
+    }
+
+
+    void ProviderSegmentQueryProcessor::process(ProviderSegment& result,
+        const query::provider::AllEntitiesQuery& query, const ProviderSegment& providerSegment) const
+    {
+        for (const auto& [name, entity] : providerSegment.entities)
+        {
+            result.addEntity(std::move(*entityProcessor.process(query.entityQueries, *entity)));
+        }
+    }
+
+    void ProviderSegmentQueryProcessor::process(ProviderSegment& result,
+        const query::provider::SingleEntitiesQuery& query, const ProviderSegment& providerSegment) const
+    {
+        try
+        {
+            const Entity& entity = providerSegment.getEntity(query.entityName);
+            result.addEntity(std::move(*entityProcessor.process(query.entityQueries, entity)));
+        }
+        catch (const error::MissingEntry&)
+        {
+            // Leave empty.
+        }
+    }
+
+    void ProviderSegmentQueryProcessor::process(ProviderSegment& result,
+            const query::provider::RegexEntityQuery& query, const ProviderSegment& providerSegment) const
+    {
+        std::regex regex(query.entityNameRegex);
+        for (const auto& [name, entity] : providerSegment.entities)
+        {
+            if (std::regex_search(entity->name, regex))
+            {
+                result.addEntity(std::move(*entityProcessor.process(query.entityQueries, *entity)));
+            }
+        }
+    }
+
+
+    data::ProviderSegment ProviderSegmentQueryProcessor::processToIce(
+            const query::ProviderSegmentQuery& query, const ProviderSegment& providerSegment) const
+    {
+        return toIce<data::ProviderSegment>(process(query, providerSegment));
+    }
+
+}

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

+#pragma once
+
+#include <RobotAPI/interface/armem/query.h>
+
+#include "../memory/Memory.h"
+
+#include "ice_conversions.h"
+#include "BaseQueryProcessor.h"
+#include "EntityQueryProcessor.h"
+
+
+
+namespace armarx::armem
+{
+
+    /**
+     * @brief Handles memory queries.
+     */
+    class ProviderSegmentQueryProcessor : public BaseQueryProcessor<ProviderSegment, query::ProviderSegmentQuery>
+    {
+    public:
+
+        using BaseQueryProcessor::process;
+
+        void process(ProviderSegment& result, const query::ProviderSegmentQuery& query, const ProviderSegment& providerSegment) const;
+
+        void process(ProviderSegment& result, const query::provider::AllEntitiesQuery& query, const ProviderSegment& providerSegment) const;
+        void process(ProviderSegment& result, const query::provider::SingleEntitiesQuery& query, const ProviderSegment& providerSegment) const;
+        void process(ProviderSegment& result, const query::provider::RegexEntityQuery& query, const ProviderSegment& providerSegment) const;
+
+
+        data::ProviderSegment processToIce(const query::ProviderSegmentQuery& query, const ProviderSegment& providerSegment) const;
+
+
+    private:
+
+        EntityQueryProcessor entityProcessor;
+
+    };
+
+}