From 7e99fc91f94d287c873b372f2a385a8bc3284254 Mon Sep 17 00:00:00 2001
From: Fabian Peller-Konrad <fabian.peller-konrad@kit.edu>
Date: Tue, 26 Jul 2022 16:08:27 +0200
Subject: [PATCH] armem PSE updates and implementation of recording interface.
 Moved aron base class to aron instead of codegeneration

---
 source/RobotAPI/interface/CMakeLists.txt      |   2 +-
 source/RobotAPI/interface/armem/io.ice        |  13 --
 source/RobotAPI/interface/armem/query.ice     |  17 ++-
 .../armem/server/ReadingMemoryInterface.ice   |   8 ++
 .../armem/server/RecordingMemoryInterface.ice |  10 +-
 .../armem/server/ReplayingMemoryInterface.ice |   2 +-
 source/RobotAPI/interface/armem/structure.ice |  21 +++
 .../RobotAPI/libraries/armem/CMakeLists.txt   |   7 +-
 .../RobotAPI/libraries/armem/client/Query.cpp |   4 +-
 .../RobotAPI/libraries/armem/client/Query.h   |  69 +---------
 .../libraries/armem/client/Reader.cpp         |  14 +-
 .../RobotAPI/libraries/armem/client/Reader.h  |  14 +-
 .../libraries/armem/client/query/Builder.cpp  |   4 +-
 .../libraries/armem/client/query/Builder.h    |   8 +-
 .../client/query/detail/NameSelectorOps.h     |   1 +
 .../armem/client/query/detail/SelectorOps.h   |  33 +----
 .../libraries/armem/client/query/selectors.h  |  16 +--
 source/RobotAPI/libraries/armem/core.h        |   2 +-
 source/RobotAPI/libraries/armem/core/query.h  |  12 ++
 .../libraries/armem/core/query/DataMode.cpp   |   9 ++
 .../armem/core/{ => query}/DataMode.h         |   3 +-
 .../armem/core/query/QueryTarget.cpp          |  21 +++
 .../libraries/armem/core/query/QueryTarget.h  |  15 +++
 .../armem/server/MemoryToIceAdapter.cpp       | 125 ++++++++++++------
 .../armem/server/MemoryToIceAdapter.h         |   6 +-
 .../ltm/base/detail/BufferedMemoryBase.h      |   8 +-
 .../server/ltm/base/detail/CoreSegmentBase.h  |  19 +++
 .../armem/server/ltm/base/detail/EntityBase.h |  19 +++
 .../ltm/base/detail/EntitySnapshotBase.h      |  23 +++-
 .../armem/server/ltm/base/detail/MemoryBase.h |  68 +++++++++-
 .../server/ltm/base/detail/Processors.cpp     |  16 +--
 .../armem/server/ltm/base/detail/Processors.h |   2 +-
 .../ltm/base/detail/ProviderSegmentBase.h     |  19 +++
 .../armem/server/ltm/disk/CoreSegment.cpp     |   2 +
 .../armem/server/ltm/disk/Entity.cpp          |  32 ++++-
 .../armem/server/ltm/disk/EntitySnapshot.cpp  |   4 +-
 .../armem/server/ltm/disk/EntitySnapshot.h    |   2 +-
 .../armem/server/ltm/disk/Memory.cpp          |   2 +
 .../armem/server/ltm/disk/ProviderSegment.cpp |   3 +
 .../armem/server/ltm/io/Recording.cpp         |   4 +-
 .../libraries/armem/server/ltm/io/Recording.h |   4 +-
 .../libraries/armem/server/plugins/Plugin.cpp |  23 +++-
 .../libraries/armem/server/plugins/Plugin.h   |   4 +
 .../server/plugins/ReadOnlyPluginUser.cpp     |   6 +
 .../armem/server/plugins/ReadOnlyPluginUser.h |   4 +
 .../server/plugins/ReadWritePluginUser.cpp    |  12 +-
 .../server/plugins/ReadWritePluginUser.h      |   2 +-
 .../base/BaseQueryProcessorBase.cpp           |  12 --
 .../query_proc/base/BaseQueryProcessorBase.h  |  22 +--
 .../base/CoreSegmentQueryProcessorBase.h      |   6 +-
 .../base/EntityQueryProcessorBase.h           |   6 +-
 .../base/MemoryQueryProcessorBase.h           |  12 +-
 .../base/ProviderSegmentQueryProcessorBase.h  |   6 +-
 .../detail/CoreSegmentQueryProcessorBase.h    |   6 +-
 .../ltm/detail/EntityQueryProcessorBase.h     |   6 +-
 .../ltm/detail/MemoryQueryProcessorBase.h     |  14 +-
 .../ProviderSegmentQueryProcessorBase.h       |   6 +-
 .../armem/server/query_proc/ltm/disk/ltm.h    |  19 ++-
 .../wm/detail/CoreSegmentQueryProcessorBase.h |   6 +-
 .../wm/detail/EntityQueryProcessorBase.h      |   6 +-
 .../wm/detail/MemoryQueryProcessorBase.h      |   6 +-
 .../ProviderSegmentQueryProcessorBase.h       |   6 +-
 .../armem/server/query_proc/wm/wm.cpp         |  16 +--
 .../libraries/armem/server/query_proc/wm/wm.h |  55 ++++----
 .../armem/server/test/ArMemQueryTest.cpp      | 107 ++++++---------
 .../armem/test/ArMemQueryBuilderTest.cpp      |   2 +-
 source/RobotAPI/libraries/armem/util/util.h   |   2 +-
 .../libraries/armem_gui/MemoryViewer.cpp      |   4 +-
 .../armem_gui/commit_widget/CommitWidget.h    |   2 +-
 .../libraries/armem_gui/memory/GroupBox.cpp   |   8 +-
 .../armem_gui/query_widgets/QueryWidget.cpp   |   6 +-
 .../armem_gui/query_widgets/QueryWidget.h     |   4 +-
 .../armem_gui/query_widgets/SnapshotForm.cpp  |   4 +-
 .../armem_gui/query_widgets/SnapshotForm.h    |   2 +-
 .../query_widgets/SnapshotSelectorWidget.cpp  |  34 +----
 .../query_widgets/SnapshotSelectorWidget.h    |   8 +-
 .../aron/codegeneration/CMakeLists.txt        |   2 -
 .../codegenerator/codewriter/cpp/Writer.cpp   |   2 +-
 .../libraries/aron/common/test/MyCustomType.h |   2 +-
 .../libraries/aron/core/CMakeLists.txt        |   2 +
 .../codegeneration}/cpp/AronGeneratedClass.h  |   0
 81 files changed, 618 insertions(+), 497 deletions(-)
 delete mode 100644 source/RobotAPI/interface/armem/io.ice
 create mode 100644 source/RobotAPI/interface/armem/structure.ice
 create mode 100644 source/RobotAPI/libraries/armem/core/query.h
 create mode 100644 source/RobotAPI/libraries/armem/core/query/DataMode.cpp
 rename source/RobotAPI/libraries/armem/core/{ => query}/DataMode.h (70%)
 create mode 100644 source/RobotAPI/libraries/armem/core/query/QueryTarget.cpp
 create mode 100644 source/RobotAPI/libraries/armem/core/query/QueryTarget.h
 rename source/RobotAPI/libraries/aron/{codegeneration/codegenerator/codewriter => core/codegeneration}/cpp/AronGeneratedClass.h (100%)

diff --git a/source/RobotAPI/interface/CMakeLists.txt b/source/RobotAPI/interface/CMakeLists.txt
index 1559da7cf..5d9d3c04b 100644
--- a/source/RobotAPI/interface/CMakeLists.txt
+++ b/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
diff --git a/source/RobotAPI/interface/armem/io.ice b/source/RobotAPI/interface/armem/io.ice
deleted file mode 100644
index e99472e92..000000000
--- a/source/RobotAPI/interface/armem/io.ice
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <ArmarXCore/interface/core/PackagePath.ice>
-#include <RobotAPI/interface/armem/memory.ice>
-#include <RobotAPI/interface/armem/query.ice>
-
-module armarx
-{
-    module armem
-    {
-
-    };
-};
diff --git a/source/RobotAPI/interface/armem/query.ice b/source/RobotAPI/interface/armem/query.ice
index f5555e4f3..c672e42dd 100644
--- a/source/RobotAPI/interface/armem/query.ice
+++ b/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;
diff --git a/source/RobotAPI/interface/armem/server/ReadingMemoryInterface.ice b/source/RobotAPI/interface/armem/server/ReadingMemoryInterface.ice
index d8eed09f3..8a0d185d6 100644
--- a/source/RobotAPI/interface/armem/server/ReadingMemoryInterface.ice
+++ b/source/RobotAPI/interface/armem/server/ReadingMemoryInterface.ice
@@ -1,6 +1,7 @@
 #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();
             };
         };
     };
diff --git a/source/RobotAPI/interface/armem/server/RecordingMemoryInterface.ice b/source/RobotAPI/interface/armem/server/RecordingMemoryInterface.ice
index b52fe01a0..1da45e9db 100644
--- a/source/RobotAPI/interface/armem/server/RecordingMemoryInterface.ice
+++ b/source/RobotAPI/interface/armem/server/RecordingMemoryInterface.ice
@@ -1,7 +1,6 @@
 #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();
             };
         };
     };
diff --git a/source/RobotAPI/interface/armem/server/ReplayingMemoryInterface.ice b/source/RobotAPI/interface/armem/server/ReplayingMemoryInterface.ice
index d881a0dc6..d0825d838 100644
--- a/source/RobotAPI/interface/armem/server/ReplayingMemoryInterface.ice
+++ b/source/RobotAPI/interface/armem/server/ReplayingMemoryInterface.ice
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <RobotAPI/interface/armem/io.ice>
+#include <RobotAPI/interface/armem/memory.ice>
 
 
 module armarx
diff --git a/source/RobotAPI/interface/armem/structure.ice b/source/RobotAPI/interface/armem/structure.ice
new file mode 100644
index 000000000..2331a9e9b
--- /dev/null
+++ b/source/RobotAPI/interface/armem/structure.ice
@@ -0,0 +1,21 @@
+#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...)
+                };
+            };
+        };
+    };
+};
diff --git a/source/RobotAPI/libraries/armem/CMakeLists.txt b/source/RobotAPI/libraries/armem/CMakeLists.txt
index a75412cac..c17efd186 100644
--- a/source/RobotAPI/libraries/armem/CMakeLists.txt
+++ b/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
diff --git a/source/RobotAPI/libraries/armem/client/Query.cpp b/source/RobotAPI/libraries/armem/client/Query.cpp
index aeb21e97f..b6a66fb7d 100644
--- a/source/RobotAPI/libraries/armem/client/Query.cpp
+++ b/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)
diff --git a/source/RobotAPI/libraries/armem/client/Query.h b/source/RobotAPI/libraries/armem/client/Query.h
index 56b9caa79..bee999f07 100644
--- a/source/RobotAPI/libraries/armem/client/Query.h
+++ b/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;
diff --git a/source/RobotAPI/libraries/armem/client/Reader.cpp b/source/RobotAPI/libraries/armem/client/Reader.cpp
index 03178f4e5..872f4b7dd 100644
--- a/source/RobotAPI/libraries/armem/client/Reader.cpp
+++ b/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;
 
diff --git a/source/RobotAPI/libraries/armem/client/Reader.h b/source/RobotAPI/libraries/armem/client/Reader.h
index 7358bea17..8f78b33ec 100644
--- a/source/RobotAPI/libraries/armem/client/Reader.h
+++ b/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;
diff --git a/source/RobotAPI/libraries/armem/client/query/Builder.cpp b/source/RobotAPI/libraries/armem/client/query/Builder.cpp
index 2a3182871..ff6300d56 100644
--- a/source/RobotAPI/libraries/armem/client/query/Builder.cpp
+++ b/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);
             }
         }
diff --git a/source/RobotAPI/libraries/armem/client/query/Builder.h b/source/RobotAPI/libraries/armem/client/query/Builder.h
index 90d3e211a..c4a33bc7a 100644
--- a/source/RobotAPI/libraries/armem/client/query/Builder.h
+++ b/source/RobotAPI/libraries/armem/client/query/Builder.h
@@ -1,8 +1,6 @@
 #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;
 
     };
 
diff --git a/source/RobotAPI/libraries/armem/client/query/detail/NameSelectorOps.h b/source/RobotAPI/libraries/armem/client/query/detail/NameSelectorOps.h
index ee004f1b8..79f501fe4 100644
--- a/source/RobotAPI/libraries/armem/client/query/detail/NameSelectorOps.h
+++ b/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;
 
 
diff --git a/source/RobotAPI/libraries/armem/client/query/detail/SelectorOps.h b/source/RobotAPI/libraries/armem/client/query/detail/SelectorOps.h
index aa354b42f..95388b139 100644
--- a/source/RobotAPI/libraries/armem/client/query/detail/SelectorOps.h
+++ b/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);
                 }
             }
diff --git a/source/RobotAPI/libraries/armem/client/query/selectors.h b/source/RobotAPI/libraries/armem/client/query/selectors.h
index b9c257dc6..cf67e44e1 100644
--- a/source/RobotAPI/libraries/armem/client/query/selectors.h
+++ b/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();
diff --git a/source/RobotAPI/libraries/armem/core.h b/source/RobotAPI/libraries/armem/core.h
index 11abe789b..58ef0c64a 100644
--- a/source/RobotAPI/libraries/armem/core.h
+++ b/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"
 
diff --git a/source/RobotAPI/libraries/armem/core/query.h b/source/RobotAPI/libraries/armem/core/query.h
new file mode 100644
index 000000000..975361744
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/core/query.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "query/DataMode.h"
+#include "query/QueryTarget.h"
+
+
+namespace armarx::armem::query
+{
+
+
+}
+
diff --git a/source/RobotAPI/libraries/armem/core/query/DataMode.cpp b/source/RobotAPI/libraries/armem/core/query/DataMode.cpp
new file mode 100644
index 000000000..07877d2dc
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/core/query/DataMode.cpp
@@ -0,0 +1,9 @@
+#include "DataMode.h"
+
+namespace armarx::armem::query
+{
+    DataMode boolToDataMode(bool withData)
+    {
+        return withData ? DataMode::WithData : DataMode::NoData;
+    }
+}
diff --git a/source/RobotAPI/libraries/armem/core/DataMode.h b/source/RobotAPI/libraries/armem/core/query/DataMode.h
similarity index 70%
rename from source/RobotAPI/libraries/armem/core/DataMode.h
rename to source/RobotAPI/libraries/armem/core/query/DataMode.h
index d2e80cac2..0bcd7be09 100644
--- a/source/RobotAPI/libraries/armem/core/DataMode.h
+++ b/source/RobotAPI/libraries/armem/core/query/DataMode.h
@@ -1,7 +1,7 @@
 #pragma once
 
 
-namespace armarx::armem
+namespace armarx::armem::query
 {
 
     enum class DataMode
@@ -10,4 +10,5 @@ namespace armarx::armem
         WithData,   ///< Get structure and ARON data.
     };
 
+    DataMode boolToDataMode(bool withData);
 }
diff --git a/source/RobotAPI/libraries/armem/core/query/QueryTarget.cpp b/source/RobotAPI/libraries/armem/core/query/QueryTarget.cpp
new file mode 100644
index 000000000..e66a41907
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/core/query/QueryTarget.cpp
@@ -0,0 +1,21 @@
+#include "QueryTarget.h"
+
+namespace armarx::armem::query
+{
+    void toIce(armem::query::data::QueryTarget::QueryTargetEnum& ice, const QueryTarget bo)
+    {
+        switch(bo)
+        {
+            case QueryTarget::WM: ice = armem::query::data::QueryTarget::WM; break;
+            case QueryTarget::WM_LTM: ice = armem::query::data::QueryTarget::WM_LTM; break;
+        }
+    }
+    void fromIce(const armem::query::data::QueryTarget::QueryTargetEnum ice, QueryTarget& bo)
+    {
+        switch(ice)
+        {
+            case armem::query::data::QueryTarget::WM: bo = QueryTarget::WM; break;
+            case armem::query::data::QueryTarget::WM_LTM: bo = QueryTarget::WM_LTM; break;
+        }
+    }
+}
diff --git a/source/RobotAPI/libraries/armem/core/query/QueryTarget.h b/source/RobotAPI/libraries/armem/core/query/QueryTarget.h
new file mode 100644
index 000000000..304157213
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/core/query/QueryTarget.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <RobotAPI/interface/armem/query.h>
+
+namespace armarx::armem::query
+{
+
+    enum class QueryTarget
+    {
+        WM,
+        WM_LTM
+    };
+    void toIce(armem::query::data::QueryTarget::QueryTargetEnum& ice, const QueryTarget bo);
+    void fromIce(const armem::query::data::QueryTarget::QueryTargetEnum ice, QueryTarget& bo);
+}
diff --git a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
index a4397d037..93673c8aa 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
+++ b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
@@ -7,6 +7,8 @@
 #include <RobotAPI/libraries/armem/core/error.h>
 #include <RobotAPI/libraries/armem/core/ice_conversions.h>
 #include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
+
+#include <RobotAPI/libraries/armem/client/query/Builder.h>
 #include <RobotAPI/libraries/armem/server/wm/ice_conversions.h>
 
 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
@@ -193,7 +195,7 @@ namespace armarx::armem::server
                 }
 
                 // Consollidate to ltm
-                if (longtermMemory->enabled)
+                if (longtermMemory->isRecording())
                 {
                     //ARMARX_IMPORTANT << longtermMemory->id().str();
                     //ARMARX_IMPORTANT << longtermMemory->getPath();
@@ -267,42 +269,42 @@ namespace armarx::armem::server
         ARMARX_CHECK_NOT_NULL(longtermMemory);
 
         // Core segment processors will aquire the core segment locks.
-        query_proc::wm_server::MemoryQueryProcessor wmServerProcessor(
-            input.withData ? armem::DataMode::WithData : armem::DataMode::NoData);
-        armem::wm::Memory wmResult = wmServerProcessor.process(input.memoryQueries, *workingMemory);
+        query_proc::wm_server::MemoryQueryProcessor wmServerProcessor(armem::query::boolToDataMode(input.withData));
+        armem::wm::Memory wmResult = wmServerProcessor.process(input, *workingMemory);
 
         armem::query::data::Result result;
 
-        if (longtermMemory->enabled)
-        {
-            query_proc::ltm_server::disk::MemoryQueryProcessor ltmProcessor;
-            armem::wm::Memory ltmResult = ltmProcessor.process(input, *longtermMemory);
-
-            if (not ltmResult.empty())
-            {
-                ARMARX_INFO << "The LTM returned data after query";
-
-                longtermMemory->resolve(ltmResult); // convert memory ==> meaning resolving references
+        query_proc::ltm_server::disk::MemoryQueryProcessor ltmProcessor;
+        armem::wm::Memory ltmResult = ltmProcessor.process(input, *longtermMemory);
 
-                wmResult.append(ltmResult);
-                if (wmResult.empty())
-                {
-                    ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
-                }
+        if (not ltmResult.empty())
+        {
+            ARMARX_INFO << "The LTM returned data after query";
 
-                // query again to limit output size (TODO: Skip if querytype is all)
-                auto queryInput = armem::client::QueryInput::fromIce(input);
-                queryInput.replaceQueryTarget(query::data::QueryTarget::LTM, query::data::QueryTarget::WM);
+            // convert memory ==> meaning resolving references
+            // upon query, the LTM only returns a structure of the data (memory without data)
+            longtermMemory->resolve(ltmResult);
 
-                query_proc::wm::MemoryQueryProcessor wm2wmProcessor(
-                    input.withData ? armem::DataMode::WithData : armem::DataMode::NoData);
-                wmResult = wm2wmProcessor.process(queryInput.toIce(), wmResult);
-                if (wmResult.empty())
-                {
-                    ARMARX_ERROR << "A merged and postprocessed Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
-                }
+            // append result to return memory and sanity check
+            wmResult.append(ltmResult);
+            if (wmResult.empty())
+            {
+                ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
+            }
 
-                // also move results of ltm to wm
+            // Ist das wirklich notwendig?
+            // query again to limit output size (TODO: Skip if querytype is all)
+            //auto queryInput = armem::client::QueryInput::fromIce(input);
+            //query_proc::wm::MemoryQueryProcessor wm2wmProcessor(armem::query::boolToDataMode(input.withData));
+            //wmResult = wm2wmProcessor.process(queryInput.toIce(), wmResult);
+            //if (wmResult.empty())
+            //{
+            //    ARMARX_ERROR << "A merged and postprocessed Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
+            //}
+
+            if (longtermMemory->isRecording())
+            {
+                // TODO: also move results of ltm to wm
                 //this->commit(toCommit(ltm_converted));
 
                 // mark removed entries of wm in viewer
@@ -328,16 +330,46 @@ namespace armarx::armem::server
         return client::QueryResult::fromIce(query(input.toIce()));
     }
 
+    armem::structure::data::GetServerStructureResult MemoryToIceAdapter::getServerStructure()
+    {
+        ARMARX_TRACE;
+        ARMARX_CHECK_NOT_NULL(workingMemory);
+        ARMARX_CHECK_NOT_NULL(longtermMemory);
+
+        armem::structure::data::GetServerStructureResult ret;
+        ret.success = true;
+
+        wm::Memory structure;
+        structure.id() = workingMemory->id();
+
+        // Get all info from the WM
+        client::QueryBuilder builder(armem::query::DataMode::NoData);
+        builder.all();
+        auto query_result = this->query(builder.buildQueryInput());
+        if (query_result.success)
+        {
+            structure.append(query_result.memory);
+        }
+
+        // Get all info from the LTM
+        structure.append(longtermMemory->loadAllReferences());
+
+        ret.serverStructure = armarx::toIce<data::MemoryPtr>(structure);
+
+        return ret;
+    }
+
 
     // LTM LOADING FROM LTM
 
     // LTM STORING AND RECORDING
-    dto::DirectlyStoreResult MemoryToIceAdapter::directlyStore(dto::DirectlyStoreInput directlStoreInput)
+    dto::DirectlyStoreResult MemoryToIceAdapter::directlyStore(const dto::DirectlyStoreInput& directlStoreInput)
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(longtermMemory);
 
         dto::DirectlyStoreResult output;
+        output.success = true;
 
         armem::wm::Memory m = armarx::fromIce<armem::wm::Memory>(directlStoreInput.memory);
         longtermMemory->store(m);
@@ -345,12 +377,12 @@ namespace armarx::armem::server
         return output;
     }
 
-    dto::StartRecordResult MemoryToIceAdapter::startRecord(dto::StartRecordInput startRecordInput)
+    dto::StartRecordResult MemoryToIceAdapter::startRecord(const dto::StartRecordInput& startRecordInput)
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(longtermMemory);
-        ARMARX_IMPORTANT << "ENABLING THE RECORDING OF MEMORY " << longtermMemory->id().str();
-        longtermMemory->enabled = true;
+        ARMARX_IMPORTANT << "Enabling the recording of memory " << longtermMemory->id().str();
+        longtermMemory->startRecording();
 
         dto::StartRecordResult ret;
         ret.success = true;
@@ -362,8 +394,8 @@ namespace armarx::armem::server
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(longtermMemory);
-        ARMARX_IMPORTANT << "DISABLING THE RECORDING OF MEMORY " << longtermMemory->id().str();
-        longtermMemory->enabled = false;
+        ARMARX_IMPORTANT << "Disabling the recording of memory " << longtermMemory->id().str();
+        longtermMemory->stopRecording();
 
         dto::StopRecordResult ret;
         ret.success = true;
@@ -376,13 +408,22 @@ namespace armarx::armem::server
         dto::RecordStatusResult ret;
         ret.success = true;
 
-        return ret;
-    }
+        long savedSnapshots;
+        long totalSnapshots;
+        longtermMemory->forEachCoreSegment([&savedSnapshots, &totalSnapshots](const auto& c){
+            c.forEachProviderSegment([&savedSnapshots, &totalSnapshots](const auto& p){
+                p.forEachEntity([&savedSnapshots, &totalSnapshots](const auto& e){
+                    savedSnapshots += e.getStatistics().recordedSnapshots;
+
+                    e.forEachSnapshot([&totalSnapshots](const auto&){
+                        totalSnapshots++;
+                    });
+                });
+            });
+        });
 
-    dto::GetServerStructureResult MemoryToIceAdapter::getServerStructure()
-    {
-        dto::GetServerStructureResult ret;
-        ret.success = true;
+        ret.status.savedSnapshots = savedSnapshots;
+        ret.status.totalSnapshots = totalSnapshots;
 
         return ret;
     }
diff --git a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
index f4aeba5c7..6f1979639 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
+++ b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
@@ -46,15 +46,15 @@ namespace armarx::armem::server
         // READING
         query::data::Result query(const armem::query::data::Input& input);
         client::QueryResult query(const client::QueryInput& input);
+        armem::structure::data::GetServerStructureResult getServerStructure();
 
         // LTM LOADING AND REPLAYING
 
         // LTM STORING AND RECORDING
-        dto::DirectlyStoreResult directlyStore(dto::DirectlyStoreInput directlStoreInput);
-        dto::StartRecordResult startRecord(dto::StartRecordInput startRecordInput);
+        dto::DirectlyStoreResult directlyStore(const dto::DirectlyStoreInput& directlStoreInput);
+        dto::StartRecordResult startRecord(const dto::StartRecordInput& startRecordInput);
         dto::StopRecordResult stopRecord();
         dto::RecordStatusResult getRecordStatus();
-        dto::GetServerStructureResult getServerStructure();
 
         // PREDICTION
         prediction::data::EngineSupportMap getAvailableEngines();
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h
index 4dade14f3..f61b4451d 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h
@@ -75,11 +75,9 @@ namespace armarx::armem::server::ltm
             this->directlyStore(*to_store);
         }
 
-        virtual void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix) override
+        /// configuration
+        virtual void configure()
         {
-            Base::createPropertyDefinitions(defs, prefix);
-
-            defs->optional(storeFrequency, prefix + ".buffer.storeFreq", "Frequency to store the buffer to the LTM in Hz.").setMin(1).setMax(1000);
         }
 
     protected:
@@ -110,7 +108,7 @@ namespace armarx::armem::server::ltm
         /// The periodic'task to store the content of the buffer to the ltm
         typename armarx::PeriodicTask<BufferedMemoryBase>::pointer_type task = nullptr;
 
-        /// The frequency to store data to the ltm
+        /// The frequency (Hz) to store data to the ltm
         float storeFrequency = 10;
 
         /// a mutex to access the buffer object
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h
index d34d693af..b975b352f 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h
@@ -17,6 +17,13 @@ namespace armarx::armem::server::ltm
     template <class _ProviderSegmentT>
     class CoreSegmentBase : public MemoryItem
     {
+    public:
+        struct Statistics
+        {
+            long recordedProviderSegments = 0;
+
+        };
+
     public:
         using ProviderSegmentT = _ProviderSegmentT;
 
@@ -47,6 +54,16 @@ namespace armarx::armem::server::ltm
             _storeType(coreSeg);
         }
 
+        /// statistics
+        void resetStatistics()
+        {
+            statistics.recordedProviderSegments = 0;
+        }
+        Statistics getStatistics() const
+        {
+            return statistics;
+        }
+
         /// iterate over all provider segments of this ltm
         virtual bool forEachProviderSegment(std::function<void(ProviderSegmentT&)>&& func) const = 0;
 
@@ -73,5 +90,7 @@ namespace armarx::armem::server::ltm
 
     protected:
         mutable std::recursive_mutex ltm_mutex;
+
+        Statistics statistics;
     };
 } // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h
index 5f92e1a20..9dedb572f 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h
@@ -17,6 +17,13 @@ namespace armarx::armem::server::ltm
     template <class _EntitySnapshotT>
     class EntityBase : public MemoryItem
     {
+    public:
+        struct Statistics
+        {
+            long recordedSnapshots = 0;
+
+        };
+
     public:
         using EntitySnapshotT = _EntitySnapshotT;
 
@@ -41,6 +48,16 @@ namespace armarx::armem::server::ltm
             _store(e);
         }
 
+        /// statistics
+        void resetStatistics()
+        {
+            statistics.recordedSnapshots = 0;
+        }
+        Statistics getStatistics() const
+        {
+            return statistics;
+        }
+
         /// iterate over all entity snapshots of this ltm
         virtual bool forEachSnapshot(std::function<void(EntitySnapshotT&)>&& func) const = 0;
         virtual bool forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshotT&)>&& func) const = 0;
@@ -68,5 +85,7 @@ namespace armarx::armem::server::ltm
 
     protected:
         mutable std::recursive_mutex ltm_mutex;
+
+        Statistics statistics;
     };
 } // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h
index 5ebca1943..411dd43cc 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h
@@ -14,6 +14,13 @@ namespace armarx::armem::server::ltm
     /// @brief Interface functions for the longterm memory classes
     class EntitySnapshotBase : public MemoryItem
     {
+    public:
+        struct Statistics
+        {
+            long recordedInstances = 0;
+
+        };
+
     public:
 
         using MemoryItem::MemoryItem;
@@ -32,19 +39,31 @@ namespace armarx::armem::server::ltm
         }
 
         /// encode the content of a wm::Memory and store
-        void store(const armem::wm::EntitySnapshot& e) const
+        void store(const armem::wm::EntitySnapshot& e)
         {
             _store(e);
         }
 
+        /// statistics
+        void resetStatistics()
+        {
+            statistics.recordedInstances = 0;
+        }
+        Statistics getStatistics() const
+        {
+            return statistics;
+        }
+
         static std::string getLevelName();
 
     protected:
         virtual void _loadAllReferences(armem::wm::EntitySnapshot&) const = 0;
         virtual void _resolve(armem::wm::EntitySnapshot&) const = 0;
-        virtual void _store(const armem::wm::EntitySnapshot&) const = 0;
+        virtual void _store(const armem::wm::EntitySnapshot&) = 0;
 
     protected:
         mutable std::recursive_mutex ltm_mutex;
+
+        Statistics statistics;
     };
 } // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h
index d7ec68da7..35762b0ce 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h
@@ -25,6 +25,13 @@ namespace armarx::armem::server::ltm
     template <class _CoreSegmentT>
     class MemoryBase : public MemoryItem
     {
+    public:
+        struct Statistics
+        {
+            armarx::core::time::DateTime lastEnabled = armarx::core::time::DateTime::Invalid();
+            long recordedCoreSegments = 0;
+        };
+
     public:
         using CoreSegmentT = _CoreSegmentT;
 
@@ -38,6 +45,20 @@ namespace armarx::armem::server::ltm
         {
         }
 
+        /// initialize config
+        void init()
+        {
+            // init without changing the memory id
+            init(this->id());
+        }
+        void init(const armem::MemoryID& wmMemoryId)
+        {
+            setMemoryID(wmMemoryId);
+
+            enabled = enabled_on_startup;
+            this->configure(nlohmann::json::parse(configuration_on_startup));
+        }
+
         /// return the full ltm as a wm::Memory with only references
         /// the ltm may be huge, use with caution
         armem::wm::Memory loadAllReferences()
@@ -111,7 +132,43 @@ namespace armarx::armem::server::ltm
         /// parameters
         virtual void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix)
         {
-            processors->createPropertyDefinitions(defs, prefix);
+            defs->optional(enabled_on_startup, prefix + ".enabled");
+            defs->optional(configuration_on_startup, prefix + ".configuration");
+            //processors->createPropertyDefinitions(defs, prefix);
+        }
+
+        /// configuration
+        virtual void configure(const nlohmann::json& config)
+        {
+            // Processors are shared. So we only need to configure the root
+            processors->configure(config);
+        }
+
+        /// enable/disable
+        void startRecording()
+        {
+            statistics.lastEnabled = armarx::core::time::DateTime::Now();
+            enabled = true;
+        }
+        void stopRecording()
+        {
+            enabled = false;
+        }
+        bool isRecording() const
+        {
+            return enabled;
+        }
+
+        /// statistics
+        virtual void resetStatistics()
+        {
+            // enabled stays the same
+            statistics.lastEnabled = armarx::core::time::DateTime::Invalid();
+            statistics.recordedCoreSegments = 0;
+        }
+        Statistics getStatistics() const
+        {
+            return statistics;
         }
 
         /// get level name
@@ -126,10 +183,17 @@ namespace armarx::armem::server::ltm
         virtual void _store(const armem::wm::Memory& memory) = 0;
 
     public:
-        bool enabled = false;
+        // stuff for scenario parameters
+        bool enabled_on_startup = false;
+        std::string configuration_on_startup = "";
 
     protected:
         mutable std::recursive_mutex ltm_mutex;
 
+        Statistics statistics;
+
+    private:
+        std::atomic_bool enabled = false;
+
     };
 } // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.cpp
index 6e176bf79..33934e1af 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.cpp
@@ -14,22 +14,8 @@ namespace armarx::armem::server::ltm
         converters.insert({exrConverter.identifier, &exrConverter});
     }
 
-    void Processors::createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix)
+    void Processors::configure(const nlohmann::json& config)
     {
-        // filters
-        defs->optional(memFreqFilter.enabled, prefix + "memFreqFilter.Enabled");
-        defs->optional(memFreqFilter.waitingTimeInMs, prefix + "memFreqFilter.WaitingTime", "Waiting time in MS after each LTM update.");
-        defs->optional(snapFreqFilter.enabled, prefix + "snapFreqFilter.Enabled");
-        defs->optional(snapFreqFilter.waitingTimeInMs, prefix + "snapFreqFilter.WaitingTime", "Waiting time in MS after each Entity update.");
-        defs->optional(snapEqFilter.enabled, prefix + "snapEqFilter.Enabled");
-        defs->optional(snapEqFilter.maxWaitingTimeInMs, prefix + "snapEqFilter.MaxWaitingTime", "Max Waiting time in MS after each Entity update.");
 
-        // extractors
-        defs->optional(imageExtractor.enabled, prefix + "imageExtractor.Enabled");
-        defs->optional(depthImageExtractor.enabled, prefix + "depthImageExtractor.Enabled");
-
-        // converters
-        defs->optional(pngConverter.enabled, prefix + "pngConverter.Enabled");
-        defs->optional(exrConverter.enabled, prefix + "exrConverter.Enabled");
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.h
index cc10b538d..43677cb9b 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.h
@@ -25,7 +25,7 @@ namespace armarx::armem::server::ltm
     {
     public:
         Processors();
-        void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix);
+        void configure(const nlohmann::json& config);
 
     public:
         // Unique Memory Filters
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h
index b3c4be572..b5aa8f0ee 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h
@@ -17,6 +17,13 @@ namespace armarx::armem::server::ltm
     template <class _EntityT>
     class ProviderSegmentBase : public MemoryItem
     {
+    public:
+        struct Statistics
+        {
+            long recordedEntities = 0;
+
+        };
+
     public:
         using EntityT = _EntityT;
 
@@ -47,6 +54,16 @@ namespace armarx::armem::server::ltm
             _storeType(coreSeg);
         }
 
+        /// statistics
+        void resetStatistics()
+        {
+            statistics.recordedEntities = 0;
+        }
+        Statistics getStatistics() const
+        {
+            return statistics;
+        }
+
         /// iterate over all core segments of this ltm
         virtual bool forEachEntity(std::function<void(EntityT&)>&& func) const = 0;
 
@@ -71,5 +88,7 @@ namespace armarx::armem::server::ltm
 
     protected:
         mutable std::recursive_mutex ltm_mutex;
+
+        Statistics statistics;
     };
 } // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
index ee45273c7..785276d04 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
@@ -126,6 +126,8 @@ namespace armarx::armem::server::ltm::disk
             ProviderSegment c(memoryParentPath, id().withProviderSegmentName(prov.id().providerSegmentName), processors, encodingModeOfPast, currentMaxExport);
             util::ensureFolderExists(defaultMPath, c.getRelativePathForMode(defaultMode), true);
 
+            statistics.recordedProviderSegments++;
+
             c.storeType(prov);
             c.store(prov);
         });
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
index b64531211..6c87da45e 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
@@ -5,6 +5,7 @@
 #include <ArmarXCore/core/time/TimeUtil.h>
 #include <ArmarXCore/core/logging/Logging.h>
 
+#include <RobotAPI/libraries/armem/core/base/detail/negative_index_semantics.h>
 #include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
 
 #include "../base/filter/frequencyFilter/FrequencyFilter.h"
@@ -76,7 +77,33 @@ namespace armarx::armem::server::ltm::disk
 
     bool Entity::forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshot&)>&& func) const
     {
-        throw LocalException("NOT IMPLEMENTED YET BECAUSE THE DIRECTORY ITERATOR IS UNSORTED!");
+        ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
+
+        if (first < 0 or last < 0)
+        {
+            // We need to know what the size of the memory is... May be slow
+            unsigned long size = 0;
+            auto f = [&](EntitySnapshot& e)
+            {
+                size++;
+            };
+            forEachSnapshot(std::move(f));
+
+            first = armarx::armem::base::detail::negativeIndexSemantics(first, size);
+            last = armarx::armem::base::detail::negativeIndexSemantics(last, size);
+        }
+
+        long checked = 0;
+        auto f = [&](EntitySnapshot& e)
+        {
+            checked++;
+            if (checked >= first && checked <= last)
+            {
+                func(e);
+            }
+        };
+
+        return forEachSnapshot(std::move(f));
     }
 
     bool Entity::forEachSnapshotInTimeRange(const Time& min, const Time& max, std::function<void(EntitySnapshot&)>&& func) const
@@ -335,6 +362,9 @@ namespace armarx::armem::server::ltm::disk
 
             EntitySnapshot c(memoryParentPath, id().withTimestamp(snap.id().timestamp), processors, encodingModeOfPast, currentMaxExport);
             util::ensureFolderExists(defaultMPath, c.getRelativePathForMode(defaultMode));
+
+            statistics.recordedSnapshots++;
+
             c.store(snap);
         });
     }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
index 3d43ea8a0..4d24c2e6b 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
@@ -130,7 +130,7 @@ namespace armarx::armem::server::ltm::disk
         }
     }
 
-    void EntitySnapshot::_store(const armem::wm::EntitySnapshot& e) const
+    void EntitySnapshot::_store(const armem::wm::EntitySnapshot& e)
     {
         //auto currentMaxExport = currentExport;
         //auto encodingModeOfPast = currentMode;
@@ -215,6 +215,8 @@ namespace armarx::armem::server::ltm::disk
                 ARMARX_CHECK_EMPTY(dataVecModeSuffix);
                 ARMARX_CHECK_EMPTY(metadataVecModeSuffix);
 
+                statistics.recordedInstances++;
+
                 util::writeDataToFileRepeated(defaultMPath, relDataPath, dataVec);
                 util::writeDataToFileRepeated(defaultMPath, relMetadataPath, metadataVec);
             }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h
index b91c69b78..aa72ea3e1 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h
@@ -19,7 +19,7 @@ namespace armarx::armem::server::ltm::disk
     protected:
         void _loadAllReferences(armem::wm::EntitySnapshot&) const override;
         void _resolve(armem::wm::EntitySnapshot&) const override;
-        void _store(const armem::wm::EntitySnapshot&) const override;
+        void _store(const armem::wm::EntitySnapshot&) override;
 
     private:
         MemoryEncodingMode currentMode;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
index 0eccbbf1a..0a85e4ac5 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
@@ -188,6 +188,8 @@ namespace armarx::armem::server::ltm::disk
             CoreSegment c(memoryParentPath, id().withCoreSegmentName(core.id().coreSegmentName), processors, encodeModeOfPast, 0 /* how far to look back in past on enity level. For full lookup use maxExportIndex. */);
             util::ensureFolderExists(defaultMPath, c.getRelativePathForMode(defaultMode), true); // create subfolder
 
+            statistics.recordedCoreSegments++;
+
             // 1. store type
             c.storeType(core);
 
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
index df52832d1..ede13058b 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
@@ -127,6 +127,9 @@ namespace armarx::armem::server::ltm::disk
         {
             Entity c(memoryParentPath, id().withEntityName(e.id().entityName), processors, encodingModeOfPast, currentMaxExport);
             util::ensureFolderExists(defaultMPath, c.getRelativePathForMode(defaultMode), true);
+
+            statistics.recordedEntities++;
+
             c.store(e);
         });
     }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/io/Recording.cpp b/source/RobotAPI/libraries/armem/server/ltm/io/Recording.cpp
index 949692ec5..265a4f0f9 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/io/Recording.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/io/Recording.cpp
@@ -159,7 +159,7 @@ namespace armarx::armem::server::ltm
 
     /* ===========================
      * GetServerStructureResult
-     * =========================== */
+     * ===========================
     GetServerStructureResult GetServerStructureResult::fromIce(const dto::GetServerStructureResult& ice)
     {
         return armarx::fromIce<GetServerStructureResult>(ice);
@@ -177,5 +177,5 @@ namespace armarx::armem::server::ltm
     {
         fromIce(ice, dynamic_cast<detail::SuccessHeader&>(result));
         fromIce(ice.serverStructure, result.serverStructure);
-    }
+    }*/
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/io/Recording.h b/source/RobotAPI/libraries/armem/server/ltm/io/Recording.h
index a664bf673..3d1def0b1 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/io/Recording.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/io/Recording.h
@@ -110,7 +110,7 @@ namespace armarx::armem::server::ltm
 
     /* ===========================
      * GetServerStructureResult
-     * =========================== */
+     * ===========================
     struct GetServerStructureResult : public detail::SuccessHeader
     {
         armem::wm::Memory serverStructure;
@@ -119,5 +119,5 @@ namespace armarx::armem::server::ltm
         dto::GetServerStructureResult toIce() const;
     };
     void toIce(dto::GetServerStructureResult& ice, const GetServerStructureResult& input);
-    void fromIce(const dto::GetServerStructureResult& ice, GetServerStructureResult& input);
+    void fromIce(const dto::GetServerStructureResult& ice, GetServerStructureResult& input);*/
 }
diff --git a/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp b/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp
index 40d22cead..fbeff6c93 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp
+++ b/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp
@@ -26,17 +26,12 @@ namespace armarx::armem::server::plugins
     void Plugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties)
     {
         const std::string prefix = "mem.";
-        if (not workingMemory.name().empty()
-            and not properties->hasDefinition(prefix + "MemoryName"))
+        if (not workingMemory.name().empty() and not properties->hasDefinition(prefix + "MemoryName"))
         {
             properties->optional(workingMemory.name(), prefix + "MemoryName", "Name of this memory server.");
         }
 
         // stuff for ltm
-        if (not properties->hasDefinition(prefix + "ltm.enabled"))
-        {
-            properties->optional(longtermMemory.enabled, prefix + "ltm.enabled");
-        }
         longtermMemory.createPropertyDefinitions(properties, prefix + "ltm.");
     }
 
@@ -45,6 +40,14 @@ namespace armarx::armem::server::plugins
     {
         memoryTopicName = client::util::MemoryListener::MakeMemoryTopicName(MemoryID(workingMemory.name()));
         parent().offeringTopic(memoryTopicName);
+
+        longtermMemory.init(workingMemory.id());
+    }
+
+
+    void Plugin::postOnInitComponent()
+    {
+        initialized = true;
     }
 
 
@@ -59,6 +62,8 @@ namespace armarx::armem::server::plugins
         }
         parent.getTopic(memoryTopic, memoryTopicName);
         iceAdapter.setMemoryListener(memoryTopic);
+
+        connected = true;
     }
 
 
@@ -73,8 +78,12 @@ namespace armarx::armem::server::plugins
 
     void Plugin::setMemoryName(const std::string& memoryName)
     {
+        if (initialized)
+        {
+            ARMARX_WARNING << "Please set the memory name before initializing the component. Otherwise the WM and LTM may have different names";
+        }
+
         workingMemory.name() = memoryName;
-        longtermMemory.setMemoryID(workingMemory.id());
     }
 
 
diff --git a/source/RobotAPI/libraries/armem/server/plugins/Plugin.h b/source/RobotAPI/libraries/armem/server/plugins/Plugin.h
index dcbe7adc4..02c89e5f3 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/Plugin.h
+++ b/source/RobotAPI/libraries/armem/server/plugins/Plugin.h
@@ -34,6 +34,7 @@ namespace armarx::armem::server::plugins
         virtual void postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties) override;
 
         virtual void preOnInitComponent() override;
+        virtual void postOnInitComponent() override;
         virtual void postOnConnectComponent() override;
         virtual void preOnDisconnectComponent() override;
 
@@ -91,6 +92,9 @@ namespace armarx::armem::server::plugins
 
         client::plugins::Plugin* clientPlugin = nullptr;
 
+        std::atomic_bool initialized = false;
+        std::atomic_bool connected = false;
+
     };
 }
 
diff --git a/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.cpp b/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.cpp
index b95b94afb..e8805d525 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.cpp
+++ b/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.cpp
@@ -35,6 +35,12 @@ namespace armarx::armem::server::plugins
         return iceAdapter().query(input);
     }
 
+    structure::data::GetServerStructureResult ReadOnlyPluginUser::getServerStructure(const Ice::Current&)
+    {
+        ARMARX_TRACE;
+        return iceAdapter().getServerStructure();
+    }
+
 
     Plugin& ReadOnlyPluginUser::memoryServerPlugin()
     {
diff --git a/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.h b/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.h
index f56d66b0f..d234819b9 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.h
+++ b/source/RobotAPI/libraries/armem/server/plugins/ReadOnlyPluginUser.h
@@ -39,6 +39,10 @@ namespace armarx::armem::server::plugins
                 const Ice::Current& = Ice::emptyCurrent) override;
 
 
+        virtual armem::structure::data::GetServerStructureResult
+        getServerStructure(const Ice::Current& = Ice::emptyCurrent) override;
+
+
     public:
 
         Plugin& memoryServerPlugin();
diff --git a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
index 7bfd4478f..8d0b98644 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
+++ b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
@@ -60,6 +60,12 @@ namespace armarx::armem::server::plugins
         return iceAdapter().query(input);
     }
 
+    structure::data::GetServerStructureResult ReadWritePluginUser::getServerStructure(const Ice::Current&)
+    {
+        ARMARX_TRACE;
+        return iceAdapter().getServerStructure();
+    }
+
 
     // LTM STORING AND RECORDING
     dto::DirectlyStoreResult ReadWritePluginUser::directlyStore(const dto::DirectlyStoreInput& input, const Ice::Current&)
@@ -86,12 +92,6 @@ namespace armarx::armem::server::plugins
         return iceAdapter().getRecordStatus();
     }
 
-    dto::GetServerStructureResult ReadWritePluginUser::getServerStructure(const Ice::Current&)
-    {
-        ARMARX_TRACE;
-        return iceAdapter().getServerStructure();
-    }
-
 
     Plugin& ReadWritePluginUser::memoryServerPlugin()
     {
diff --git a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
index e952a4f83..3c29eb693 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
+++ b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
@@ -43,6 +43,7 @@ namespace armarx::armem::server::plugins
 
         // ReadingInterface interface
         virtual armem::query::data::Result query(const armem::query::data::Input& input, const Ice::Current& = Ice::emptyCurrent) override;
+        virtual armem::structure::data::GetServerStructureResult getServerStructure(const Ice::Current& = Ice::emptyCurrent) override;
 
 
         // StoringInterface interface
@@ -50,7 +51,6 @@ namespace armarx::armem::server::plugins
         virtual dto::StartRecordResult startRecord(const dto::StartRecordInput& startRecordInput, const Ice::Current& = Ice::emptyCurrent) override;
         virtual dto::StopRecordResult stopRecord(const Ice::Current& = Ice::emptyCurrent) override;
         virtual dto::RecordStatusResult getRecordStatus(const Ice::Current& = Ice::emptyCurrent) override;
-        virtual dto::GetServerStructureResult getServerStructure(const Ice::Current& = Ice::emptyCurrent) override;
 
         // ActionsInterface interface
         virtual armem::actions::GetActionsOutputSeq getActions(const armem::actions::GetActionsInputSeq& inputs);
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.cpp
index a3dfb4eb4..ae1dedc14 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.cpp
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.cpp
@@ -6,16 +6,4 @@
 namespace armarx::armem::server::query_proc::base
 {
 
-    std::set<query::data::QueryTarget>
-    detail::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;
-    }
-
 }
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h
index b4ad4300d..709457fb5 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h
@@ -1,29 +1,23 @@
 #pragma once
 
 #include <RobotAPI/interface/armem/query.h>
+#include <RobotAPI/libraries/armem/core/query/QueryTarget.h>
 
 #include <Ice/Handle.h>
 
 #include <set>
 #include <vector>
 
-
-namespace armarx::armem::server::query_proc::base::detail
-{
-    // 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.
-    std::set<query::data::QueryTarget> getTargets(const std::vector<query::data::QueryTarget>& _targets);
-}
 namespace armarx::armem::server::query_proc::base
 {
 
-    using QueryTarget = query::data::QueryTarget;
+    using QueryTarget = armem::query::data::QueryTarget::QueryTargetEnum;
 
 
     /**
      * @brief Base class for memory query processors.
      */
-    template <QueryTarget queryTarget, class DataT, class ResultT, class QueryT>
+    template <class DataT, class ResultT, class QueryT>
     class BaseQueryProcessorBase
     {
     public:
@@ -39,10 +33,7 @@ namespace armarx::armem::server::query_proc::base
         ResultT process(const QueryT& query, const DataT& data) const
         {
             ResultT result { data.id() };
-            if (detail::getTargets(query.targets).count(queryTarget))
-            {
-                this->process(result, query, data);
-            }
+            this->process(result, query, data);
             return result;
         }
 
@@ -67,10 +58,7 @@ namespace armarx::armem::server::query_proc::base
 
             for (const auto& query : queries)
             {
-                if (detail::getTargets(query->targets).count(queryTarget))
-                {
-                    this->process(result, *query, data);
-                }
+                this->process(result, *query, data);
             }
         }
 
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h
index 76b9ad735..70506550c 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h
@@ -14,13 +14,13 @@ namespace armarx::armem::server::query_proc::base
     /**
      * @brief Handles memory queries.
      */
-    template <QueryTarget queryTarget, class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
+    template <class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
     class CoreSegmentQueryProcessorBase :
-        public BaseQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, armem::query::data::CoreSegmentQuery>
+        public BaseQueryProcessorBase<_CoreSegmentT, _ResultCoreSegmentT, armem::query::data::CoreSegmentQuery>
     {
     protected:
 
-        using Base = BaseQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, armem::query::data::CoreSegmentQuery>;
+        using Base = BaseQueryProcessorBase<_CoreSegmentT, _ResultCoreSegmentT, armem::query::data::CoreSegmentQuery>;
 
     public:
 
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h
index 432453afb..e5578ace3 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h
@@ -22,13 +22,13 @@ namespace armarx::armem::server::query_proc::base::detail
 namespace armarx::armem::server::query_proc::base
 {
 
-    template <QueryTarget queryTarget, class _EntityT, class _ResultEntityT>
+    template <class _EntityT, class _ResultEntityT>
     class EntityQueryProcessorBase :
-        public BaseQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT, armem::query::data::EntityQuery>
+        public BaseQueryProcessorBase<_EntityT, _ResultEntityT, armem::query::data::EntityQuery>
     {
     protected:
 
-        using Base = BaseQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT, armem::query::data::EntityQuery>;
+        using Base = BaseQueryProcessorBase<_EntityT, _ResultEntityT, armem::query::data::EntityQuery>;
 
     public:
 
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h
index 3fc3deecb..ae8e1ddb8 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h
@@ -11,13 +11,13 @@
 namespace armarx::armem::server::query_proc::base
 {
 
-    template <QueryTarget queryTarget, class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
+    template <class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
     class MemoryQueryProcessorBase :
-        public BaseQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, armem::query::data::MemoryQuery>
+        public BaseQueryProcessorBase<_MemoryT, _ResultMemoryT, armem::query::data::MemoryQuery>
     {
     protected:
 
-        using Base = BaseQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, armem::query::data::MemoryQuery>;
+        using Base = BaseQueryProcessorBase<_MemoryT, _ResultMemoryT, armem::query::data::MemoryQuery>;
 
     public:
 
@@ -106,6 +106,12 @@ namespace armarx::armem::server::query_proc::base
 
     protected:
 
+        virtual bool _processAllowed(const armem::query::data::MemoryQuery& query) const
+        {
+            // always execute query. Override if you want to execute the quey only if a special condition is fulfilled (e.g. querytargets)
+            return true;
+        }
+
         void _processResult(ResultMemoryT& result,
                             const CoreSegmentT& coreSegment,
                             const armem::query::data::MemoryQuery& query) const
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h
index 7b138e9ac..240e38a37 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h
@@ -12,13 +12,13 @@
 namespace armarx::armem::server::query_proc::base
 {
 
-    template <QueryTarget queryTarget, class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
+    template <class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
     class ProviderSegmentQueryProcessorBase :
-        public BaseQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, armem::query::data::ProviderSegmentQuery>
+        public BaseQueryProcessorBase<_ProviderSegmentT, _ResultProviderSegmentT, armem::query::data::ProviderSegmentQuery>
     {
     protected:
 
-        using Base = BaseQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, armem::query::data::ProviderSegmentQuery>;
+        using Base = BaseQueryProcessorBase<_ProviderSegmentT, _ResultProviderSegmentT, armem::query::data::ProviderSegmentQuery>;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h
index 0f06af9da..f1c52ecc8 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h
@@ -9,13 +9,13 @@ namespace armarx::armem::server::query_proc::ltm::detail
     /**
      * @brief Handles memory queries.
      */
-    template <base::QueryTarget queryTarget, class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
+    template <class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
     class CoreSegmentQueryProcessorBase :
-        public base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>
+        public base::CoreSegmentQueryProcessorBase<_CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>
     {
     protected:
 
-        using Base = base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>;
+        using Base = base::CoreSegmentQueryProcessorBase<_CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
index 71374c40f..d9f64fc7a 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
@@ -6,13 +6,13 @@
 namespace armarx::armem::server::query_proc::ltm::detail
 {
 
-    template <base::QueryTarget queryTarget, class _EntityT, class _ResultEntityT>
+    template <class _EntityT, class _ResultEntityT>
     class EntityQueryProcessorBase :
-        public base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>
+        public base::EntityQueryProcessorBase<_EntityT, _ResultEntityT>
     {
     protected:
 
-        using Base = base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>;
+        using Base = base::EntityQueryProcessorBase<_EntityT, _ResultEntityT>;
 
     public:
         using EntityT = typename Base::EntityT;
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h
index a077de9ca..8ae444bc8 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h
@@ -6,13 +6,13 @@
 namespace armarx::armem::server::query_proc::ltm::detail
 {
 
-    template <base::QueryTarget queryTarget, class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
+    template <class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
     class MemoryQueryProcessorBase :
-        public base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>
+        public base::MemoryQueryProcessorBase<_MemoryT, _ResultMemoryT, _ChildProcessorT>
     {
     protected:
 
-        using Base = base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>;
+        using Base = base::MemoryQueryProcessorBase<_MemoryT, _ResultMemoryT, _ChildProcessorT>;
 
     public:
 
@@ -28,6 +28,14 @@ namespace armarx::armem::server::query_proc::ltm::detail
 
         using Base::process;
 
+    protected:
+
+        bool _processAllowed(const armem::query::data::MemoryQuery& query) const final
+        {
+            // only execute if query target is correct
+            return query.target == armem::query::data::QueryTarget::WM_LTM;
+        }
+
 
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h
index b3512921d..0559e2716 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h
@@ -6,13 +6,13 @@
 namespace armarx::armem::server::query_proc::ltm::detail
 {
 
-    template <base::QueryTarget queryTarget, class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
+    template <class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
     class ProviderSegmentQueryProcessorBase :
-        public base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>
+        public base::ProviderSegmentQueryProcessorBase<_ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>
     {
     protected:
 
-        using Base = base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>;
+        using Base = base::ProviderSegmentQueryProcessorBase<_ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>;
 
     public:
 
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h
index 80d83a15c..f569e986a 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h
@@ -10,15 +10,12 @@
 
 namespace armarx::armem::server::query_proc::ltm_server::disk
 {
-    static const base::QueryTarget queryTarget = query::data::QueryTarget::LTM;
-
-
     class EntityQueryProcessor :
-        public ltm::detail::EntityQueryProcessorBase<queryTarget, armem::server::ltm::disk::Entity, armem::wm::Entity>
+        public ltm::detail::EntityQueryProcessorBase<armem::server::ltm::disk::Entity, armem::wm::Entity>
     {
     protected:
 
-        using Base = ltm::detail::EntityQueryProcessorBase<queryTarget, armem::server::ltm::disk::Entity, armem::wm::Entity>;
+        using Base = ltm::detail::EntityQueryProcessorBase<armem::server::ltm::disk::Entity, armem::wm::Entity>;
 
 
     public:
@@ -28,11 +25,11 @@ namespace armarx::armem::server::query_proc::ltm_server::disk
     };
 
     class ProviderSegmentQueryProcessor :
-        public ltm::detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>
+        public ltm::detail::ProviderSegmentQueryProcessorBase<armem::server::ltm::disk::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>
     {
     protected:
 
-        using Base = ltm::detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
+        using Base = ltm::detail::ProviderSegmentQueryProcessorBase<armem::server::ltm::disk::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
 
 
     public:
@@ -40,11 +37,11 @@ namespace armarx::armem::server::query_proc::ltm_server::disk
     };
 
     class CoreSegmentQueryProcessor :
-        public ltm::detail::CoreSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>
+        public ltm::detail::CoreSegmentQueryProcessorBase<armem::server::ltm::disk::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>
     {
     protected:
 
-        using Base = ltm::detail::CoreSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
+        using Base = ltm::detail::CoreSegmentQueryProcessorBase<armem::server::ltm::disk::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
 
 
     public:
@@ -52,11 +49,11 @@ namespace armarx::armem::server::query_proc::ltm_server::disk
     };
 
     class MemoryQueryProcessor :
-        public ltm::detail::MemoryQueryProcessorBase<queryTarget, armem::server::ltm::disk::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>
+        public ltm::detail::MemoryQueryProcessorBase<armem::server::ltm::disk::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>
     {
     protected:
 
-        using Base = ltm::detail::MemoryQueryProcessorBase<queryTarget, armem::server::ltm::disk::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
+        using Base = ltm::detail::MemoryQueryProcessorBase<armem::server::ltm::disk::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
 
     public:
         using Base::process;
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h
index c9a0ddb51..70a8f32e4 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h
@@ -9,13 +9,13 @@ namespace armarx::armem::server::query_proc::wm::detail
     /**
      * @brief Handles memory queries.
      */
-    template <base::QueryTarget queryTarget, class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
+    template <class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
     class CoreSegmentQueryProcessorBase :
-        public base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>
+        public base::CoreSegmentQueryProcessorBase<_CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>
     {
     protected:
 
-        using Base = base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>;
+        using Base = base::CoreSegmentQueryProcessorBase<_CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h
index a107d6155..faa3fe544 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h
@@ -6,13 +6,13 @@
 namespace armarx::armem::server::query_proc::wm::detail
 {
 
-    template <base::QueryTarget queryTarget, class _EntityT, class _ResultEntityT>
+    template <class _EntityT, class _ResultEntityT>
     class EntityQueryProcessorBase :
-        public base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>
+        public base::EntityQueryProcessorBase<_EntityT, _ResultEntityT>
     {
     protected:
 
-        using Base = base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>;
+        using Base = base::EntityQueryProcessorBase<_EntityT, _ResultEntityT>;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h
index 38d7a9ec4..b6ae97063 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h
@@ -6,13 +6,13 @@
 namespace armarx::armem::server::query_proc::wm::detail
 {
 
-    template <base::QueryTarget queryTarget, class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
+    template <class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
     class MemoryQueryProcessorBase :
-        public base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>
+        public base::MemoryQueryProcessorBase<_MemoryT, _ResultMemoryT, _ChildProcessorT>
     {
     protected:
 
-        using Base = base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>;
+        using Base = base::MemoryQueryProcessorBase<_MemoryT, _ResultMemoryT, _ChildProcessorT>;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h
index 759938b2b..75abb12ee 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h
@@ -6,13 +6,13 @@
 namespace armarx::armem::server::query_proc::wm::detail
 {
 
-    template <base::QueryTarget queryTarget, class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
+    template <class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
     class ProviderSegmentQueryProcessorBase :
-        public base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>
+        public base::ProviderSegmentQueryProcessorBase<_ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>
     {
     protected:
 
-        using Base = base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>;
+        using Base = base::ProviderSegmentQueryProcessorBase<_ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp
index 0a50a1c4f..138ee9525 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp
@@ -6,7 +6,7 @@
 namespace armarx::armem::server::query_proc::wm::detail
 {
 
-    HasDataMode::HasDataMode(armem::DataMode dataMode) : dataMode(dataMode)
+    HasDataMode::HasDataMode(armem::query::DataMode dataMode) : dataMode(dataMode)
     {
     }
 
@@ -16,20 +16,20 @@ namespace armarx::armem::server::query_proc::wm::detail
 namespace armarx::armem::server::query_proc::wm
 {
 
-    ProviderSegmentQueryProcessor::ProviderSegmentQueryProcessor(DataMode dataMode) :
-        detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>(dataMode),
+    ProviderSegmentQueryProcessor::ProviderSegmentQueryProcessor(armem::query::DataMode dataMode) :
+        detail::ProviderSegmentQueryProcessorBase<armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>(dataMode),
         HasDataMode(dataMode)
     {
     }
 
 
-    CoreSegmentQueryProcessor::CoreSegmentQueryProcessor(DataMode dataMode) :
+    CoreSegmentQueryProcessor::CoreSegmentQueryProcessor(armem::query::DataMode dataMode) :
         CoreSegmentQueryProcessorBase(dataMode), HasDataMode(dataMode)
     {
     }
 
 
-    MemoryQueryProcessor::MemoryQueryProcessor(DataMode dataMode) :
+    MemoryQueryProcessor::MemoryQueryProcessor(armem::query::DataMode dataMode) :
         MemoryQueryProcessorBase(dataMode), HasDataMode(dataMode)
     {
     }
@@ -39,13 +39,13 @@ namespace armarx::armem::server::query_proc::wm
 
 namespace armarx::armem::server::query_proc::wm_server
 {
-    ProviderSegmentQueryProcessor::ProviderSegmentQueryProcessor(DataMode dataMode) :
+    ProviderSegmentQueryProcessor::ProviderSegmentQueryProcessor(armem::query::DataMode dataMode) :
         ProviderSegmentQueryProcessorBase(dataMode), HasDataMode(dataMode)
     {
     }
 
 
-    CoreSegmentQueryProcessor::CoreSegmentQueryProcessor(DataMode dataMode) :
+    CoreSegmentQueryProcessor::CoreSegmentQueryProcessor(armem::query::DataMode dataMode) :
         CoreSegmentQueryProcessorBase(dataMode),
         HasDataMode(dataMode)
     {
@@ -64,7 +64,7 @@ namespace armarx::armem::server::query_proc::wm_server
     }
 
 
-    MemoryQueryProcessor::MemoryQueryProcessor(DataMode dataMode) :
+    MemoryQueryProcessor::MemoryQueryProcessor(armem::query::DataMode dataMode) :
         MemoryQueryProcessorBase(dataMode),
         HasDataMode(dataMode)
     {
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h
index 2d1ff3e35..27e88e828 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <RobotAPI/libraries/armem/core/DataMode.h>
+#include <RobotAPI/libraries/armem/core/query/DataMode.h>
 #include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
 #include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
 
@@ -9,11 +9,6 @@
 #include "detail/ProviderSegmentQueryProcessorBase.h"
 #include "detail/EntityQueryProcessorBase.h"
 
-
-namespace armarx::armem::server::query_proc::wm
-{
-    static const base::QueryTarget queryTarget = query::data::QueryTarget::WM;
-}
 namespace armarx::armem::server::query_proc::wm::detail
 {
 
@@ -21,12 +16,12 @@ namespace armarx::armem::server::query_proc::wm::detail
     {
     public:
 
-        HasDataMode(armem::DataMode dataMode);
+        HasDataMode(armem::query::DataMode dataMode);
 
 
     protected:
 
-        armem::DataMode dataMode;
+        armem::query::DataMode dataMode;
 
     };
 
@@ -34,18 +29,18 @@ namespace armarx::armem::server::query_proc::wm::detail
 
     template <class SourceEntityT>
     class EntityQueryProcessor :
-        public EntityQueryProcessorBase<queryTarget, SourceEntityT, armem::wm::Entity>,
+        public EntityQueryProcessorBase<SourceEntityT, armem::wm::Entity>,
         public HasDataMode
     {
     protected:
 
-        using Base = EntityQueryProcessorBase<queryTarget, SourceEntityT, armem::wm::Entity>;
+        using Base = EntityQueryProcessorBase<SourceEntityT, armem::wm::Entity>;
         using Entity = armem::wm::Entity;
 
 
     public:
 
-        EntityQueryProcessor(DataMode dataMode = DataMode::WithData) :
+        EntityQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData) :
             HasDataMode(dataMode)
         {}
 
@@ -55,7 +50,7 @@ namespace armarx::armem::server::query_proc::wm::detail
 
         void addResultSnapshot(armem::wm::Entity& result, const typename SourceEntityT::EntitySnapshotT& snapshot) const
         {
-            bool withData = (dataMode == DataMode::WithData);
+            bool withData = (dataMode == armem::query::DataMode::WithData);
             if (withData)
             {
                 result.addSnapshot(server::wm::EntitySnapshot{ snapshot });
@@ -82,38 +77,38 @@ namespace armarx::armem::server::query_proc::wm
     using EntityQueryProcessor = detail::EntityQueryProcessor<armem::wm::Entity>;
 
     class ProviderSegmentQueryProcessor :
-        public detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>,
+        public detail::ProviderSegmentQueryProcessorBase<armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>,
         public detail::HasDataMode
     {
     protected:
 
-        using Base = detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
+        using Base = detail::ProviderSegmentQueryProcessorBase<armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
         using ProviderSegment = armem::wm::ProviderSegment;
         using Entity = armem::wm::Entity;
 
 
     public:
 
-        ProviderSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
+        ProviderSegmentQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData);
 
         using Base::process;
     };
 
 
     class CoreSegmentQueryProcessor :
-        public detail::CoreSegmentQueryProcessorBase <queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>,
+        public detail::CoreSegmentQueryProcessorBase <armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>,
         public detail::HasDataMode
     {
     protected:
 
-        using Base = wm::detail::CoreSegmentQueryProcessorBase<queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
+        using Base = wm::detail::CoreSegmentQueryProcessorBase<armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
         using CoreSegment = armem::wm::CoreSegment;
         using ProviderSegment = armem::wm::ProviderSegment;
 
 
     public:
 
-        CoreSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
+        CoreSegmentQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData);
 
         using Base::process;
 
@@ -121,19 +116,19 @@ namespace armarx::armem::server::query_proc::wm
 
 
     class MemoryQueryProcessor :
-        public detail::MemoryQueryProcessorBase<queryTarget, armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
+        public detail::MemoryQueryProcessorBase<armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
         public detail::HasDataMode
     {
     protected:
 
-        using Base = detail::MemoryQueryProcessorBase<queryTarget, armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
+        using Base = detail::MemoryQueryProcessorBase<armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
         using Memory = armem::wm::Memory;
         using CoreSegment = armem::wm::CoreSegment;
 
 
     public:
 
-        MemoryQueryProcessor(DataMode dataMode = DataMode::WithData);
+        MemoryQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData);
 
         using Base::process;
 
@@ -149,36 +144,36 @@ namespace armarx::armem::server::query_proc::wm_server
 
 
     class ProviderSegmentQueryProcessor :
-        public wm::detail::ProviderSegmentQueryProcessorBase<wm::queryTarget, server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>,
+        public wm::detail::ProviderSegmentQueryProcessorBase<server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>,
         public wm::detail::HasDataMode
     {
     protected:
 
-        using Base = wm::detail::ProviderSegmentQueryProcessorBase<wm::queryTarget, server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
+        using Base = wm::detail::ProviderSegmentQueryProcessorBase<server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
         using ProviderSegment = server::wm::ProviderSegment;
         using Entity = server::wm::Entity;
 
     public:
 
-        ProviderSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
+        ProviderSegmentQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData);
 
     };
 
 
     class CoreSegmentQueryProcessor :
-        public wm::detail::CoreSegmentQueryProcessorBase <wm::queryTarget, server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>,
+        public wm::detail::CoreSegmentQueryProcessorBase <server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>,
         public wm::detail::HasDataMode
     {
     protected:
 
-        using Base = wm::detail::CoreSegmentQueryProcessorBase<wm::queryTarget, server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
+        using Base = wm::detail::CoreSegmentQueryProcessorBase <server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
         using CoreSegment = server::wm::CoreSegment;
         using ProviderSegment = server::wm::ProviderSegment;
 
 
     public:
 
-        CoreSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
+        CoreSegmentQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData);
 
         using Base::process;
 
@@ -192,18 +187,18 @@ namespace armarx::armem::server::query_proc::wm_server
 
 
     class MemoryQueryProcessor :
-        public wm::detail::MemoryQueryProcessorBase<wm::queryTarget, server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
+        public wm::detail::MemoryQueryProcessorBase<server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
         public wm::detail::HasDataMode
     {
     protected:
 
-        using Base = wm::detail::MemoryQueryProcessorBase<wm::queryTarget, server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
+        using Base = wm::detail::MemoryQueryProcessorBase<server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
         using Memory = server::wm::Memory;
         using CoreSegment = server::wm::CoreSegment;
 
     public:
 
-        MemoryQueryProcessor(DataMode dataMode = DataMode::WithData);
+        MemoryQueryProcessor(armem::query::DataMode dataMode = armem::query::DataMode::WithData);
 
         using Base::process;
 
diff --git a/source/RobotAPI/libraries/armem/server/test/ArMemQueryTest.cpp b/source/RobotAPI/libraries/armem/server/test/ArMemQueryTest.cpp
index c778cbc4f..583dbb5fd 100644
--- a/source/RobotAPI/libraries/armem/server/test/ArMemQueryTest.cpp
+++ b/source/RobotAPI/libraries/armem/server/test/ArMemQueryTest.cpp
@@ -148,7 +148,7 @@ d_usec(long usec)
 
 BOOST_AUTO_TEST_CASE(test_entity_Single_existing)
 {
-    addResults(query::entity::Single({query::QueryTarget::WM, query::QueryTarget::LTM}, t_usec(3000)));
+    addResults(query::entity::Single(t_usec(3000)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -162,7 +162,7 @@ BOOST_AUTO_TEST_CASE(test_entity_Single_existing)
 
 BOOST_AUTO_TEST_CASE(test_entity_Single_non_existing)
 {
-    addResults(query::entity::Single({query::QueryTarget::WM, query::QueryTarget::LTM}, t_usec(3500)));
+    addResults(query::entity::Single(t_usec(3500)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -197,8 +197,7 @@ BOOST_AUTO_TEST_CASE(test_entity_All)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeRange_slice)
 {
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(1500), t_usec(3500)));
+    addResults(query::entity::TimeRange(t_usec(1500), t_usec(3500)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -219,8 +218,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeRange_slice)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeRange_exact)
 {
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(2000), t_usec(4000)));
+    addResults(query::entity::TimeRange(t_usec(2000), t_usec(4000)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -242,10 +240,8 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeRange_exact)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeRange_all)
 {
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(0), t_usec(10000)));
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(-1), t_usec(-1)));
+    addResults(query::entity::TimeRange(t_usec(0), t_usec(10000)));
+    addResults(query::entity::TimeRange(t_usec(-1), t_usec(-1)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -262,10 +258,8 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeRange_all)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeRange_empty)
 {
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(2400), t_usec(2600)));
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(6000), t_usec(1000)));
+    addResults(query::entity::TimeRange(t_usec(2400), t_usec(2600)));
+    addResults(query::entity::TimeRange(t_usec(6000), t_usec(1000)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -279,8 +273,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeRange_empty)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeRange_from_start)
 {
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(-1), t_usec(2500)));
+    addResults(query::entity::TimeRange(t_usec(-1), t_usec(2500)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -302,8 +295,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeRange_from_start)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeRange_to_end)
 {
-    addResults(query::entity::TimeRange({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                        t_usec(2500), t_usec(-1)));
+    addResults(query::entity::TimeRange(t_usec(2500), t_usec(-1)));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -328,8 +320,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeRange_to_end)
 BOOST_AUTO_TEST_CASE(test_entity_BeforeTime_1)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::BeforeTime({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3500), 1));
+    addResults(query::entity::BeforeTime(t_usec(3500), 1));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -344,8 +335,7 @@ BOOST_AUTO_TEST_CASE(test_entity_BeforeTime_1)
 BOOST_AUTO_TEST_CASE(test_entity_BeforeTime_2)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::BeforeTime({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3500), 2));
+    addResults(query::entity::BeforeTime(t_usec(3500), 2));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -371,8 +361,7 @@ BOOST_AUTO_TEST_CASE(test_entity_BeforeTime_2)
 BOOST_AUTO_TEST_CASE(test_entity_BeforeOrAtTime_before)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::BeforeOrAtTime({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                             t_usec(3500)));
+    addResults(query::entity::BeforeOrAtTime(t_usec(3500)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -387,8 +376,7 @@ BOOST_AUTO_TEST_CASE(test_entity_BeforeOrAtTime_before)
 BOOST_AUTO_TEST_CASE(test_entity_BeforeOrAtTime_at)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::BeforeOrAtTime({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                             t_usec(3000)));
+    addResults(query::entity::BeforeOrAtTime(t_usec(3000)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -403,8 +391,7 @@ BOOST_AUTO_TEST_CASE(test_entity_BeforeOrAtTime_at)
 BOOST_AUTO_TEST_CASE(test_entity_BeforeOrAtTime_lookup_past)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::BeforeOrAtTime({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                             t_usec(1)));
+    addResults(query::entity::BeforeOrAtTime(t_usec(1)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -424,8 +411,7 @@ BOOST_AUTO_TEST_CASE(test_entity_BeforeOrAtTime_lookup_past)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_no_limit)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3500), d_usec(-1)));
+    addResults(query::entity::TimeApprox(t_usec(3500), d_usec(-1)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -452,8 +438,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_no_limit)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_600)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3500), d_usec(600)));
+    addResults(query::entity::TimeApprox(t_usec(3500), d_usec(600)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -480,8 +465,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_600)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_too_small)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3500), d_usec(100)));
+    addResults(query::entity::TimeApprox(t_usec(3500), d_usec(100)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -500,8 +484,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_too_small)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_only_next)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3700), d_usec(400)));
+    addResults(query::entity::TimeApprox(t_usec(3700), d_usec(400)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -526,8 +509,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_only_next)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_only_previous)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3300), d_usec(400)));
+    addResults(query::entity::TimeApprox(t_usec(3300), d_usec(400)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -552,8 +534,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_limit_only_previous)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_perfect_match)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(3000), d_usec(-1)));
+    addResults(query::entity::TimeApprox(t_usec(3000), d_usec(-1)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -578,8 +559,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_perfect_match)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_past)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(1), d_usec(1)));
+    addResults(query::entity::TimeApprox(t_usec(1), d_usec(1)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -597,8 +577,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_past)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_future)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(10'000), d_usec(1)));
+    addResults(query::entity::TimeApprox(t_usec(10'000), d_usec(1)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -616,8 +595,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_future)
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_future_valid)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                         t_usec(10'000), d_usec(-1)));
+    addResults(query::entity::TimeApprox(t_usec(10'000), d_usec(-1)));
     BOOST_REQUIRE_EQUAL(results.size(), 2);
 
     for (const auto& result : results)
@@ -636,8 +614,7 @@ BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_future_valid)
 
 BOOST_AUTO_TEST_CASE(test_entity_TimeApprox_lookup_invalid_timestamp)
 {
-    BOOST_REQUIRE_THROW(addResults(query::entity::TimeApprox({query::QueryTarget::WM, query::QueryTarget::LTM},
-                                                             t_usec(-1), d_usec(1))), ::armarx::LocalException);
+    BOOST_REQUIRE_THROW(addResults(query::entity::TimeApprox(t_usec(-1), d_usec(1))), ::armarx::LocalException);
 }
 
 
@@ -677,7 +654,7 @@ BOOST_AUTO_TEST_CASE(test_negative_index_semantics)
 BOOST_AUTO_TEST_CASE(test_entity_IndexRange_all_default)
 {
     addResults(query::entity::IndexRange());
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM}, 0, -1));
+    addResults(query::entity::IndexRange(0, -1));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -697,10 +674,10 @@ BOOST_AUTO_TEST_CASE(test_entity_IndexRange_all_default)
 BOOST_AUTO_TEST_CASE(test_entity_IndexRange_slice)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  1,  3));  // => [1, 2, 3]
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  1, -2));  // 5 - 2 = 3
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM}, -4,  3));  // 5 - 4 = 1
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM}, -4, -2));
+    addResults(query::entity::IndexRange(1,  3));  // => [1, 2, 3]
+    addResults(query::entity::IndexRange(1, -2));  // 5 - 2 = 3
+    addResults(query::entity::IndexRange(-4,  3));  // 5 - 4 = 1
+    addResults(query::entity::IndexRange(-4, -2));
     BOOST_REQUIRE_GT(results.size(), 0);
 
     for (const armem::wm::Entity& result : results)
@@ -724,12 +701,12 @@ BOOST_AUTO_TEST_CASE(test_entity_IndexRange_slice)
 BOOST_AUTO_TEST_CASE(test_entity_IndexRange_empty_range)
 {
     BOOST_REQUIRE_EQUAL(entity.size(), 5);
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  1,  0));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  2,  1));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  5,  3));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  4, -3));   // 5-3 = 2
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  3, -3));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  1, -5));
+    addResults(query::entity::IndexRange(1,  0));
+    addResults(query::entity::IndexRange(2,  1));
+    addResults(query::entity::IndexRange(5,  3));
+    addResults(query::entity::IndexRange(4, -3));   // 5-3 = 2
+    addResults(query::entity::IndexRange(3, -3));
+    addResults(query::entity::IndexRange(1, -5));
 
     BOOST_REQUIRE_GT(results.size(), 0);
 
@@ -746,12 +723,12 @@ BOOST_AUTO_TEST_CASE(test_entity_IndexRange_empty_entity)
 {
     entity.clear();
     BOOST_REQUIRE_EQUAL(entity.size(), 0);
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  0,  0));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  0, 10));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM}, -10, -1));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  2,  5));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM},  3, -3));
-    addResults(query::entity::IndexRange({query::QueryTarget::WM, query::QueryTarget::LTM}, -1, 10));
+    addResults(query::entity::IndexRange(0,  0));
+    addResults(query::entity::IndexRange(0, 10));
+    addResults(query::entity::IndexRange(-10, -1));
+    addResults(query::entity::IndexRange(2,  5));
+    addResults(query::entity::IndexRange(3, -3));
+    addResults(query::entity::IndexRange(-1, 10));
 
     BOOST_REQUIRE_GT(results.size(), 0);
 
diff --git a/source/RobotAPI/libraries/armem/test/ArMemQueryBuilderTest.cpp b/source/RobotAPI/libraries/armem/test/ArMemQueryBuilderTest.cpp
index 1f92ff883..ebf288ab7 100644
--- a/source/RobotAPI/libraries/armem/test/ArMemQueryBuilderTest.cpp
+++ b/source/RobotAPI/libraries/armem/test/ArMemQueryBuilderTest.cpp
@@ -92,7 +92,7 @@ BOOST_AUTO_TEST_CASE(test_mixed)
 
     std::vector<std::string> entityNames = {"one", "two"};
 
-    armem::client::query::Builder qb(armem::DataMode::WithData);
+    armem::client::query::Builder qb(armem::query::DataMode::WithData);
     qb
     .coreSegments(withName("core"))
     .providerSegments(withName("provider"))
diff --git a/source/RobotAPI/libraries/armem/util/util.h b/source/RobotAPI/libraries/armem/util/util.h
index 2f4941e92..2f45b843a 100644
--- a/source/RobotAPI/libraries/armem/util/util.h
+++ b/source/RobotAPI/libraries/armem/util/util.h
@@ -28,7 +28,7 @@
 
 #include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
 #include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
-#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/AronGeneratedClass.h>
+#include <RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h>
 
 
 namespace armarx::armem
diff --git a/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp b/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp
index 3bc4b0b76..be54e55ab 100644
--- a/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp
+++ b/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp
@@ -93,7 +93,7 @@ namespace armarx::armem::gui
             try
             {
                 predictionEngines = reader.getAvailablePredictionEngines();
-                queryResult = reader.queryMemoryIDs({entityID}, DataMode::NoData);
+                queryResult = reader.queryMemoryIDs({entityID}, armem::query::DataMode::NoData);
             }
             catch (const Ice::LocalException& e)
             {
@@ -498,7 +498,7 @@ namespace armarx::armem::gui
                                [&reader, input, recursionDepth, this]()
                                {
                                    // Can't resolve MemoryLinks without data
-                                   return recursionDepth == 0 || input.dataMode == DataMode::NoData
+                                   return recursionDepth == 0 || input.dataMode == armem::query::DataMode::NoData
                                               ? reader.query(input.toIce())
                                               : reader.query(input.toIce(), mns, recursionDepth);
                                });
diff --git a/source/RobotAPI/libraries/armem_gui/commit_widget/CommitWidget.h b/source/RobotAPI/libraries/armem_gui/commit_widget/CommitWidget.h
index c82ba93f3..1795d4877 100644
--- a/source/RobotAPI/libraries/armem_gui/commit_widget/CommitWidget.h
+++ b/source/RobotAPI/libraries/armem_gui/commit_widget/CommitWidget.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <RobotAPI/libraries/armem/core/DataMode.h>
+#include <RobotAPI/libraries/armem/core/query/DataMode.h>
 #include <RobotAPI/libraries/armem/client/query/Builder.h>
 
 #include <QWidget>
diff --git a/source/RobotAPI/libraries/armem_gui/memory/GroupBox.cpp b/source/RobotAPI/libraries/armem_gui/memory/GroupBox.cpp
index 2c34cb5b3..8680fe165 100644
--- a/source/RobotAPI/libraries/armem_gui/memory/GroupBox.cpp
+++ b/source/RobotAPI/libraries/armem_gui/memory/GroupBox.cpp
@@ -102,10 +102,10 @@ namespace armarx::armem::gui::memory
     armem::client::QueryInput GroupBox::queryInput() const
     {
         armem::client::query::Builder queryBuilder(_queryWidget->dataMode());
-        queryBuilder.queryTargets(_snapshotSelectorWidget->queryTargets())
-        .coreSegments().all().queryTargets(_snapshotSelectorWidget->queryTargets())
-        .providerSegments().all().queryTargets(_snapshotSelectorWidget->queryTargets())
-        .entities().all().queryTargets(_snapshotSelectorWidget->queryTargets())
+        queryBuilder
+        .coreSegments().all()
+        .providerSegments().all()
+        .entities().all()
         .snapshots(_snapshotSelectorWidget->selector());
 
         return queryBuilder.buildQueryInput();
diff --git a/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.cpp b/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.cpp
index f5645fb2e..1719e6cac 100644
--- a/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.cpp
+++ b/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.cpp
@@ -149,11 +149,11 @@ namespace armarx::armem::gui
         }
     }
 
-    armem::DataMode QueryWidget::dataMode() const
+    armem::query::DataMode QueryWidget::dataMode() const
     {
         return _dataCheckBox->isChecked()
-               ? armem::DataMode::WithData
-               : armem::DataMode::NoData;
+               ? armem::query::DataMode::WithData
+               : armem::query::DataMode::NoData;
     }
 
     bool QueryWidget::dropRemovedMemories() const
diff --git a/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.h b/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.h
index 4988e5d67..bb285a9a4 100644
--- a/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.h
+++ b/source/RobotAPI/libraries/armem_gui/query_widgets/QueryWidget.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <RobotAPI/libraries/armem/core/DataMode.h>
+#include <RobotAPI/libraries/armem/core/query/DataMode.h>
 #include <RobotAPI/libraries/armem/client/query/Builder.h>
 
 #include "SnapshotSelectorWidget.h"
@@ -22,7 +22,7 @@ namespace armarx::armem::gui
 
         QueryWidget();
 
-        armem::DataMode dataMode() const;
+        armem::query::DataMode dataMode() const;
 
         bool dropRemovedMemories() const;
         bool dropDisabledMemories() const;
diff --git a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.cpp b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.cpp
index 8a9ff01c6..c6977d062 100644
--- a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.cpp
+++ b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.cpp
@@ -21,9 +21,9 @@
 namespace armarx::armem::gui
 {
 
-    client::query::SnapshotSelector SnapshotForm::makeEntitySelector(const armem::query::data::QueryTargets& targets)
+    client::query::SnapshotSelector SnapshotForm::makeEntitySelector()
     {
-        client::query::SnapshotSelector s(targets);
+        client::query::SnapshotSelector s;
         fillEntitySelector(s);
         return s;
     }
diff --git a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.h b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.h
index f2f9ba194..1e673a73e 100644
--- a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.h
+++ b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotForm.h
@@ -19,7 +19,7 @@ namespace armarx::armem::gui
         Q_OBJECT
 
     public:
-        virtual client::query::SnapshotSelector makeEntitySelector(const armem::query::data::QueryTargets& targets);
+        virtual client::query::SnapshotSelector makeEntitySelector();
 
 
     signals:
diff --git a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.cpp b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.cpp
index 1d8c4ecad..f38c186b6 100644
--- a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.cpp
+++ b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.cpp
@@ -13,29 +13,7 @@ namespace armarx::armem::gui
 {
     client::query::SnapshotSelector SnapshotSelectorWidget::selector()
     {
-        return _queryForms.at(_queryComboBox->currentText())->makeEntitySelector(queryTargets());
-    }
-
-    query::data::QueryTargets SnapshotSelectorWidget::queryTargets() const
-    {
-        query::data::QueryTargets targets;
-        if (_WMQueryTargetCheckBox->isChecked())
-        {
-            targets.push_back(query::data::QueryTarget::WM);
-        }
-        if (_LTMQueryTargetCheckBox->isChecked())
-        {
-            targets.push_back(query::data::QueryTarget::LTM);
-        }
-        return targets;
-    }
-
-    void SnapshotSelectorWidget::queryTargetStateChanged()
-    {
-        if (!_WMQueryTargetCheckBox->isChecked() && !_LTMQueryTargetCheckBox->isChecked())
-        {
-            _WMQueryTargetCheckBox->setChecked(true);
-        }
+        return _queryForms.at(_queryComboBox->currentText())->makeEntitySelector();
     }
 
     SnapshotSelectorWidget::SnapshotSelectorWidget()
@@ -58,16 +36,6 @@ namespace armarx::armem::gui
 
             // query type select box
             auto queryTargetLayout = new QHBoxLayout();
-            _WMQueryTargetCheckBox = new QCheckBox("WM");
-            _LTMQueryTargetCheckBox = new QCheckBox("LTM");
-
-            connect(_WMQueryTargetCheckBox, &QCheckBox::stateChanged, this, &This::queryTargetStateChanged);
-            connect(_LTMQueryTargetCheckBox, &QCheckBox::stateChanged, this, &This::queryTargetStateChanged);
-
-            queryTargetLayout->addWidget(_WMQueryTargetCheckBox);
-            queryTargetLayout->addWidget(_LTMQueryTargetCheckBox);
-
-            _WMQueryTargetCheckBox->setChecked(true);
 
             typeLayout->addLayout(queryTargetLayout);
             _pageLayout->addLayout(typeLayout);
diff --git a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.h b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.h
index d57cf80fd..23833f71e 100644
--- a/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.h
+++ b/source/RobotAPI/libraries/armem_gui/query_widgets/SnapshotSelectorWidget.h
@@ -4,7 +4,7 @@
 
 #include <QWidget>
 
-#include <RobotAPI/libraries/armem/core/DataMode.h>
+#include <RobotAPI/libraries/armem/core/query/DataMode.h>
 #include <RobotAPI/libraries/armem/client/query/Builder.h>
 
 #include "SnapshotForm.h"
@@ -35,9 +35,8 @@ namespace armarx::armem::gui
         SnapshotSelectorWidget();
 
 
-        armem::DataMode dataMode() const;
+        armem::query::DataMode dataMode() const;
         client::query::SnapshotSelector selector();
-        query::data::QueryTargets queryTargets() const;
 
 
     public slots:
@@ -51,7 +50,6 @@ namespace armarx::armem::gui
 
         void hideAllForms();
         void showSelectedFormForQuery(QString selected);
-        void queryTargetStateChanged();
 
     signals:
         void queryOutdated();
@@ -65,8 +63,6 @@ namespace armarx::armem::gui
     public:
         QVBoxLayout* _pageLayout;
         QComboBox* _queryComboBox;
-        QCheckBox* _WMQueryTargetCheckBox;
-        QCheckBox* _LTMQueryTargetCheckBox;
         /// The forms for the different query types. Hidden when not selected.
         std::map<QString, SnapshotForm*> _queryForms;
 
diff --git a/source/RobotAPI/libraries/aron/codegeneration/CMakeLists.txt b/source/RobotAPI/libraries/aron/codegeneration/CMakeLists.txt
index 208f3660b..c3a800811 100644
--- a/source/RobotAPI/libraries/aron/codegeneration/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/codegeneration/CMakeLists.txt
@@ -66,8 +66,6 @@ set(LIB_HEADERS
     codegenerator/codewriter/CodeWriter.h
     codegenerator/codewriter/Factory.h
 
-    codegenerator/codewriter/cpp/AronGeneratedClass.h
-
     codegenerator/codewriter/cpp/Writer.h
     codegenerator/codewriter/cpp/generator/Generator.h
     codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h
diff --git a/source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/Writer.cpp b/source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/Writer.cpp
index bd0bc005c..72a657218 100644
--- a/source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/Writer.cpp
+++ b/source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/Writer.cpp
@@ -332,7 +332,7 @@ namespace armarx::aron::codegenerator::cpp
         // add aron includes
         c->addInclude("<RobotAPI/libraries/aron/core/aron_conversions.h>");
         c->addInclude("<RobotAPI/libraries/aron/core/rw.h>");
-        c->addInclude("<RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/AronGeneratedClass.h>");
+        c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h>");
 
         // ctor
         c->addCtor(gen.toCtor(c->getName()));
diff --git a/source/RobotAPI/libraries/aron/common/test/MyCustomType.h b/source/RobotAPI/libraries/aron/common/test/MyCustomType.h
index 85c6a29f8..f266c7a37 100644
--- a/source/RobotAPI/libraries/aron/common/test/MyCustomType.h
+++ b/source/RobotAPI/libraries/aron/common/test/MyCustomType.h
@@ -24,7 +24,7 @@
 #include <string>
 #include <vector>
 
-#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/AronGeneratedClass.h>
+#include <RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h>
 
 namespace my
 {
diff --git a/source/RobotAPI/libraries/aron/core/CMakeLists.txt b/source/RobotAPI/libraries/aron/core/CMakeLists.txt
index 8701ee053..e17910e7f 100644
--- a/source/RobotAPI/libraries/aron/core/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/core/CMakeLists.txt
@@ -106,6 +106,8 @@ set(LIB_HEADERS
     Exception.h
     Path.h
 
+    codegeneration/cpp/AronGeneratedClass.h
+
     aron_conversions.h
     rw.h
 
diff --git a/source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/AronGeneratedClass.h b/source/RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h
similarity index 100%
rename from source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/AronGeneratedClass.h
rename to source/RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h
-- 
GitLab