Migrate ExampleMemory predictions to dispatching

source/RobotAPI/components/armem/server/ExampleMemory/ExampleMemory.cpp

@@ -73,7 +73,11 @@ namespace armarx
         workingMemory().addCoreSegment("LinkedData", armem::example::LinkedData::ToAronType());
 
         // We support the "Latest" prediction engine for the entire memory.
+        // TODO(phesch): This should really be one operation.
         workingMemory().addPredictionEngine({"Latest"});
+        workingMemory().addPredictor("Latest",
+                                     [this](const armem::PredictionRequest& request)
+                                     { return this->predictLatest(request); });
 
         // For illustration purposes, we add more segments (without types).
         bool trim = true;
@@ -216,66 +220,44 @@ namespace armarx
     }
 
     // PREDICTING
-
-    armem::prediction::data::PredictionResultSeq
-    ExampleMemory::predict(const armem::prediction::data::PredictionRequestSeq& requests)
-    {
-        armem::prediction::data::PredictionResultSeq result;
-        for (const auto& request : requests)
-        {
-            result.push_back(predictSingle(request));
-        }
-        return result;
-    }
-
-    armem::prediction::data::PredictionResult
-    ExampleMemory::predictSingle(const armem::prediction::data::PredictionRequest& request)
+    armem::PredictionResult
+    ExampleMemory::predictLatest(const armem::PredictionRequest& request)
     {
         armem::PredictionResult result;
-
-        std::string engine = request.settings.predictionEngineID;
-        if (engine.empty() || engine == "Latest")
+        auto memID = request.snapshotID;
+        result.snapshotID = memID;
+
+        armem::client::QueryBuilder builder;
+        builder.latestEntitySnapshot(memID);
+        auto queryResult =
+            query(armarx::toIce<armem::query::data::Input>(builder.buildQueryInput()));
+        if (queryResult.success)
         {
-            auto boID = fromIce<armem::MemoryID>(request.snapshotID);
-            armem::client::QueryBuilder builder;
-            builder.latestEntitySnapshot(boID);
-            auto queryResult =
-                query(armarx::toIce<armem::query::data::Input>(builder.buildQueryInput()));
-            if (queryResult.success)
+            auto readMemory = fromIce<armem::wm::Memory>(queryResult.memory);
+            auto* latest = readMemory.findLatestSnapshot(memID);
+            if (latest != nullptr)
             {
-                auto readMemory = fromIce<armem::wm::Memory>(queryResult.memory);
-                auto* latest = readMemory.findLatestSnapshot(boID);
-                if (latest != nullptr)
-                {
-                    auto instance = boID.hasInstanceIndex()
-                                        ? latest->getInstance(boID)
-                                        : latest->getInstance(latest->getInstanceIndices().at(0));
-                    result.success = true;
-                    result.snapshotID = boID;
-                    result.prediction = instance.data();
-                }
-                else
-                {
-                    result.success = false;
-                    result.errorMessage =
-                        "Could not find entity referenced by MemoryID '" + boID.str() + "'.";
-                }
+                auto instance = memID.hasInstanceIndex()
+                                    ? latest->getInstance(memID)
+                                    : latest->getInstance(latest->getInstanceIndices().at(0));
+                result.success = true;
+                result.prediction = instance.data();
             }
             else
             {
                 result.success = false;
                 result.errorMessage =
-                    "Could not find entity referenced by MemoryID '" + boID.str() + "'.";
+                    "Could not find entity referenced by MemoryID '" + memID.str() + "'.";
             }
         }
         else
         {
             result.success = false;
             result.errorMessage =
-                "This memory does not support the prediction engine '" + engine + "'.";
+                "Could not find entity referenced by MemoryID '" + memID.str() + "'.";
         }
 
-        return result.toIce();
+        return result;
     }
 
     // REMOTE GUI

source/RobotAPI/components/armem/server/ExampleMemory/ExampleMemory.h

@@ -28,6 +28,7 @@
 #include <ArmarXCore/interface/observers/ObserverInterface.h>
 #include <ArmarXGui/libraries/ArmarXGuiComponentPlugins/LightweightRemoteGuiComponentPlugin.h>
 
+#include <RobotAPI/libraries/armem/core/Prediction.h>
 #include <RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h>
 
 
@@ -71,11 +72,6 @@ namespace armarx
         armem::actions::GetActionsOutputSeq getActions(const armem::actions::GetActionsInputSeq& input) override;
         armem::actions::ExecuteActionOutputSeq executeActions(const armem::actions::ExecuteActionInputSeq& input) override;
 
-        // PredictingMemoryInterface interface
-    public:
-        armem::prediction::data::PredictionResultSeq
-        predict(const armem::prediction::data::PredictionRequestSeq& requests) override;
-
 
     protected:
 
@@ -89,8 +85,7 @@ namespace armarx
 
     private:
 
-        armem::prediction::data::PredictionResult
-        predictSingle(const armem::prediction::data::PredictionRequest& request);
+        armem::PredictionResult predictLatest(const armem::PredictionRequest& request);
 
         armarx::DebugObserverInterfacePrx debugObserver;