From 3392e66fd015e191b01f6e3fc6839edc3948e31f Mon Sep 17 00:00:00 2001
From: Kitsune Ral <Kitsune-Ral@users.sf.net>
Date: Sat, 8 Dec 2018 15:36:04 +0900
Subject: Refactor toJson/fillJson

Both now use through a common JsonConverter<> template class with its
base definition tuned for structs/QJsonObjects and specialisations for
non-object types. This new implementation doesn't work with virtual
fillJson functions yet (so EventContent classes still use toJson as a
member function) and does not cope quite well with non-constructible
objects (you have to specialise JsonConverter<> rather than, more
intuitively, JsonObjectConverter<>), but overall is more streamlined
compared to the previous implementation. It also fixes one important
issue that pushed for a rewrite: the previous implementation was not
working with structure hierarchies at all so (in particular) the Filter
part of CS API was totally disfunctional.
---
 lib/events/accountdataevents.h | 35 ++++++++++++++++++-----------------
 lib/events/eventloader.h       | 10 +++++++---
 lib/events/roommemberevent.cpp | 12 +++++-------
 3 files changed, 30 insertions(+), 27 deletions(-)

(limited to 'lib/events')

diff --git a/lib/events/accountdataevents.h b/lib/events/accountdataevents.h
index d1c1abc8..a99d85ac 100644
--- a/lib/events/accountdataevents.h
+++ b/lib/events/accountdataevents.h
@@ -36,37 +36,38 @@ namespace QMatrixClient
         order_type order;
 
         TagRecord (order_type order = none) : order(order) { }
-        explicit TagRecord(const QJsonObject& jo)
+
+        bool operator<(const TagRecord& other) const
+        {
+            // Per The Spec, rooms with no order should be after those with order
+            return !order.omitted() &&
+                        (other.order.omitted() || order.value() < other.order.value());
+        }
+    };
+
+    template <> struct JsonObjectConverter<TagRecord>
+    {
+        static void fillFrom(const QJsonObject& jo, TagRecord& rec)
         {
             // Parse a float both from JSON double and JSON string because
             // libqmatrixclient previously used to use strings to store order.
             const auto orderJv = jo.value("order"_ls);
             if (orderJv.isDouble())
-                order = fromJson<float>(orderJv);
-            else if (orderJv.isString())
+                rec.order = fromJson<float>(orderJv);
+            if (orderJv.isString())
             {
                 bool ok;
-                order = orderJv.toString().toFloat(&ok);
+                rec.order = orderJv.toString().toFloat(&ok);
                 if (!ok)
-                    order = none;
+                    rec.order = none;
             }
         }
-
-        bool operator<(const TagRecord& other) const
+        static void dumpTo(QJsonObject& jo, const TagRecord& rec)
         {
-            // Per The Spec, rooms with no order should be after those with order
-            return !order.omitted() &&
-                        (other.order.omitted() || order.value() < other.order.value());
+            addParam<IfNotEmpty>(jo, QStringLiteral("order"), rec.order);
         }
     };
 
-    inline QJsonValue toJson(const TagRecord& rec)
-    {
-        QJsonObject o;
-        addParam<IfNotEmpty>(o, QStringLiteral("order"), rec.order);
-        return o;
-    }
-
     using TagsMap = QHash<QString, TagRecord>;
 
 #define DEFINE_SIMPLE_EVENT(_Name, _TypeId, _ContentType, _ContentKey) \
diff --git a/lib/events/eventloader.h b/lib/events/eventloader.h
index cd2f9149..da663392 100644
--- a/lib/events/eventloader.h
+++ b/lib/events/eventloader.h
@@ -57,11 +57,15 @@ namespace QMatrixClient {
                                             matrixType);
     }
 
-    template <typename EventT> struct FromJsonObject<event_ptr_tt<EventT>>
+    template <typename EventT> struct JsonConverter<event_ptr_tt<EventT>>
     {
-        auto operator()(const QJsonObject& jo) const
+        static auto load(const QJsonValue& jv)
         {
-            return loadEvent<EventT>(jo);
+            return loadEvent<EventT>(jv.toObject());
+        }
+        static auto load(const QJsonDocument& jd)
+        {
+            return loadEvent<EventT>(jd.object());
         }
     };
 } // namespace QMatrixClient
diff --git a/lib/events/roommemberevent.cpp b/lib/events/roommemberevent.cpp
index eaa3302c..a5ac3c5f 100644
--- a/lib/events/roommemberevent.cpp
+++ b/lib/events/roommemberevent.cpp
@@ -23,20 +23,17 @@
 
 #include <array>
 
-using namespace QMatrixClient;
-
 static const std::array<QString, 5> membershipStrings = { {
     QStringLiteral("invite"), QStringLiteral("join"),
     QStringLiteral("knock"), QStringLiteral("leave"),
     QStringLiteral("ban")
 } };
 
-namespace QMatrixClient
-{
+namespace QMatrixClient {
     template <>
-    struct FromJson<MembershipType>
+    struct JsonConverter<MembershipType>
     {
-        MembershipType operator()(const QJsonValue& jv) const
+        static MembershipType load(const QJsonValue& jv)
         {
             const auto& membershipString = jv.toString();
             for (auto it = membershipStrings.begin();
@@ -48,9 +45,10 @@ namespace QMatrixClient
             return MembershipType::Undefined;
         }
     };
-
 }
 
+using namespace QMatrixClient;
+
 MemberEventContent::MemberEventContent(const QJsonObject& json)
     : membership(fromJson<MembershipType>(json["membership"_ls]))
     , isDirect(json["is_direct"_ls].toBool())
-- 
cgit v1.2.3