Add QueryBuilder (WIP)

source/RobotAPI/libraries/armem/CMakeLists.txt

@@ -44,6 +44,8 @@ set(LIB_FILES
     client/MemoryReader.cpp
     client/MemoryClientComponentPlugin.cpp
 
+    client/query/QueryBuilder.cpp
+
     component/IceMemory.cpp
     component/MemoryComponentPlugin.cpp
     component/MemoryRemoteGui.cpp
@@ -87,6 +89,9 @@ set(LIB_HEADERS
     client/MemoryReader.h
     client/MemoryClientComponentPlugin.h
 
+    client/query/detail.h
+    client/query/QueryBuilder.h
+
     component/IceMemory.h
     component/MemoryComponentPlugin.h
     component/MemoryRemoteGui.h

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

+#include "MemoryQuery.h"
+
+
+namespace armarx::armem::client
+{
+
+
+}

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

+#pragma once
+
+#include <vector>
+
+#include <RobotAPI/interface/armem/query.h>
+
+#include "../../core/Time.h"
+#include "../../core/ice_conversions.h"
+
+#include "detail.h"
+
+
+namespace armarx::armem::client
+{
+
+    class SnapshotsSelector :
+            public detail::ChildSelectorOps<SnapshotsSelector, query::EntityQueryPtr>
+    {
+    public:
+
+
+        std::vector<query::EntityQueryPtr> build() const
+        {
+            return _queries;
+        }
+
+
+        SnapshotsSelector& all(bool withData = true)
+        {
+            auto q = _addQuery<query::entity::All>(withData);
+            q.withData = withData;
+            return *this;
+        }
+        SnapshotsSelector& latest(bool withData = true);
+
+        SnapshotsSelector& atTime(Time timestamp, bool withData = true)
+        {
+            auto q = _addQuery<query::entity::Single>(withData);
+            toIce(q.timestamp, timestamp);
+            return *this;
+        }
+
+        SnapshotsSelector& timeRange(Time min, Time max, bool withData = true)
+        {
+            auto q = _addQuery<query::entity::TimeRange>(withData);
+            toIce(q.minTimestamp, min);
+            toIce(q.maxTimestamp, max);
+            return *this;
+        }
+
+        SnapshotsSelector& indexRange(long first, long last, bool withData = true)
+        {
+            auto q = _addQuery<query::entity::IndexRange>(withData);
+            q.first = first;
+            q.last = last;
+            return *this;
+        }
+
+
+    protected:
+
+        template <class DerivedQueryT>
+        DerivedQueryT& _addQuery(bool withData)
+        {
+            DerivedQueryT& query = ChildSelectorOps::_addQuery<DerivedQueryT>();
+            query.withData = withData;
+            return query;
+        }
+
+    };
+
+
+    class EntitiesSelector :
+            public detail::InnerSelectorOps<EntitiesSelector, query::ProviderSegmentQueryPtr, SnapshotsSelector>
+    {
+    public:
+
+        SnapshotsSelector& snapshots()
+        {
+            return _addChild();
+        }
+
+
+        EntitiesSelector& all()
+        {
+            auto q = _addQuery<query::provider::All>();
+            return *this;
+        }
+
+        EntitiesSelector& withName(const std::string& name);
+        EntitiesSelector& withNames(const std::vector<std::string>& names);
+
+        EntitiesSelector& withNameMatching(const std::string& regex);
+
+
+    protected:
+
+        void _setChildQueries(QueryT& query, const std::vector<ChildT::QueryT>& childQueries) const override;
+    };
+
+    void EntitiesSelector::_setChildQueries(ChildSelectorOps::QueryT& query, const std::vector<ChildT::QueryT>& childQueries) const
+    {
+        query->entityQueries = childQueries;
+    }
+
+
+
+    class ProviderSegmentSelector :
+            public detail::InnerSelectorOps<ProviderSegmentSelector, query::CoreSegmentQueryPtr, EntitiesSelector>
+    {
+    public:
+
+        EntitiesSelector& entities()
+        {
+            return _addChild();
+        }
+
+        ProviderSegmentSelector& all()
+        {
+            auto q = _addQuery<query::core::All>();
+            return *this;
+        }
+
+        ProviderSegmentSelector& withName(const std::string& name);
+        ProviderSegmentSelector& withNames(const std::vector<std::string>& names);
+
+        ProviderSegmentSelector& withNameMatching(const std::string& regex);
+
+    protected:
+
+        void _setChildQueries(QueryT& query, const std::vector<ChildT::QueryT>& childQueries) const override;
+    };
+
+    void ProviderSegmentSelector::_setChildQueries(ChildSelectorOps::QueryT& query, const std::vector<ChildT::QueryT>& childQueries) const
+    {
+        query->providerSegmentQueries = childQueries;
+    }
+
+
+
+    class CoreSegmentSelector :
+            public detail::InnerSelectorOps<CoreSegmentSelector, query::MemoryQueryPtr, ProviderSegmentSelector>
+    {
+    public:
+
+        ProviderSegmentSelector& providerSegments()
+        {
+            return _addChild();
+        }
+
+        CoreSegmentSelector& all()
+        {
+            auto q = _addQuery<query::memory::All>();
+            return *this;
+        }
+
+        CoreSegmentSelector& withName(const std::string& name);
+        CoreSegmentSelector& withNames(const std::vector<std::string>& names);
+
+        CoreSegmentSelector& withNameMatching(const std::string& regex);
+
+
+    protected:
+
+        void _setChildQueries(QueryT& query, const std::vector<ChildT::QueryT>& childQueries) const override;
+    };
+
+    void CoreSegmentSelector::_setChildQueries(query::MemoryQueryPtr& query, const std::vector<ChildT::QueryT>& childQueries) const
+    {
+        query->coreSegmentQueries = childQueries;
+    }
+
+
+    // ToDo: Make a memory selector (but this level is not in ice, yet)
+    class QueryBuilder :
+            public detail::ParentSelectorOps<QueryBuilder, CoreSegmentSelector>
+    {
+    public:
+
+        std::vector<query::MemoryQueryPtr> finalize() const
+        {
+            std::vector<query::MemoryQueryPtr> childQueries;
+            for (const CoreSegmentSelector& child : _children)
+            {
+                for (const query::MemoryQueryPtr& query : child.build())
+                {
+                    childQueries.push_back(query);
+                }
+            }
+            return childQueries;
+        }
+
+
+        CoreSegmentSelector& coreSegments()
+        {
+            return _addChild();
+        }
+
+    };
+
+}

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

+#pragma once
+
+#include <vector>
+
+#include <Ice/Handle.h>
+
+
+namespace armarx::armem::client::detail
+{
+
+    template <class _DerivedT, class _QueryT>
+    class ChildSelectorOps
+    {
+    public:
+        using DerivedT = _DerivedT;
+        using QueryT = _QueryT;
+
+
+    protected:
+
+        template <class DerivedQueryT>
+        DerivedQueryT& _addQuery()
+        {
+            IceInternal::Handle<DerivedQueryT> query(new DerivedQueryT);
+            _queries.push_back(query);
+            return *query;
+        }
+
+        std::vector<QueryT> _queries;
+
+    };
+
+    template <class _DerivedT, class _ChildT>
+    class ParentSelectorOps
+    {
+    public:
+        using DerivedT = _DerivedT;
+        using ChildT = _ChildT;
+
+
+    protected:
+
+        ChildT& _addChild()
+        {
+            return _children.emplace_back();
+        }
+
+        std::vector<ChildT> _children;
+
+    };
+
+
+    template <class DerivedT, class QueryT, class ChildT>
+    class InnerSelectorOps :
+            public ParentSelectorOps<DerivedT, ChildT>,
+            public ChildSelectorOps<DerivedT, QueryT>
+    {
+    public:
+
+        virtual ~InnerSelectorOps()
+        {}
+
+
+        virtual std::vector<QueryT> build() const
+        {
+            std::vector<typename ChildT::QueryT> childQueries;
+            for (const auto& child : _children)
+            {
+                for (const auto& query : child.build())
+                {
+                    childQueries.push_back(query);
+                }
+            }
+
+            std::vector<QueryT> queries = this->_queries;
+            for (auto& query : queries)
+            {
+                this->_setChildQueries(query, childQueries);
+            }
+            return queries;
+        }
+
+
+    protected:
+
+        virtual void _setChildQueries(QueryT& query, const std::vector<typename ChildT::QueryT>& childQueries) const = 0;
+
+        ChildT& _addChild()
+        {
+            return _children.emplace_back();
+        }
+
+        std::vector<ChildT> _children;
+
+    };
+
+}