Separated the base filter from the rest of the query.

1 files changed, 113 insertions, 79 deletions

diff --git a/common/query.h b/common/query.h
index 3ab5acf..c0ea0f3 100644
--- a/common/query.h
+++ b/common/query.h
@@ -27,21 +27,9 @@
 
 namespace Sink {
 
-/**
- * A query that matches a set of entities.
- */
-class SINK_EXPORT Query
+class SINK_EXPORT QueryBase
 {
 public:
-    enum Flag
-    {
-        /** Leave the query running and continuously update the result set. */
-        LiveQuery,
-        /** Run the query synchronously. */
-        SynchronousQuery
-    };
-    Q_DECLARE_FLAGS(Flags, Flag)
-
     struct Comparator {
         enum Comparators {
             Invalid,
@@ -59,137 +47,184 @@ public:
         Comparators comparator;
     };
 
-    template <typename T>
-    Query &request()
+    class Filter {
+    public:
+        QByteArrayList ids;
+        QHash<QByteArray, Comparator> propertyFilter;
+    };
+
+    Comparator getFilter(const QByteArray &property) const
     {
-        requestedProperties << T::name;
-        return *this;
+        return mBaseFilterStage.propertyFilter.value(property);
     }
 
-    template <typename T>
-    Query &requestTree()
+    bool hasFilter(const QByteArray &property) const
     {
-        parentProperty = T::name;
-        return *this;
+        return mBaseFilterStage.propertyFilter.contains(property);
     }
 
-    template <typename T>
-    Query &sort()
+    void setBaseFilters(const QHash<QByteArray, Comparator> &filter)
     {
-        sortProperty = T::name;
-        return *this;
+        mBaseFilterStage.propertyFilter = filter;
     }
 
-    Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false)
+    QHash<QByteArray, Comparator> getBaseFilters() const
     {
-        filter(value.identifier());
-        resourceFilter(value.resourceInstanceIdentifier());
+        return mBaseFilterStage.propertyFilter;
     }
 
-    Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false)
+    QByteArrayList ids() const
     {
+        return mBaseFilterStage.ids;
     }
 
-    QByteArrayList requestedProperties;
-    QByteArray parentProperty;
-    QByteArray sortProperty;
-    QByteArray type;
-    int limit;
-    bool liveQuery;
-    bool synchronousQuery;
-
-    class FilterStage {
-    public:
-        virtual ~FilterStage(){};
-    };
+    void filter(const QByteArray &id)
+    {
+        mBaseFilterStage.ids << id;
+    }
 
-    QList<QSharedPointer<FilterStage>> getFilterStages()
+    void filter(const QByteArrayList &ids)
     {
-        return mFilterStages;
+        mBaseFilterStage.ids << ids;
     }
 
-    /*
-    * Filters
-    */
-    class Filter : public FilterStage {
-    public:
-        QByteArrayList ids;
-        QHash<QByteArray, Comparator> propertyFilter;
-    };
+    void filter(const QByteArray &property, const QueryBase::Comparator &comparator)
+    {
+        mBaseFilterStage.propertyFilter.insert(property, comparator);
+    }
 
-    template <typename T>
-    Query &filter(const QVariant &value)
+    void setType(const QByteArray &type)
     {
-        return filter(T::name, value);
+        mType = type;
     }
 
-    template <typename T>
-    Query &containsFilter(const QVariant &value)
+    QByteArray type() const
     {
-        return filter(T::name, Comparator(value, Comparator::Contains));
+        return mType;
     }
 
+private:
+    Filter mBaseFilterStage;
+    QByteArray mType;
+};
+
+/**
+ * A query that matches a set of entities.
+ */
+class SINK_EXPORT Query : public QueryBase
+{
+public:
+    enum Flag
+    {
+        /** Leave the query running and continuously update the result set. */
+        LiveQuery,
+        /** Run the query synchronously. */
+        SynchronousQuery
+    };
+    Q_DECLARE_FLAGS(Flags, Flag)
+
     template <typename T>
-    Query &filter(const Comparator &comparator)
+    Query &request()
     {
-        return filter(T::name, comparator);
+        requestedProperties << T::name;
+        return *this;
     }
 
-    Query &filter(const QByteArray &id)
+    template <typename T>
+    Query &requestTree()
     {
-        mBaseFilterStage.ids << id;
+        parentProperty = T::name;
         return *this;
     }
 
-    Query &filter(const QByteArrayList &ids)
+    template <typename T>
+    Query &sort()
     {
-        mBaseFilterStage.ids << ids;
+        sortProperty = T::name;
         return *this;
     }
 
-    Query &filter(const QByteArray &property, const Comparator &comparator)
+    template <typename T>
+    Query &filter(const QVariant &value)
     {
-        mBaseFilterStage.propertyFilter.insert(property, comparator);
+        filter(T::name, value);
         return *this;
     }
 
-    Comparator getFilter(const QByteArray &property) const
+    template <typename T>
+    Query &containsFilter(const QVariant &value)
     {
-        return mBaseFilterStage.propertyFilter.value(property);
+        QueryBase::filter(T::name, QueryBase::Comparator(value, QueryBase::Comparator::Contains));
+        return *this;
     }
 
-    bool hasFilter(const QByteArray &property) const
+    template <typename T>
+    Query &filter(const QueryBase::Comparator &comparator)
     {
-        return mBaseFilterStage.propertyFilter.contains(property);
+        QueryBase::filter(T::name, comparator);
+        return *this;
     }
 
-    void setBaseFilters(const QHash<QByteArray, Comparator> &filter)
+    Query &filter(const QByteArray &id)
     {
-        mBaseFilterStage.propertyFilter = filter;
+        QueryBase::filter(id);
+        return *this;
     }
 
-    QHash<QByteArray, Comparator> getBaseFilters() const
+    Query &filter(const QByteArrayList &ids)
     {
-        return mBaseFilterStage.propertyFilter;
+        QueryBase::filter(ids);
+        return *this;
     }
 
-    QByteArrayList ids() const
+    Query &filter(const QByteArray &property, const QueryBase::Comparator &comparator)
     {
-        return mBaseFilterStage.ids;
+        QueryBase::filter(property, comparator);
+        return *this;
     }
 
     template <typename T>
     Query &filter(const ApplicationDomain::Entity &value)
     {
-        return filter(T::name, QVariant::fromValue(value.identifier()));
+        filter(T::name, QVariant::fromValue(value.identifier()));
+        return *this;
     }
 
     template <typename T>
     Query &filter(const Query &query)
     {
         auto q = query;
-        q.type = ApplicationDomain::getTypeName<typename T::ReferenceType>();
-        return filter(T::name, QVariant::fromValue(q));
+        q.setType(ApplicationDomain::getTypeName<typename T::ReferenceType>());
+        filter(T::name, QVariant::fromValue(q));
+        return *this;
+    }
+
+
+    Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false)
+    {
+        filter(value.identifier());
+        resourceFilter(value.resourceInstanceIdentifier());
+    }
+
+    Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false)
+    {
+    }
+
+    QByteArrayList requestedProperties;
+    QByteArray parentProperty;
+    QByteArray sortProperty;
+    int limit;
+    bool liveQuery;
+    bool synchronousQuery;
+
+    class FilterStage {
+    public:
+        virtual ~FilterStage(){};
+    };
+
+    QList<QSharedPointer<FilterStage>> getFilterStages()
+    {
+        return mFilterStages;
     }
 
     Filter getResourceFilter() const
@@ -342,7 +377,6 @@ public:
 
 private:
     Filter mResourceFilter;
-    Filter mBaseFilterStage;
     QList<QSharedPointer<FilterStage>> mFilterStages;
 };