Query serialization.

3 files changed, 129 insertions, 8 deletions

diff --git a/common/query.cpp b/common/query.cpp
index a43ef6c..67b74cc 100644
--- a/common/query.cpp
+++ b/common/query.cpp
@@ -19,6 +19,9 @@
  */
 #include "query.h"
 
+#include <QList>
+#include <QDataStream>
+
 using namespace Sink;
 
 QDebug operator<<(QDebug dbg, const Sink::Query::Comparator &c)
@@ -34,19 +37,85 @@ QDebug operator<<(QDebug dbg, const Sink::Query::Comparator &c)
     return dbg.space();
 }
 
-Query::Comparator::Comparator() : comparator(Invalid)
+QDataStream & operator<< (QDataStream &stream, const Sink::QueryBase::Comparator &comparator)
+{
+    stream << comparator.comparator;
+    stream << comparator.value;
+    return stream;
+}
+
+QDataStream & operator>> (QDataStream &stream, Sink::QueryBase::Comparator &comparator)
+{
+    int c;
+    stream >> c;
+    comparator.comparator = static_cast<Sink::QueryBase::Comparator::Comparators>(c);
+    stream >> comparator.value;
+    return stream;
+}
+
+QDataStream & operator<< (QDataStream &stream, const Sink::QueryBase::Filter &filter)
+{
+    stream << filter.ids;
+    stream << filter.propertyFilter;
+    return stream;
+}
+
+QDataStream & operator>> (QDataStream &stream, Sink::QueryBase::Filter &filter)
+{
+    stream >> filter.ids;
+    stream >> filter.propertyFilter;
+    return stream;
+}
+
+QDataStream & operator<< (QDataStream &stream, const Sink::QueryBase &query)
+{
+    stream << query.type();
+    stream << query.sortProperty();
+    stream << query.getFilter();
+    return stream;
+}
+
+QDataStream & operator>> (QDataStream &stream, Sink::QueryBase &query)
+{
+    QByteArray type;
+    stream >> type;
+    query.setType(type);
+    QByteArray sortProperty;
+    stream >> sortProperty;
+    query.setSortProperty(sortProperty);
+    Sink::QueryBase::Filter filter;
+    stream >> filter;
+    query.setFilter(filter);
+    return stream;
+}
+
+bool QueryBase::Filter::operator==(const QueryBase::Filter &other) const
+{
+    auto ret = ids == other.ids && propertyFilter == other.propertyFilter;
+    return ret;
+}
+
+bool QueryBase::operator==(const QueryBase &other) const
+{
+    auto ret = mType == other.mType 
+        && mSortProperty == other.mSortProperty 
+        && mBaseFilterStage == other.mBaseFilterStage;
+    return ret;
+}
+
+QueryBase::Comparator::Comparator() : comparator(Invalid)
 {
 }
 
-Query::Comparator::Comparator(const QVariant &v) : value(v), comparator(Equals)
+QueryBase::Comparator::Comparator(const QVariant &v) : value(v), comparator(Equals)
 {
 }
 
-Query::Comparator::Comparator(const QVariant &v, Comparators c) : value(v), comparator(c)
+QueryBase::Comparator::Comparator(const QVariant &v, Comparators c) : value(v), comparator(c)
 {
 }
 
-bool Query::Comparator::matches(const QVariant &v) const
+bool QueryBase::Comparator::matches(const QVariant &v) const
 {
     switch(comparator) {
         case Equals:
@@ -73,3 +142,8 @@ bool Query::Comparator::matches(const QVariant &v) const
     }
     return false;
 }
+
+bool Query::Comparator::operator==(const Query::Comparator &other) const
+{
+    return value == other.value && comparator == other.comparator;
+}
diff --git a/common/query.h b/common/query.h
index b858610..70b6d63 100644
--- a/common/query.h
+++ b/common/query.h
@@ -42,6 +42,7 @@ public:
         Comparator(const QVariant &v);
         Comparator(const QVariant &v, Comparators c);
         bool matches(const QVariant &v) const;
+        bool operator==(const Comparator &other) const;
 
         QVariant value;
         Comparators comparator;
@@ -51,8 +52,11 @@ public:
     public:
         QByteArrayList ids;
         QHash<QByteArray, Comparator> propertyFilter;
+        bool operator==(const Filter &other) const;
     };
 
+    bool operator==(const QueryBase &other) const;
+
     Comparator getFilter(const QByteArray &property) const
     {
         return mBaseFilterStage.propertyFilter.value(property);
@@ -68,6 +72,11 @@ public:
         mBaseFilterStage.propertyFilter = filter;
     }
 
+    void setFilter(const Filter &filter)
+    {
+        mBaseFilterStage = filter;
+    }
+
     QHash<QByteArray, Comparator> getBaseFilters() const
     {
         return mBaseFilterStage.propertyFilter;
@@ -110,12 +119,12 @@ public:
 
     void setSortProperty(const QByteArray &property)
     {
-        mSortPorperty = property;
+        mSortProperty = property;
     }
 
     QByteArray sortProperty() const
     {
-        return mSortPorperty;
+        return mSortProperty;
     }
 
     class FilterStage {
@@ -244,7 +253,7 @@ private:
     Filter mBaseFilterStage;
     QList<QSharedPointer<FilterStage>> mFilterStages;
     QByteArray mType;
-    QByteArray mSortPorperty;
+    QByteArray mSortProperty;
 };
 
 /**
@@ -458,7 +467,10 @@ private:
 
 }
 
-QDebug operator<<(QDebug dbg, const Sink::Query::Comparator &c);
+QDebug SINK_EXPORT operator<<(QDebug dbg, const Sink::Query::Comparator &c);
+QDataStream & SINK_EXPORT operator<< (QDataStream &stream, const Sink::QueryBase &query);
+QDataStream & SINK_EXPORT operator>> (QDataStream &stream, Sink::QueryBase &query);
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Sink::Query::Flags)
+Q_DECLARE_METATYPE(Sink::QueryBase);
 Q_DECLARE_METATYPE(Sink::Query);
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index a5e1caf..06c6ad6 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -45,6 +45,41 @@ private slots:
         qDebug();
     }
 
+    void testSerialization()
+    {
+        qRegisterMetaTypeStreamOperators<Sink::QueryBase>();
+
+        auto type = QByteArray("type");
+        auto sort = QByteArray("sort");
+
+        Sink::QueryBase::Filter filter;
+        filter.ids << "id";
+        filter.propertyFilter.insert("foo", QVariant::fromValue(QByteArray("bar")));
+
+        Sink::Query query;
+        query.setFilter(filter);
+        query.setType(type);
+        query.setSortProperty(sort);
+
+        QByteArray data;
+        {
+            QDataStream stream(&data, QIODevice::WriteOnly);
+            stream << query;
+        }
+
+        Sink::Query deserializedQuery;
+        {
+            QDataStream stream(&data, QIODevice::ReadOnly);
+            stream >> deserializedQuery;
+        }
+
+        QCOMPARE(deserializedQuery.type(), type);
+        QCOMPARE(deserializedQuery.sortProperty(), sort);
+        QCOMPARE(deserializedQuery.getFilter().ids, filter.ids);
+        QCOMPARE(deserializedQuery.getFilter().propertyFilter.keys(), filter.propertyFilter.keys());
+        QCOMPARE(deserializedQuery.getFilter().propertyFilter, filter.propertyFilter);
+    }
+
     void testNoResources()
     {
         // Test