Better power level checking, part 1

Quotient/events/event.cpp

@@ -4,55 +4,44 @@
 #include "event.h"
 
 #include "../logging_categories_p.h"
-#include "stateevent.h"
+#include "../ranges_extras.h"
 
 #include <QtCore/QJsonDocument>
 
+#if Quotient_VERSION_MAJOR == 0 && Quotient_VERSION_MINOR <= 9
+#include "stateevent.h" // For deprecated isStateEvent(); remove, once Event::isStateEvent() is gone
+#endif
+
 using namespace Quotient;
 
 void AbstractEventMetaType::addDerived(const AbstractEventMetaType* newType)
 {
  if (const auto existing =
- std::find_if(derivedTypes.cbegin(), derivedTypes.cend(),
- [&newType](const AbstractEventMetaType* t) {
- return t->matrixId == newType->matrixId;
- });
- existing != derivedTypes.cend())
- {
+ findIndirect(_derivedTypes, newType->matrixId, &AbstractEventMetaType::matrixId);
+ existing != _derivedTypes.cend()) {
  if (*existing == newType)
  return;
  // Two different metatype objects claim the same Matrix type id; this
  // is not normal, so give as much information as possible to diagnose
  if ((*existing)->className == newType->className) {
- qCritical(EVENTS)
- << newType->className << "claims" << newType->matrixId
- << "repeatedly; check that it's exported across translation "
- "units or shared objects";
+ qCritical(EVENTS) << newType->className << "claims" << newType->matrixId
+ << "repeatedly; check that it's exported across translation "
+ "units or shared objects";
  Q_ASSERT(false); // That situation is plain wrong
  return; // So maybe std::terminate() even?
  }
- qWarning(EVENTS).nospace()
- << newType->matrixId << " is already mapped to "
- << (*existing)->className << " before " << newType->className
- << "; unless the two have different isValid() conditions, the "
- "latter class will never be used";
+ qWarning(EVENTS).nospace() << newType->matrixId << " is already mapped to "
+ << (*existing)->className << " before " << newType->className
+ << "; unless the two have different isValid() conditions, the "
+ "latter class will never be used";
  }
- derivedTypes.emplace_back(newType);
- qDebug(EVENTS).nospace()
- << newType->matrixId << " -> " << newType->className << "; "
- << derivedTypes.size() << " derived type(s) registered for "
- << className;
+ _derivedTypes.emplace_back(newType);
+ qDebug(EVENTS).nospace() << newType->matrixId << " -> " << newType->className << "; "
+ << _derivedTypes.size() << " derived type(s) registered for "
+ << className;
 }
 
-Event::Event(const QJsonObject& json)
- : _json(json)
-{
- if (!json.contains(ContentKey)
- && !json.value(UnsignedKey).toObject().contains(RedactedCauseKey)) {
- qCWarning(EVENTS) << "Event without 'content' node";
- qCWarning(EVENTS) << formatJson << json;
- }
-}
+Event::Event(const QJsonObject& json) : _json(json) {}
 
 Event::~Event() = default;
 
@@ -68,7 +57,9 @@ const QJsonObject Event::unsignedJson() const
  return fullJson()[UnsignedKey].toObject();
 }
 
+#if Quotient_VERSION_MAJOR == 0 && Quotient_VERSION_MINOR <= 9
 bool Event::isStateEvent() const { return is<StateEvent>(); }
+#endif
 
 void Event::dumpTo(QDebug dbg) const
 {

Quotient/events/event.h

@@ -19,6 +19,7 @@ constexpr inline auto TypeKey = "type"_L1;
 constexpr inline auto BodyKey = "body"_L1;
 constexpr inline auto ContentKey = "content"_L1;
 constexpr inline auto SenderKey = "sender"_L1;
+constexpr inline auto UnsignedKey = "unsigned"_L1;
 
 using event_type_t = QLatin1String;
 
@@ -55,6 +56,7 @@ class QUOTIENT_API AbstractEventMetaType {
  }
 
  void addDerived(const AbstractEventMetaType* newType);
+ auto derivedTypes() const { return std::span(_derivedTypes); }
 
  virtual ~AbstractEventMetaType() = default;
 
@@ -69,7 +71,7 @@ class QUOTIENT_API AbstractEventMetaType {
  Event*& event) const = 0;
 
 private:
- std::vector<const AbstractEventMetaType*> derivedTypes{};
+ std::vector<const AbstractEventMetaType*> _derivedTypes{};
  Q_DISABLE_COPY_MOVE(AbstractEventMetaType)
 };
 
@@ -146,7 +148,7 @@ class QUOTIENT_API EventMetaType : public AbstractEventMetaType {
  if (EventT::TypeId != type)
  return false;
  } else {
- for (const auto& p : derivedTypes) {
+ for (const auto& p : _derivedTypes) {
  p->doLoadFrom(fullJson, type, event);
  if (event) {
  Q_ASSERT(is<EventT>(*event));
@@ -328,10 +330,9 @@ class QUOTIENT_API Event {
  return dbg;
  }
 
- // State events are quite special in Matrix; so isStateEvent() is here,
- // as an exception. For other base events, Event::is<>() and
- // Quotient::is<>() should be used; don't add is* methods here
- bool isStateEvent() const;
+#if Quotient_VERSION_MAJOR == 0 && Quotient_VERSION_MINOR <= 9
+ [[deprecated("isStateEvent() has moved to RoomEvent")]] bool isStateEvent() const;
+#endif
 
 protected:
  friend class EventMetaType<Event>; // To access the below constructor

Quotient/events/roomevent.cpp

@@ -3,10 +3,11 @@
 
 #include "roomevent.h"
 
-#include "../logging_categories_p.h"
+#include "encryptedevent.h"
 #include "redactionevent.h"
+#include "stateevent.h"
 
-#include "encryptedevent.h"
+#include "../logging_categories_p.h"
 
 using namespace Quotient;
 
@@ -48,6 +49,8 @@ QString RoomEvent::transactionId() const
  return unsignedPart<QString>("transaction_id"_L1);
 }
 
+bool RoomEvent::isStateEvent() const { return is<StateEvent>(); }
+
 QString RoomEvent::stateKey() const
 {
  return fullJson()[StateKeyKey].toString();
@@ -98,3 +101,17 @@ const QJsonObject RoomEvent::encryptedJson() const
  }
  return _originalEvent->fullJson();
 }
+
+namespace {
+bool containsEventType(const auto& haystack, const auto& needle)
+{
+ return std::ranges::any_of(haystack, [needle](const AbstractEventMetaType* candidate) {
+ return candidate->matrixId == needle || containsEventType(candidate->derivedTypes(), needle);
+ });
+}
+}
+
+bool Quotient::isStateEvent(const QString& eventTypeId)
+{
+ return containsEventType(StateEvent::BaseMetaType.derivedTypes(), eventTypeId);
+}

Quotient/events/roomevent.h

@@ -14,7 +14,6 @@ constexpr inline auto RoomIdKey = "room_id"_L1;
 constexpr inline auto StateKeyKey = "state_key"_L1;
 constexpr inline auto RedactedCauseKey = "redacted_because"_L1;
 constexpr inline auto RelatesToKey = "m.relates_to"_L1;
-constexpr inline auto UnsignedKey = "unsigned"_L1;
 
 class RedactionEvent;
 class EncryptedEvent;
@@ -49,6 +48,12 @@ class QUOTIENT_API RoomEvent : public Event {
  //! The transaction_id JSON value for the event.
  QString transactionId() const;
 
+ // State events are special in Matrix; so isStateEvent() and stateKey() are here,
+ // as an exception. For other event types (including base types), Event::is<>() and
+ // Quotient::is<>() should be used
+
+ bool isStateEvent() const;
+
  QString stateKey() const;
 
  //! \brief Fill the pending event object with the room id
@@ -89,6 +94,9 @@ using RoomEventPtr = event_ptr_tt<RoomEvent>;
 using RoomEvents = EventsArray<RoomEvent>;
 using RoomEventsRange = std::ranges::subrange<RoomEvents::iterator>;
 
+//! \brief Determine whether a given event type is that of a state event
+QUOTIENT_API bool isStateEvent(const QString& eventTypeId);
+
 } // namespace Quotient
 Q_DECLARE_METATYPE(Quotient::RoomEvent*)
 Q_DECLARE_METATYPE(const Quotient::RoomEvent*)

Quotient/events/roompowerlevelsevent.cpp

@@ -5,33 +5,36 @@
 
 using namespace Quotient;
 
-// The default values used below are defined in
-// https://spec.matrix.org/v1.3/client-server-api/#mroompower_levels
-PowerLevelsEventContent::PowerLevelsEventContent(const QJsonObject& json) :
- invite(json["invite"_L1].toInt(50)),
- kick(json["kick"_L1].toInt(50)),
- ban(json["ban"_L1].toInt(50)),
- redact(json["redact"_L1].toInt(50)),
- events(fromJson<QHash<QString, int>>(json["events"_L1])),
- eventsDefault(json["events_default"_L1].toInt(0)),
- stateDefault(json["state_default"_L1].toInt(50)),
- users(fromJson<QHash<QString, int>>(json["users"_L1])),
- usersDefault(json["users_default"_L1].toInt(0)),
- notifications(Notifications{json["notifications"_L1].toObject()["room"_L1].toInt(50)})
-{}
-
-QJsonObject PowerLevelsEventContent::toJson() const
+PowerLevelsEventContent JsonConverter<PowerLevelsEventContent>::load(const QJsonValue& jv)
 {
- return QJsonObject{ { u"invite"_s, invite },
- { u"kick"_s, kick },
- { u"ban"_s, ban },
- { u"redact"_s, redact },
- { u"events"_s, Quotient::toJson(events) },
- { u"events_default"_s, eventsDefault },
- { u"state_default"_s, stateDefault },
- { u"users"_s, Quotient::toJson(users) },
- { u"users_default"_s, usersDefault },
- { u"notifications"_s, QJsonObject{ { u"room"_s, notifications.room } } } };
+ const auto& jo = jv.toObject();
+ PowerLevelsEventContent c;
+#define FROM_JSON(member) fromJson(jo[toSnakeCase(#member##_L1)], c.member)
+ FROM_JSON(invite);
+ FROM_JSON(kick);
+ FROM_JSON(ban);
+ FROM_JSON(redact);
+ FROM_JSON(events);
+ FROM_JSON(eventsDefault);
+ FROM_JSON(stateDefault);
+ FROM_JSON(users);
+ FROM_JSON(usersDefault);
+ fromJson(jo["notifications"_L1]["room"_L1], c.notifications.room);
+#undef FROM_JSON
+ return c;
+}
+
+QJsonObject JsonConverter<PowerLevelsEventContent>::dump(const PowerLevelsEventContent& c) {
+ return QJsonObject{ { u"invite"_s, c.invite },
+ { u"kick"_s, c.kick },
+ { u"ban"_s, c.ban },
+ { u"redact"_s, c.redact },
+ { u"events"_s, Quotient::toJson(c.events) },
+ { u"events_default"_s, c.eventsDefault },
+ { u"state_default"_s, c.stateDefault },
+ { u"users"_s, Quotient::toJson(c.users) },
+ { u"users_default"_s, c.usersDefault },
+ { u"notifications"_s, QJsonObject{ { u"room"_s, c.notifications.room } } } };
 }
 
 int RoomPowerLevelsEvent::powerLevelForEvent(const QString& eventTypeId) const

Quotient/events/roompowerlevelsevent.h

@@ -6,28 +6,33 @@
 #include "stateevent.h"
 
 namespace Quotient {
+
 struct QUOTIENT_API PowerLevelsEventContent {
- struct Notifications {
- int room;
- };
+ // See https://spec.matrix.org/v1.11/client-server-api/#mroompower_levels for the defaults
 
- explicit PowerLevelsEventContent(const QJsonObject& json);
- QJsonObject toJson() const;
+ int invite = 0;
+ int kick = 50;
+ int ban = 50;
 
- int invite;
- int kick;
- int ban;
+ int redact = 50;
 
- int redact;
+ QHash<QString, int> events{};
+ int eventsDefault = 0;
+ int stateDefault = 50;
 
- QHash<QString, int> events;
- int eventsDefault;
- int stateDefault;
+ QHash<QString, int> users{};
+ int usersDefault = 0;
 
- QHash<QString, int> users;
- int usersDefault;
+ struct Notifications {
+ int room = 50;
+ };
+ Notifications notifications{};
+};
 
- Notifications notifications;
+template <>
+struct QUOTIENT_API JsonConverter<PowerLevelsEventContent> {
+ static PowerLevelsEventContent load(const QJsonValue& jv);
+ static QJsonObject dump(const PowerLevelsEventContent& c);
 };
 
 class QUOTIENT_API RoomPowerLevelsEvent
@@ -52,8 +57,37 @@ class QUOTIENT_API RoomPowerLevelsEvent
 
  int roomNotification() const { return content().notifications.room; }
 
+ //! \brief Get the power level for message events of a given type
+ //!
+ //! \note You normally should not compare power levels returned from this
+ //! and other powerLevelFor*() functions directly; use
+ //! Room::canSendEvents() instead
  int powerLevelForEvent(const QString& eventTypeId) const;
+
+ //! \brief Get the power level for state events of a given type
+ //!
+ //! \note You normally should not compare power levels returned from this
+ //! and other powerLevelFor*() functions directly; use
+ //! Room::canSetState() instead
  int powerLevelForState(const QString& eventTypeId) const;
+
+ //! \brief Get the power level for a given user
+ //!
+ //! \note You normally should not directly use power levels returned by this
+ //! and other powerLevelFor*() functions; use Room API instead
+ //! \sa Room::canSend, Room::canSendEvents, Room::canSetState,
+ //! Room::effectivePowerLevel
  int powerLevelForUser(const QString& userId) const;
+
+ template <EventClass EvT>
+ int powerLevelForEventType() const
+ {
+ if constexpr (std::is_base_of_v<StateEvent, EvT>) {
+ return powerLevelForState(EvT::TypeId);
+ } else {
+ return powerLevelForEvent(EvT::TypeId);
+ }
+ }
 };
+
 } // namespace Quotient