(RK,FR): fixing query processors: if no modality is specified, assuming working memory query

source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp

@@ -236,10 +236,10 @@ namespace armarx::armem::server
         // Core segment processors will aquire the core segment locks.
         armem::wm::query_proc::MemoryQueryProcessor wmProcessor(
             input.withData ? armem::DataMode::WithData : armem::DataMode::NoData);
-        wm::Memory wmResult = wmProcessor.process(input, *workingMemory, /* execute if: */ { query::data::QueryTarget::WM });
+        wm::Memory wmResult = wmProcessor.process(input, *workingMemory);
 
         armem::ltm::query_proc::MemoryQueryProcessor ltmProcessor;
-        ltm::Memory ltmResult = ltmProcessor.process(input, *longtermMemory, /* execute if: */ { query::data::QueryTarget::LTM });
+        ltm::Memory ltmResult = ltmProcessor.process(input, *longtermMemory);
 
         armem::query::data::Result result;
         if (ltmResult.hasData())
@@ -267,7 +267,7 @@ namespace armarx::armem::server
             auto queryInput = armem::client::QueryInput::fromIce(input);
             queryInput.replaceQueryTarget(query::data::QueryTarget::LTM, query::data::QueryTarget::WM);
 
-            wm::Memory merged_result = wmProcessor.process(queryInput.toIce(), wmResult, /* execute if: */ { query::data::QueryTarget::WM });
+            wm::Memory merged_result = wmProcessor.process(queryInput.toIce(), wmResult);
             if (!merged_result.hasData())
             {
                 ARMARX_ERROR << "A merged and postprocessed Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";

source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h

@@ -22,34 +22,29 @@ namespace armarx::armem::base::query_proc
         virtual ~BaseQueryProcessorBase() = default;
 
 
-        DataT process(const QueryT& query, const DataT& data, const query::data::QueryTargets& executeIf = {}) const
+        DataT process(const QueryT& query, const DataT& data) const
         {
             DataT result = data.copyEmpty();
-
-            for (const auto queryTarget : query.targets)
+            if (getTargets(query.targets).count(getTargetType()))
             {
-                if (std::find(executeIf.begin(), executeIf.end(), queryTarget) != executeIf.end())
-                {
-                    this->process(result, query, data);
-                    break;
-                }
+                this->process(result, query, data);
             }
             return result;
         }
 
-        DataT process(const QueryPtrT& query, const DataT& data, const query::data::QueryTargets& executeIf = {}) const
+        DataT process(const QueryPtrT& query, const DataT& data) const
         {
-            return this->process(*query, *data, executeIf);
+            return this->process(*query, *data);
         }
 
-        DataT process(const QuerySeqT& queries, const DataT& data, const query::data::QueryTargets& executeIf = {}) const
+        DataT process(const QuerySeqT& queries, const DataT& data) const
         {
             DataT result = data.copyEmpty();
-            this->process(result, queries, data, executeIf);
+            this->process(result, queries, data);
             return result;
         }
 
-        void process(DataT& result, const QuerySeqT& queries, const DataT& data, const query::data::QueryTargets& executeIf = {}) const
+        void process(DataT& result, const QuerySeqT& queries, const DataT& data) const
         {
             if (queries.empty())
             {
@@ -57,35 +52,37 @@ namespace armarx::armem::base::query_proc
                 return;
             }
 
-            if (executeIf.empty())
-            {
-                ARMARX_DEBUG << "Could not execute query. ExecuteIf s empty.";
-                return;
-            }
-
             for (const auto& query : queries)
             {
-                if (query->targets.empty())
+                if (getTargets(query->targets).count(getTargetType()))
                 {
-                    ARMARX_DEBUG << "The targets of a query are empty";
-                    continue;
-                }
-
-                for (const auto queryTarget : query->targets)
-                {
-                    if (std::find(executeIf.begin(), executeIf.end(), queryTarget) != executeIf.end())
-                    {
-                        this->process(result, *query, data);
-                        break;
-                    }
-                    else
-                    {
-                        ARMARX_DEBUG << "The query target " << queryTarget << " was not found in executeIf: " << executeIf;
-                    }
+                    this->process(result, *query, data);
                 }
             }
         }
 
         virtual void process(DataT& result, const QueryT& query, const DataT& data) const = 0;
+
+
+    protected:
+
+        virtual query::data::QueryTarget getTargetType() const = 0;
+
+
+    private:
+
+        /// If empty, e.g. when receiving queries from python, we use WM as default.
+        /// We do it here as (Sl)ice does not support default values for vectors.
+        static std::set<query::data::QueryTarget> getTargets(const std::vector<query::data::QueryTarget>& _targets)
+        {
+            std::set<query::data::QueryTarget> targets(_targets.begin(), _targets.end());
+            if (targets.empty())
+            {
+                ARMARX_DEBUG << "Query has no targets - using WM as default.";
+                targets.insert(query::data::QueryTarget::WM);
+            }
+            return targets;
+        }
+
     };
 }

source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h

@@ -34,9 +34,9 @@ namespace armarx::armem::base::query_proc
 
 
         using Base::process;
-        _MemoryT process(const armem::query::data::Input& input, const _MemoryT& memory, const std::vector<query::data::QueryTarget>& executeIf = {}) const
+        _MemoryT process(const armem::query::data::Input& input, const _MemoryT& memory) const
         {
-            return this->process(input.memoryQueries, memory, executeIf);
+            return this->process(input.memoryQueries, memory);
         }
 
         void process(_MemoryT& result,

source/RobotAPI/libraries/armem/server/query_proc/diskmemory/BaseQueryProcessor.h

@@ -22,5 +22,11 @@ namespace armarx::armem::d_ltm::query_proc
         {}
 
     protected:
+
+        query::data::QueryTarget getTargetType() const override
+        {
+            return query::data::QueryTarget::Disk;
+        }
+
     };
 }

source/RobotAPI/libraries/armem/server/query_proc/diskmemory/CoreSegmentQueryProcessor.h

@@ -27,7 +27,7 @@ namespace armarx::armem::d_ltm::query_proc
     protected:
         virtual ProviderSegmentT providerSegmentProcessorProcess(const armem::query::data::ProviderSegmentQuerySeq& q, const ProviderSegmentT& s) const override
         {
-            return providerSegmentProcessor.process(q, s, {armem::query::data::QueryTarget::Disk});
+            return providerSegmentProcessor.process(q, s);
         }
 
     private:

source/RobotAPI/libraries/armem/server/query_proc/diskmemory/MemoryQueryProcessor.h

@@ -26,7 +26,7 @@ namespace armarx::armem::d_ltm::query_proc
     protected:
         virtual CoreSegmentT coreSegmentProcessorProcess(const armem::query::data::CoreSegmentQuerySeq& q, const CoreSegmentT& s) const override
         {
-            return coreSegmentProcessor.process(q, s, {armem::query::data::QueryTarget::Disk});
+            return coreSegmentProcessor.process(q, s);
         }
 
     private:

source/RobotAPI/libraries/armem/server/query_proc/diskmemory/ProviderSegmentQueryProcessor.h

@@ -26,7 +26,7 @@ namespace armarx::armem::d_ltm::query_proc
     protected:
         virtual EntityT entityProcessorProcess(const armem::query::data::EntityQuerySeq& q, const EntityT& s) const override
         {
-            return entityProcessor.process(q, s, {armem::query::data::QueryTarget::Disk});
+            return entityProcessor.process(q, s);
         }
 
     private:

source/RobotAPI/libraries/armem/server/query_proc/longtermmemory/BaseQueryProcessor.h

@@ -22,5 +22,11 @@ namespace armarx::armem::ltm::query_proc
         {}
 
     protected:
+
+        query::data::QueryTarget getTargetType() const override
+        {
+            return query::data::QueryTarget::LTM;
+        }
+
     };
 }

source/RobotAPI/libraries/armem/server/query_proc/longtermmemory/CoreSegmentQueryProcessor.h

@@ -27,7 +27,7 @@ namespace armarx::armem::ltm::query_proc
     protected:
         virtual ProviderSegmentT providerSegmentProcessorProcess(const armem::query::data::ProviderSegmentQuerySeq& q, const ProviderSegmentT& s) const override
         {
-            return providerSegmentProcessor.process(q, s, {armem::query::data::QueryTarget::LTM});
+            return providerSegmentProcessor.process(q, s);
         }
 
     private:

source/RobotAPI/libraries/armem/server/query_proc/longtermmemory/MemoryQueryProcessor.h

@@ -26,7 +26,7 @@ namespace armarx::armem::ltm::query_proc
     protected:
         virtual CoreSegmentT coreSegmentProcessorProcess(const armem::query::data::CoreSegmentQuerySeq& q, const CoreSegmentT& s) const override
         {
-            return coreSegmentProcessor.process(q, s, {armem::query::data::QueryTarget::LTM});
+            return coreSegmentProcessor.process(q, s);
         }
 
     private:

source/RobotAPI/libraries/armem/server/query_proc/longtermmemory/ProviderSegmentQueryProcessor.h

@@ -26,7 +26,7 @@ namespace armarx::armem::ltm::query_proc
     protected:
         virtual EntityT entityProcessorProcess(const armem::query::data::EntityQuerySeq& q, const EntityT& s) const override
         {
-            return entityProcessor.process(q, s, {armem::query::data::QueryTarget::LTM});
+            return entityProcessor.process(q, s);
         }
 
     private:

source/RobotAPI/libraries/armem/server/query_proc/workingmemory/BaseQueryProcessor.h

@@ -26,6 +26,11 @@ namespace armarx::armem::wm::query_proc
 
     protected:
 
+        query::data::QueryTarget getTargetType() const override
+        {
+            return query::data::QueryTarget::WM;
+        }
+
         DataMode dataMode;
 
     };

source/RobotAPI/libraries/armem/server/query_proc/workingmemory/CoreSegmentQueryProcessor.cpp

@@ -32,7 +32,7 @@ namespace armarx::armem::wm::query_proc
 
     ProviderSegment CoreSegmentQueryProcessor::providerSegmentProcessorProcess(const armem::query::data::ProviderSegmentQuerySeq& q, const ProviderSegment& s) const
     {
-        return providerSegmentProcessor.process(q, s, {armem::query::data::QueryTarget::WM});
+        return providerSegmentProcessor.process(q, s);
     }
 
 

source/RobotAPI/libraries/armem/server/query_proc/workingmemory/EntityQueryProcessor.cpp

@@ -6,7 +6,7 @@
 namespace armarx::armem::wm::query_proc
 {
     EntityQueryProcessor::EntityQueryProcessor(DataMode dataMode) :
-        Base(dataMode)
+        BaseQueryProcessor<wm::Entity, armem::query::data::EntityQuery>(dataMode)
     {}
 
 

source/RobotAPI/libraries/armem/server/query_proc/workingmemory/MemoryQueryProcessor.cpp

@@ -16,7 +16,7 @@ namespace armarx::armem::wm::query_proc
 
     CoreSegment MemoryQueryProcessor::coreSegmentProcessorProcess(const armem::query::data::CoreSegmentQuerySeq& q, const CoreSegment& s) const
     {
-        return coreSegmentProcessor.process(q, s, {armem::query::data::QueryTarget::WM});
+        return coreSegmentProcessor.process(q, s);
     }
 
 }

source/RobotAPI/libraries/armem/server/query_proc/workingmemory/ProviderSegmentQueryProcessor.cpp

@@ -24,7 +24,7 @@ namespace armarx::armem::wm::query_proc
 
     Entity ProviderSegmentQueryProcessor::entityProcessorProcess(const armem::query::data::EntityQuerySeq& q, const Entity& s) const
     {
-        return entityProcessor.process(q, s, {armem::query::data::QueryTarget::WM});
+        return entityProcessor.process(q, s);
     }
 
 }

source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp

@@ -245,7 +245,7 @@ namespace armarx::armem::gui
                         input.addQueryTargetToAll(armem::query::data::QueryTarget::Disk);
 
                         armem::d_ltm::query_proc::MemoryQueryProcessor d_ltm_processor;
-                        dMem = d_ltm_processor.process(input.toIce(), dMem, /* execute if: */ { query::data::QueryTarget::Disk });
+                        dMem = d_ltm_processor.process(input.toIce(), dMem);
 
                         wm::Memory converted = dMem.convert();
                         memoryData[k] = std::move(converted);
@@ -275,7 +275,7 @@ namespace armarx::armem::gui
 
                             // requery (e.g. to get only the last n values instead of the last n from disk and the last n from wm)
                             armem::wm::query_proc::MemoryQueryProcessor wm_processor;
-                            result.memory = wm_processor.process(input.toIce(), result.memory, /* execute if: */ { query::data::QueryTarget::WM });
+                            result.memory = wm_processor.process(input.toIce(), result.memory);
 
                             if (!result.memory.hasData())
                             {
@@ -293,7 +293,7 @@ namespace armarx::armem::gui
                 }
                 else
                 {
-                    ARMARX_WARNING << "A query for memory '" + name + "' produced an error: " << result.errorMessage;
+                    ARMARX_WARNING << "A query for memory '" << name << "' produced an error: " << result.errorMessage;
                     if (statusLabel)
                     {
                         statusLabel->setText(QString::fromStdString(result.errorMessage));