From e511841292d241fb9175a712184900ae69ed8685 Mon Sep 17 00:00:00 2001
From: Christian Mollekopf <chrigi_1@fastmail.fm>
Date: Sun, 6 Nov 2016 10:12:24 +0100
Subject: Query serialization.

---
 common/query.cpp | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++---
 common/query.h   | 20 +++++++++++---
 2 files changed, 94 insertions(+), 8 deletions(-)

(limited to 'common')

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);
-- 
cgit v1.2.3