User querybase

1 files changed, 177 insertions, 115 deletions

diff --git a/common/query.h b/common/query.h
index c9d52b7..b858610 100644
--- a/common/query.h
+++ b/common/query.h
@@ -73,6 +73,11 @@ public:
         return mBaseFilterStage.propertyFilter;
     }
 
+    Filter getFilter() const
+    {
+        return mBaseFilterStage;
+    }
+
     QByteArrayList ids() const
     {
         return mBaseFilterStage.ids;
@@ -103,9 +108,143 @@ public:
         return mType;
     }
 
+    void setSortProperty(const QByteArray &property)
+    {
+        mSortPorperty = property;
+    }
+
+    QByteArray sortProperty() const
+    {
+        return mSortPorperty;
+    }
+
+    class FilterStage {
+    public:
+        virtual ~FilterStage(){};
+    };
+
+    QList<QSharedPointer<FilterStage>> getFilterStages()
+    {
+        return mFilterStages;
+    }
+
+    class Reduce : public FilterStage {
+    public:
+
+        class Selector {
+        public:
+            enum Comparator {
+                Min, //get the minimum value
+                Max, //get the maximum value
+                First //Get the first result we get
+            };
+
+            template <typename SelectionProperty>
+            static Selector max()
+            {
+                return Selector(SelectionProperty::name, Max);
+            }
+
+            Selector(const QByteArray &p, Comparator c)
+                : property(p),
+                comparator(c)
+            {
+            }
+
+            QByteArray property;
+            Comparator comparator;
+        };
+
+        class Aggregator {
+        public:
+            enum Operation {
+                Count,
+                Collect
+            };
+
+            Aggregator(const QByteArray &p, Operation o, const QByteArray &c = QByteArray())
+                : resultProperty(p),
+                operation(o),
+                propertyToCollect(c)
+            {
+            }
+
+            QByteArray resultProperty;
+            Operation operation;
+            QByteArray propertyToCollect;
+        };
+
+        Reduce(const QByteArray &p, const Selector &s)
+            : property(p),
+            selector(s)
+        {
+        }
+
+        Reduce &count(const QByteArray &propertyName = "count")
+        {
+            aggregators << Aggregator(propertyName, Aggregator::Count);
+            return *this;
+        }
+
+        template <typename T>
+        Reduce &collect(const QByteArray &propertyName)
+        {
+            aggregators << Aggregator(propertyName, Aggregator::Collect, T::name);
+            return *this;
+        }
+
+        //Reduce on property
+        QByteArray property;
+        Selector selector;
+        QList<Aggregator> aggregators;
+
+        //TODO add aggregate functions like:
+        //.count()
+        //.collect<Mail::sender>();
+        //...
+        //
+        //Potentially pass-in an identifier under which the result will be available in the result set.
+    };
+
+    template <typename T>
+    Reduce &reduce(const Reduce::Selector &s)
+    {
+        auto reduction = QSharedPointer<Reduce>::create(T::name, s);
+        mFilterStages << reduction;
+        return *reduction;
+    }
+
+    /**
+    * "Bloom" on a property.
+    *
+    * For every encountered value of a property,
+    * a result set is generated containing all entries with the same value.
+    *
+    * Example:
+    * For an input set of one mail; return all emails with the same threadId.
+    */
+    class Bloom : public FilterStage {
+    public:
+        //Property to bloom on
+        QByteArray property;
+        Bloom(const QByteArray &p)
+            : property(p)
+        {
+        }
+    };
+
+    template <typename T>
+    void bloom()
+    {
+        auto bloom = QSharedPointer<Bloom>::create(T::name);
+        mFilterStages << bloom;
+    }
+
 private:
     Filter mBaseFilterStage;
+    QList<QSharedPointer<FilterStage>> mFilterStages;
     QByteArray mType;
+    QByteArray mSortPorperty;
 };
 
 /**
@@ -140,7 +279,7 @@ public:
     template <typename T>
     Query &sort()
     {
-        sortProperty = T::name;
+        setSortProperty(T::name);
         return *this;
     }
 
@@ -212,7 +351,6 @@ public:
 
     QByteArrayList requestedProperties;
     QByteArray parentProperty;
-    QByteArray sortProperty;
     int limit;
 
     void setFlags(Flags flags)
@@ -230,16 +368,6 @@ public:
         return mFlags & SynchronousQuery;
     }
 
-    class FilterStage {
-    public:
-        virtual ~FilterStage(){};
-    };
-
-    QList<QSharedPointer<FilterStage>> getFilterStages()
-    {
-        return mFilterStages;
-    }
-
     Filter getResourceFilter() const
     {
         return mResourceFilter;
@@ -276,122 +404,56 @@ public:
         return resourceFilter(T::name, value);
     }
 
-    class Reduce : public FilterStage {
-    public:
-
-        class Selector {
-        public:
-            enum Comparator {
-                Min, //get the minimum value
-                Max, //get the maximum value
-                First //Get the first result we get
-            };
-
-            template <typename SelectionProperty>
-            static Selector max()
-            {
-                return Selector(SelectionProperty::name, Max);
-            }
-
-            Selector(const QByteArray &p, Comparator c)
-                : property(p),
-                comparator(c)
-            {
-            }
-
-            QByteArray property;
-            Comparator comparator;
-        };
-
-        class Aggregator {
-        public:
-            enum Operation {
-                Count,
-                Collect
-            };
-
-            Aggregator(const QByteArray &p, Operation o, const QByteArray &c = QByteArray())
-                : resultProperty(p),
-                operation(o),
-                propertyToCollect(c)
-            {
-            }
-
-            QByteArray resultProperty;
-            Operation operation;
-            QByteArray propertyToCollect;
-        };
-
-        Reduce(const QByteArray &p, const Selector &s)
-            : property(p),
-            selector(s)
-        {
-        }
-
-        Reduce &count(const QByteArray &propertyName = "count")
-        {
-            aggregators << Aggregator(propertyName, Aggregator::Count);
-            return *this;
-        }
+private:
+    Flags mFlags;
+    Filter mResourceFilter;
+};
 
-        template <typename T>
-        Reduce &collect(const QByteArray &propertyName)
-        {
-            aggregators << Aggregator(propertyName, Aggregator::Collect, T::name);
-            return *this;
-        }
+class SyncScope : public QueryBase {
+public:
+    template<typename T>
+    SyncScope()
+    {
+        setType(ApplicationDomain::getTypeName<T>());
+    }
 
-        //Reduce on property
-        QByteArray property;
-        Selector selector;
-        QList<Aggregator> aggregators;
+    Query::Filter getResourceFilter() const
+    {
+        return mResourceFilter;
+    }
 
-        //TODO add aggregate functions like:
-        //.count()
-        //.collect<Mail::sender>();
-        //...
-        //
-        //Potentially pass-in an identifier under which the result will be available in the result set.
-    };
+    SyncScope &resourceFilter(const QByteArray &id)
+    {
+        mResourceFilter.ids << id;
+        return *this;
+    }
 
     template <typename T>
-    Reduce &reduce(const Reduce::Selector &s)
+    SyncScope &filter(const Query::Comparator &comparator)
     {
-        auto reduction = QSharedPointer<Reduce>::create(T::name, s);
-        mFilterStages << reduction;
-        return *reduction;
+        return filter(T::name, comparator);
     }
 
-    /**
-    * "Bloom" on a property.
-    *
-    * For every encountered value of a property,
-    * a result set is generated containing all entries with the same value.
-    *
-    * Example:
-    * For an input set of one mail; return all emails with the same threadId.
-    */
-    class Bloom : public FilterStage {
-    public:
-        //Property to bloom on
-        QByteArray property;
-        Bloom(const QByteArray &p)
-            : property(p)
-        {
-        }
-    };
+    SyncScope &filter(const QByteArray &id)
+    {
+        QueryBase::filter(id);
+        return *this;
+    }
 
-    template <typename T>
-    void bloom()
+    SyncScope &filter(const QByteArrayList &ids)
     {
-        auto bloom = QSharedPointer<Bloom>::create(T::name);
-        mFilterStages << bloom;
+        QueryBase::filter(ids);
+        return *this;
+    }
+
+    SyncScope &filter(const QByteArray &property, const Query::Comparator &comparator)
+    {
+        QueryBase::filter(property, comparator);
+        return *this;
     }
 
 private:
-    Flags mFlags;
-    Filter mResourceFilter;
-    QList<QSharedPointer<FilterStage>> mFilterStages;
+    Query::Filter mResourceFilter;
 };
 
 }