Update upstream source from tag 'upstream/0.6.4'

Update to upstream version '0.6.4'
with Debian dir aa8705fd74743e79c043bc9e3e425d5064404cfe

1 files changed, 61 insertions, 64 deletions

diff --git a/lib/events/simplestateevents.h b/lib/events/simplestateevents.h
index 2c23d9ca..cde5b0fd 100644
--- a/lib/events/simplestateevents.h
+++ b/lib/events/simplestateevents.h
@@ -13,80 +13,77 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #pragma once
 
 #include "stateevent.h"
 
-#include "converters.h"
+namespace Quotient {
+namespace EventContent {
+    template <typename T>
+    class SimpleContent {
+    public:
+        using value_type = T;
 
-namespace QMatrixClient
-{
-    namespace EventContent
-    {
-        template <typename T>
-        class SimpleContent
+        // The constructor is templated to enable perfect forwarding
+        template <typename TT>
+        SimpleContent(QString keyName, TT&& value)
+            : value(std::forward<TT>(value)), key(std::move(keyName))
+        {}
+        SimpleContent(const QJsonObject& json, QString keyName)
+            : value(fromJson<T>(json[keyName])), key(std::move(keyName))
+        {}
+        QJsonObject toJson() const
         {
-            public:
-                using value_type = T;
+            return { { key, Quotient::toJson(value) } };
+        }
 
-                // The constructor is templated to enable perfect forwarding
-                template <typename TT>
-                SimpleContent(QString keyName, TT&& value)
-                    : value(std::forward<TT>(value)), key(std::move(keyName))
-                { }
-                SimpleContent(const QJsonObject& json, QString keyName)
-                    : value(fromJson<T>(json[keyName]))
-                    , key(std::move(keyName))
-                { }
-                QJsonObject toJson() const
-                {
-                    return { { key, QMatrixClient::toJson(value) } };
-                }
+    public:
+        T value;
 
-            public:
-                T value;
+    protected:
+        QString key;
+    };
+} // namespace EventContent
 
-            protected:
-                QString key;
-        };
-    } // namespace EventContent
-
-#define DEFINE_SIMPLE_STATE_EVENT(_Name, _TypeId, _ValueType, _ContentKey) \
-    class _Name : public StateEvent<EventContent::SimpleContent<_ValueType>> \
-    { \
-        public: \
-            using value_type = content_type::value_type; \
-            DEFINE_EVENT_TYPEID(_TypeId, _Name) \
-            explicit _Name() : _Name(value_type()) { } \
-            template <typename T> \
-            explicit _Name(T&& value) \
-                : StateEvent(typeId(), matrixTypeId(), \
-                             QStringLiteral(#_ContentKey), \
-                             std::forward<T>(value)) \
-            { } \
-            explicit _Name(QJsonObject obj) \
-                : StateEvent(typeId(), std::move(obj), \
-                             QStringLiteral(#_ContentKey)) \
-            { } \
-            auto _ContentKey() const { return content().value; } \
-    }; \
-    REGISTER_EVENT_TYPE(_Name) \
+#define DEFINE_SIMPLE_STATE_EVENT(_Name, _TypeId, _ValueType, _ContentKey)     \
+    class _Name : public StateEvent<EventContent::SimpleContent<_ValueType>> { \
+    public:                                                                    \
+        using value_type = content_type::value_type;                           \
+        DEFINE_EVENT_TYPEID(_TypeId, _Name)                                    \
+        explicit _Name() : _Name(value_type()) {}                              \
+        template <typename T>                                                  \
+        explicit _Name(T&& value)                                              \
+            : StateEvent(typeId(), matrixTypeId(), QString(),                  \
+                         QStringLiteral(#_ContentKey), std::forward<T>(value)) \
+        {}                                                                     \
+        explicit _Name(QJsonObject obj)                                        \
+            : StateEvent(typeId(), std::move(obj),                             \
+                         QStringLiteral(#_ContentKey))                         \
+        {}                                                                     \
+        auto _ContentKey() const { return content().value; }                   \
+    };                                                                         \
+    REGISTER_EVENT_TYPE(_Name)                                                 \
     // End of macro
 
-    DEFINE_SIMPLE_STATE_EVENT(RoomNameEvent, "m.room.name", QString, name)
-    DEFINE_EVENTTYPE_ALIAS(RoomName, RoomNameEvent)
-    DEFINE_SIMPLE_STATE_EVENT(RoomAliasesEvent, "m.room.aliases",
-                              QStringList, aliases)
-    DEFINE_EVENTTYPE_ALIAS(RoomAliases, RoomAliasesEvent)
-    DEFINE_SIMPLE_STATE_EVENT(RoomCanonicalAliasEvent, "m.room.canonical_alias",
-                              QString, alias)
-    DEFINE_EVENTTYPE_ALIAS(RoomCanonicalAlias, RoomCanonicalAliasEvent)
-    DEFINE_SIMPLE_STATE_EVENT(RoomTopicEvent, "m.room.topic", QString, topic)
-    DEFINE_EVENTTYPE_ALIAS(RoomTopic, RoomTopicEvent)
-    DEFINE_SIMPLE_STATE_EVENT(EncryptionEvent, "m.room.encryption",
-                              QString, algorithm)
-    DEFINE_EVENTTYPE_ALIAS(RoomEncryption, EncryptionEvent)
-} // namespace QMatrixClient
+DEFINE_SIMPLE_STATE_EVENT(RoomNameEvent, "m.room.name", QString, name)
+DEFINE_SIMPLE_STATE_EVENT(RoomTopicEvent, "m.room.topic", QString, topic)
+
+class RoomAliasesEvent
+    : public StateEvent<EventContent::SimpleContent<QStringList>> {
+public:
+    DEFINE_EVENT_TYPEID("m.room.aliases", RoomAliasesEvent)
+    explicit RoomAliasesEvent(const QJsonObject& obj)
+        : StateEvent(typeId(), obj, QStringLiteral("aliases"))
+    {}
+    RoomAliasesEvent(const QString& server, const QStringList& aliases)
+        : StateEvent(typeId(), matrixTypeId(), server,
+                     QStringLiteral("aliases"), aliases)
+    {}
+    QString server() const { return stateKey(); }
+    QStringList aliases() const { return content().value; }
+};
+REGISTER_EVENT_TYPE(RoomAliasesEvent)
+} // namespace Quotient