Merge branch 'kitsune/converters-upgrade' into dev

9 files changed, 79 insertions, 109 deletions

diff --git a/lib/events/encryptedevent.cpp b/lib/events/encryptedevent.cpp
index c97ccc16..ec00ad4c 100644
--- a/lib/events/encryptedevent.cpp
+++ b/lib/events/encryptedevent.cpp
@@ -49,14 +49,16 @@ RoomEventPtr EncryptedEvent::createDecrypted(const QString &decrypted) const
     eventObject["event_id"] = id();
     eventObject["sender"] = senderId();
     eventObject["origin_server_ts"] = originTimestamp().toMSecsSinceEpoch();
-    if (const auto relatesToJson = contentPart("m.relates_to"_ls); !relatesToJson.isUndefined()) {
+    if (const auto relatesToJson = contentPart<QJsonObject>("m.relates_to"_ls);
+        !relatesToJson.isEmpty()) {
         auto content = eventObject["content"].toObject();
-        content["m.relates_to"] = relatesToJson.toObject();
+        content["m.relates_to"] = relatesToJson;
         eventObject["content"] = content;
     }
-    if (const auto redactsJson = unsignedPart("redacts"_ls); !redactsJson.isUndefined()) {
+    if (const auto redactsJson = unsignedPart<QString>("redacts"_ls);
+        !redactsJson.isEmpty()) {
         auto unsign = eventObject["unsigned"].toObject();
-        unsign["redacts"] = redactsJson.toString();
+        unsign["redacts"] = redactsJson;
         eventObject["unsigned"] = unsign;
     }
     return loadEvent<RoomEvent>(eventObject);
diff --git a/lib/events/encryptionevent.cpp b/lib/events/encryptionevent.cpp
index 1654d6f3..8872447b 100644
--- a/lib/events/encryptionevent.cpp
+++ b/lib/events/encryptionevent.cpp
@@ -6,47 +6,45 @@
 
 #include "e2ee/e2ee.h"
 
-namespace Quotient {
+using namespace Quotient;
+
 static constexpr std::array encryptionStrings { MegolmV1AesSha2AlgoKey };
 
 template <>
-struct JsonConverter<EncryptionType> {
-    static EncryptionType load(const QJsonValue& jv)
-    {
-        const auto& encryptionString = jv.toString();
-        for (auto it = encryptionStrings.begin(); it != encryptionStrings.end();
-             ++it)
-            if (encryptionString == *it)
-                return EncryptionType(it - encryptionStrings.begin());
-
-        if (!encryptionString.isEmpty())
-            qCWarning(EVENTS) << "Unknown EncryptionType: " << encryptionString;
-        return EncryptionType::Undefined;
-    }
-};
-} // namespace Quotient
-
-using namespace Quotient;
+EncryptionType Quotient::fromJson(const QJsonValue& jv)
+{
+    const auto& encryptionString = jv.toString();
+    for (auto it = encryptionStrings.begin(); it != encryptionStrings.end();
+         ++it)
+        if (encryptionString == *it)
+            return EncryptionType(it - encryptionStrings.begin());
+
+    if (!encryptionString.isEmpty())
+        qCWarning(EVENTS) << "Unknown EncryptionType: " << encryptionString;
+    return EncryptionType::Undefined;
+}
 
 EncryptionEventContent::EncryptionEventContent(const QJsonObject& json)
-    : encryption(fromJson<EncryptionType>(json[AlgorithmKeyL]))
+    : encryption(fromJson<Quotient::EncryptionType>(json[AlgorithmKeyL]))
     , algorithm(sanitized(json[AlgorithmKeyL].toString()))
-    , rotationPeriodMs(json[RotationPeriodMsKeyL].toInt(604800000))
-    , rotationPeriodMsgs(json[RotationPeriodMsgsKeyL].toInt(100))
-{}
+{
+    // NB: fillFromJson only fills the variable if the JSON key exists
+    fillFromJson<int>(json[RotationPeriodMsKeyL], rotationPeriodMs);
+    fillFromJson<int>(json[RotationPeriodMsgsKeyL], rotationPeriodMsgs);
+}
 
-EncryptionEventContent::EncryptionEventContent(EncryptionType et)
+EncryptionEventContent::EncryptionEventContent(Quotient::EncryptionType et)
     : encryption(et)
 {
-    if(encryption != Undefined) {
-        algorithm = encryptionStrings[encryption];
+    if(encryption != Quotient::EncryptionType::Undefined) {
+        algorithm = encryptionStrings[static_cast<size_t>(encryption)];
     }
 }
 
 QJsonObject EncryptionEventContent::toJson() const
 {
     QJsonObject o;
-    if (encryption != EncryptionType::Undefined)
+    if (encryption != Quotient::EncryptionType::Undefined)
         o.insert(AlgorithmKey, algorithm);
     o.insert(RotationPeriodMsKey, rotationPeriodMs);
     o.insert(RotationPeriodMsgsKey, rotationPeriodMsgs);
diff --git a/lib/events/encryptionevent.h b/lib/events/encryptionevent.h
index 945b17e7..91452c3f 100644
--- a/lib/events/encryptionevent.h
+++ b/lib/events/encryptionevent.h
@@ -4,51 +4,44 @@
 
 #pragma once
 
+#include "quotient_common.h"
 #include "stateevent.h"
 
 namespace Quotient {
 class QUOTIENT_API EncryptionEventContent {
 public:
-    enum EncryptionType : size_t { MegolmV1AesSha2 = 0, Undefined };
+    using EncryptionType
+        [[deprecated("Use Quotient::EncryptionType instead")]] =
+            Quotient::EncryptionType;
 
-    QUO_IMPLICIT EncryptionEventContent(EncryptionType et);
-    [[deprecated("This constructor will require explicit EncryptionType soon")]] //
-    explicit EncryptionEventContent()
-        : EncryptionEventContent(Undefined)
-    {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    QUO_IMPLICIT EncryptionEventContent(Quotient::EncryptionType et);
     explicit EncryptionEventContent(const QJsonObject& json);
 
     QJsonObject toJson() const;
 
-    EncryptionType encryption;
-    QString algorithm;
-    int rotationPeriodMs;
-    int rotationPeriodMsgs;
+    Quotient::EncryptionType encryption;
+    QString algorithm {};
+    int rotationPeriodMs = 604'800'000;
+    int rotationPeriodMsgs = 100;
 };
 
-using EncryptionType = EncryptionEventContent::EncryptionType;
-
 class QUOTIENT_API EncryptionEvent : public StateEvent<EncryptionEventContent> {
-    Q_GADGET
 public:
     DEFINE_EVENT_TYPEID("m.room.encryption", EncryptionEvent)
 
-    using EncryptionType = EncryptionEventContent::EncryptionType;
-    Q_ENUM(EncryptionType)
+    using EncryptionType
+        [[deprecated("Use Quotient::EncryptionType instead")]] =
+            Quotient::EncryptionType;
 
     explicit EncryptionEvent(const QJsonObject& obj)
         : StateEvent(typeId(), obj)
     {}
-    [[deprecated("This constructor will require an explicit parameter soon")]] //
-//    explicit EncryptionEvent()
-//        : EncryptionEvent(QJsonObject())
-//    {}
     explicit EncryptionEvent(EncryptionEventContent&& content)
         : StateEvent(typeId(), matrixTypeId(), QString(), std::move(content))
     {}
 
-    EncryptionType encryption() const { return content().encryption; }
-
+    Quotient::EncryptionType encryption() const { return content().encryption; }
     QString algorithm() const { return content().algorithm; }
     int rotationPeriodMs() const { return content().rotationPeriodMs; }
     int rotationPeriodMsgs() const { return content().rotationPeriodMsgs; }
diff --git a/lib/events/event.h b/lib/events/event.h
index 05eb51e9..da6cf3c7 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -212,7 +212,7 @@ public:
 
     const QJsonObject contentJson() const;
 
-    template <typename T = QJsonValue, typename KeyT>
+    template <typename T, typename KeyT>
     const T contentPart(KeyT&& key) const
     {
         return fromJson<T>(contentJson()[std::forward<KeyT>(key)]);
@@ -227,7 +227,7 @@ public:
 
     const QJsonObject unsignedJson() const;
 
-    template <typename T = QJsonValue, typename KeyT>
+    template <typename T, typename KeyT>
     const T unsignedPart(KeyT&& key) const
     {
         return fromJson<T>(unsignedJson()[std::forward<KeyT>(key)]);
diff --git a/lib/events/roomcanonicalaliasevent.h b/lib/events/roomcanonicalaliasevent.h
index bb8654e5..e599699d 100644
--- a/lib/events/roomcanonicalaliasevent.h
+++ b/lib/events/roomcanonicalaliasevent.h
@@ -7,35 +7,30 @@
 #include "stateevent.h"
 
 namespace Quotient {
-namespace EventContent{
-    class AliasesEventContent {
-
-    public:
-
-        template<typename T1, typename T2>
-        AliasesEventContent(T1&& canonicalAlias, T2&& altAliases)
-            : canonicalAlias(std::forward<T1>(canonicalAlias))
-            , altAliases(std::forward<T2>(altAliases))
-        { }
-
-        AliasesEventContent(const QJsonObject& json)
-            : canonicalAlias(fromJson<QString>(json["alias"]))
-            , altAliases(fromJson<QStringList>(json["alt_aliases"]))
-        { }
-
-        auto toJson() const
-        {
-            QJsonObject jo;
-            addParam<IfNotEmpty>(jo, QStringLiteral("alias"), canonicalAlias);
-            addParam<IfNotEmpty>(jo, QStringLiteral("alt_aliases"), altAliases);
-            return jo;
-        }
-
+namespace EventContent {
+    struct AliasesEventContent {
         QString canonicalAlias;
         QStringList altAliases;
     };
 } // namespace EventContent
 
+template<>
+inline EventContent::AliasesEventContent fromJson(const QJsonObject& jo)
+{
+    return EventContent::AliasesEventContent {
+        fromJson<QString>(jo["alias"_ls]),
+        fromJson<QStringList>(jo["alt_aliases"_ls])
+    };
+}
+template<>
+inline auto toJson(const EventContent::AliasesEventContent& c)
+{
+    QJsonObject jo;
+    addParam<IfNotEmpty>(jo, QStringLiteral("alias"), c.canonicalAlias);
+    addParam<IfNotEmpty>(jo, QStringLiteral("alt_aliases"), c.altAliases);
+    return jo;
+}
+
 class RoomCanonicalAliasEvent
     : public StateEvent<EventContent::AliasesEventContent> {
 public:
diff --git a/lib/events/roomcreateevent.cpp b/lib/events/roomcreateevent.cpp
index bb6de648..3b5024d5 100644
--- a/lib/events/roomcreateevent.cpp
+++ b/lib/events/roomcreateevent.cpp
@@ -6,20 +6,11 @@
 using namespace Quotient;
 
 template <>
-struct Quotient::JsonConverter<RoomType> {
-    static RoomType load(const QJsonValue& jv)
-    {
-        const auto& roomTypeString = jv.toString();
-        for (auto it = RoomTypeStrings.begin(); it != RoomTypeStrings.end();
-             ++it)
-            if (roomTypeString == *it)
-                return RoomType(it - RoomTypeStrings.begin());
-
-        if (!roomTypeString.isEmpty())
-            qCWarning(EVENTS) << "Unknown Room Type: " << roomTypeString;
-        return RoomType::Undefined;
-    }
-};
+RoomType Quotient::fromJson(const QJsonValue& jv)
+{
+    return enumFromJsonString(jv.toString(), RoomTypeStrings,
+                              RoomType::Undefined);
+}
 
 bool RoomCreateEvent::isFederated() const
 {
diff --git a/lib/events/roomevent.cpp b/lib/events/roomevent.cpp
index 3ddf5ac4..e695e0ec 100644
--- a/lib/events/roomevent.cpp
+++ b/lib/events/roomevent.cpp
@@ -15,9 +15,9 @@ RoomEvent::RoomEvent(Type type, event_mtype_t matrixType,
 
 RoomEvent::RoomEvent(Type type, const QJsonObject& json) : Event(type, json)
 {
-    if (const auto redaction = unsignedPart(RedactedCauseKeyL);
-        redaction.isObject())
-        _redactedBecause = makeEvent<RedactionEvent>(redaction.toObject());
+    if (const auto redaction = unsignedPart<QJsonObject>(RedactedCauseKeyL);
+        !redaction.isEmpty())
+        _redactedBecause = makeEvent<RedactionEvent>(redaction);
 }
 
 RoomEvent::~RoomEvent() = default; // Let the smart pointer do its job
diff --git a/lib/events/roommemberevent.cpp b/lib/events/roommemberevent.cpp
index c3be0e00..953ff8ae 100644
--- a/lib/events/roommemberevent.cpp
+++ b/lib/events/roommemberevent.cpp
@@ -11,18 +11,10 @@ template <>
 struct JsonConverter<Membership> {
     static Membership load(const QJsonValue& jv)
     {
-        const auto& ms = jv.toString();
-        if (ms.isEmpty())
-        {
-            qCWarning(EVENTS) << "Empty membership state";
-            return Membership::Invalid;
-        }
-        const auto it =
-            std::find(MembershipStrings.begin(), MembershipStrings.end(), ms);
-        if (it != MembershipStrings.end())
-            return Membership(1U << (it - MembershipStrings.begin()));
-
-        qCWarning(EVENTS) << "Unknown Membership value: " << ms;
+        if (const auto& ms = jv.toString(); !ms.isEmpty())
+            return flagFromJsonString<Membership>(ms, MembershipStrings);
+
+        qCWarning(EVENTS) << "Empty membership state";
         return Membership::Invalid;
     }
 };
@@ -46,8 +38,7 @@ QJsonObject MemberEventContent::toJson() const
     QJsonObject o;
     if (membership != Membership::Invalid)
         o.insert(QStringLiteral("membership"),
-                  MembershipStrings[qCountTrailingZeroBits(
-                      std::underlying_type_t<Membership>(membership))]);
+                 flagToJsonString(membership, MembershipStrings));
     if (displayName)
         o.insert(QStringLiteral("displayname"), *displayName);
     if (avatarUrl && avatarUrl->isValid())
diff --git a/lib/events/stateevent.cpp b/lib/events/stateevent.cpp
index c343e37f..43dfd6e8 100644
--- a/lib/events/stateevent.cpp
+++ b/lib/events/stateevent.cpp
@@ -21,7 +21,7 @@ StateEventBase::StateEventBase(Event::Type type, event_mtype_t matrixType,
 
 bool StateEventBase::repeatsState() const
 {
-    const auto prevContentJson = unsignedPart(PrevContentKeyL);
+    const auto prevContentJson = unsignedPart<QJsonObject>(PrevContentKeyL);
     return fullJson().value(ContentKeyL) == prevContentJson;
 }