Streamline event types

This commit introduces a few things to further reduce the boilerplate
across event type definitions:
- Event type is no more separately stored in Event and therefore no more
  passed to base event constructors. Until the previous commit, it was
  used by is() to quickly match the event type; with the new event
  metatype class, the same is achieved even quicker by comparing
  metatype pointers.
- EventTemplate is a generalisation of StateEvent for all event types
  providing common constructor signatures and content() for (most) leaf
  event types. StateEvent therefore has become a partial specialisation
  of EventTemplate for types derived from StateEventBase; as the known
  client code base does not use it directly, a compatibility alias is
  not provided. Also, DEFINE_SIMPLE_EVENT now expands into a class
  deriving from EventTemplate.
- On top of StateEvent->EventTemplate specialisation,
  KeyedStateEventBase and KeylessStateEventBase types are introduced
  with appropriate constructor signatures (with or without state_key,
  respectively) to allow `using` of them from derived event types.
  To facilitate writing of constraints, concepts for keyed and keyless
  state event types are also introduced; RoomStateView, e.g., makes use
  of those to provide appropriate method signatures.
- typeId(), unknownEventTypeId(), UnknownEventTypeId are no more
  provided - they weren't used throughout the known code base
  (Quaternion, NeoChat), and the concept of "unknown event types" is
  hereby eliminated entirely.
- RoomKeyEvent no more accepts senderId as a parameter; it has never
  been a good practice as the sender is assigned by Connection anyway.

1 files changed, 14 insertions, 8 deletions

diff --git a/lib/events/roomevent.h b/lib/events/roomevent.h
index 532e72e2..830f1d30 100644
--- a/lib/events/roomevent.h
+++ b/lib/events/roomevent.h
@@ -17,10 +17,8 @@ public:
     QUO_BASE_EVENT(RoomEvent, {}, Event::BaseMetaType)
 
     // RedactionEvent is an incomplete type here so we cannot inline
-    // constructors and destructors and we cannot use 'using'.
-    RoomEvent(Type type, event_mtype_t matrixType,
-              const QJsonObject& contentJson = {});
-    RoomEvent(Type type, const QJsonObject& json);
+    // constructors using it and also destructors (with 'using', in particular).
+    explicit RoomEvent(const QJsonObject& json);
     ~RoomEvent() override;
 
     QString id() const;
@@ -85,10 +83,7 @@ class QUOTIENT_API CallEventBase : public RoomEvent {
 public:
     QUO_BASE_EVENT(CallEventBase, "m.call.*"_ls, RoomEvent::BaseMetaType)
 
-    CallEventBase(Type type, event_mtype_t matrixType, const QString& callId,
-                  int version, const QJsonObject& contentJson = {});
-    CallEventBase(Type type, const QJsonObject& json);
-    ~CallEventBase() override = default;
+    explicit CallEventBase(const QJsonObject& json);
 
     QUO_CONTENT_GETTER(QString, callId)
     QUO_CONTENT_GETTER(int, version)
@@ -98,6 +93,17 @@ protected:
                                  const QString& callId, int version,
                                  QJsonObject contentJson = {});
 };
+
+template <typename EventT>
+class EventTemplate<EventT, CallEventBase, void> : public CallEventBase {
+public:
+    using CallEventBase::CallEventBase;
+    explicit EventTemplate(const QString& callId,
+                           const QJsonObject& contentJson = {})
+        : EventTemplate(basicJson(EventT::TypeId, callId, 0, contentJson))
+    {}
+};
+
 } // namespace Quotient
 Q_DECLARE_METATYPE(Quotient::RoomEvent*)
 Q_DECLARE_METATYPE(const Quotient::RoomEvent*)