From bea4a7c81769c7e241478e4b0b29c62f389bc957 Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Fri, 23 Nov 2018 19:20:00 +0900 Subject: Update CS API --- lib/csapi/definitions/room_event_filter.cpp | 6 +++++ lib/csapi/definitions/room_event_filter.h | 4 +++ lib/csapi/kicking.h | 2 +- lib/csapi/read_markers.h | 2 +- lib/csapi/rooms.cpp | 40 ----------------------------- lib/csapi/rooms.h | 26 ------------------- 6 files changed, 12 insertions(+), 68 deletions(-) diff --git a/lib/csapi/definitions/room_event_filter.cpp b/lib/csapi/definitions/room_event_filter.cpp index f6f1e5cb..8cd2ded7 100644 --- a/lib/csapi/definitions/room_event_filter.cpp +++ b/lib/csapi/definitions/room_event_filter.cpp @@ -12,6 +12,8 @@ QJsonObject QMatrixClient::toJson(const RoomEventFilter& pod) addParam(jo, QStringLiteral("not_rooms"), pod.notRooms); addParam(jo, QStringLiteral("rooms"), pod.rooms); addParam(jo, QStringLiteral("contains_url"), pod.containsUrl); + addParam(jo, QStringLiteral("lazy_load_members"), pod.lazyLoadMembers); + addParam(jo, QStringLiteral("include_redundant_members"), pod.includeRedundantMembers); return jo; } @@ -24,6 +26,10 @@ RoomEventFilter FromJsonObject::operator()(const QJsonObject& j fromJson(jo.value("rooms"_ls)); result.containsUrl = fromJson(jo.value("contains_url"_ls)); + result.lazyLoadMembers = + fromJson(jo.value("lazy_load_members"_ls)); + result.includeRedundantMembers = + fromJson(jo.value("include_redundant_members"_ls)); return result; } diff --git a/lib/csapi/definitions/room_event_filter.h b/lib/csapi/definitions/room_event_filter.h index 697fe661..87f01189 100644 --- a/lib/csapi/definitions/room_event_filter.h +++ b/lib/csapi/definitions/room_event_filter.h @@ -21,6 +21,10 @@ namespace QMatrixClient QStringList rooms; /// If ``true``, includes only events with a ``url`` key in their content. If ``false``, excludes those events. Defaults to ``false``. bool containsUrl; + /// If ``true``, the only ``m.room.member`` events returned in the ``state`` section of the ``/sync`` response are those which are definitely necessary for a client to display the ``sender`` of the timeline events in that response. If ``false``, ``m.room.member`` events are not filtered. By default, servers should suppress duplicate redundant lazy-loaded ``m.room.member`` events from being sent to a given client across multiple calls to ``/sync``, given that most clients cache membership events (see include_redundant_members to change this behaviour). + bool lazyLoadMembers; + /// If ``true``, the ``state`` section of the ``/sync`` response will always contain the ``m.room.member`` events required to display the ``sender`` of the timeline events in that response, assuming ``lazy_load_members`` is enabled. This means that redundant duplicate member events may be returned across multiple calls to ``/sync``. This is useful for naive clients who never track membership data. If ``false``, duplicate ``m.room.member`` events may be suppressed by the server across multiple calls to ``/sync``. If ``lazy_load_members`` is ``false`` this field is ignored. + bool includeRedundantMembers; }; QJsonObject toJson(const RoomEventFilter& pod); diff --git a/lib/csapi/kicking.h b/lib/csapi/kicking.h index 5968187e..714079cf 100644 --- a/lib/csapi/kicking.h +++ b/lib/csapi/kicking.h @@ -29,7 +29,7 @@ namespace QMatrixClient * \param userId * The fully qualified user ID of the user being kicked. * \param reason - * The reason the user has been kicked. This will be supplied as the + * The reason the user has been kicked. This will be supplied as the * ``reason`` on the target's updated `m.room.member`_ event. */ explicit KickJob(const QString& roomId, const QString& userId, const QString& reason = {}); diff --git a/lib/csapi/read_markers.h b/lib/csapi/read_markers.h index f19f46b0..d982b477 100644 --- a/lib/csapi/read_markers.h +++ b/lib/csapi/read_markers.h @@ -26,7 +26,7 @@ namespace QMatrixClient * event MUST belong to the room. * \param mRead * The event ID to set the read receipt location at. This is - * equivalent to calling ``/receipt/m.read/$elsewhere:domain.com`` + * equivalent to calling ``/receipt/m.read/$elsewhere:example.org`` * and is provided here to save that extra call. */ explicit SetReadMarkerJob(const QString& roomId, const QString& mFullyRead, const QString& mRead = {}); diff --git a/lib/csapi/rooms.cpp b/lib/csapi/rooms.cpp index 3befeee5..cebb295a 100644 --- a/lib/csapi/rooms.cpp +++ b/lib/csapi/rooms.cpp @@ -46,12 +46,6 @@ BaseJob::Status GetOneRoomEventJob::parseJson(const QJsonDocument& data) return Success; } -class GetRoomStateWithKeyJob::Private -{ - public: - StateEventPtr data; -}; - QUrl GetRoomStateWithKeyJob::makeRequestUrl(QUrl baseUrl, const QString& roomId, const QString& eventType, const QString& stateKey) { return BaseJob::makeRequestUrl(std::move(baseUrl), @@ -63,29 +57,9 @@ static const auto GetRoomStateWithKeyJobName = QStringLiteral("GetRoomStateWithK GetRoomStateWithKeyJob::GetRoomStateWithKeyJob(const QString& roomId, const QString& eventType, const QString& stateKey) : BaseJob(HttpVerb::Get, GetRoomStateWithKeyJobName, basePath % "/rooms/" % roomId % "/state/" % eventType % "/" % stateKey) - , d(new Private) -{ -} - -GetRoomStateWithKeyJob::~GetRoomStateWithKeyJob() = default; - -StateEventPtr&& GetRoomStateWithKeyJob::data() { - return std::move(d->data); -} - -BaseJob::Status GetRoomStateWithKeyJob::parseJson(const QJsonDocument& data) -{ - d->data = fromJson(data); - return Success; } -class GetRoomStateByTypeJob::Private -{ - public: - StateEventPtr data; -}; - QUrl GetRoomStateByTypeJob::makeRequestUrl(QUrl baseUrl, const QString& roomId, const QString& eventType) { return BaseJob::makeRequestUrl(std::move(baseUrl), @@ -97,21 +71,7 @@ static const auto GetRoomStateByTypeJobName = QStringLiteral("GetRoomStateByType GetRoomStateByTypeJob::GetRoomStateByTypeJob(const QString& roomId, const QString& eventType) : BaseJob(HttpVerb::Get, GetRoomStateByTypeJobName, basePath % "/rooms/" % roomId % "/state/" % eventType) - , d(new Private) -{ -} - -GetRoomStateByTypeJob::~GetRoomStateByTypeJob() = default; - -StateEventPtr&& GetRoomStateByTypeJob::data() { - return std::move(d->data); -} - -BaseJob::Status GetRoomStateByTypeJob::parseJson(const QJsonDocument& data) -{ - d->data = fromJson(data); - return Success; } class GetRoomStateJob::Private diff --git a/lib/csapi/rooms.h b/lib/csapi/rooms.h index 2366918b..80895b4e 100644 --- a/lib/csapi/rooms.h +++ b/lib/csapi/rooms.h @@ -80,19 +80,6 @@ namespace QMatrixClient */ static QUrl makeRequestUrl(QUrl baseUrl, const QString& roomId, const QString& eventType, const QString& stateKey); - ~GetRoomStateWithKeyJob() override; - - // Result properties - - /// The content of the state event. - StateEventPtr&& data(); - - protected: - Status parseJson(const QJsonDocument& data) override; - - private: - class Private; - QScopedPointer d; }; /// Get the state identified by the type, with the empty state key. @@ -122,19 +109,6 @@ namespace QMatrixClient */ static QUrl makeRequestUrl(QUrl baseUrl, const QString& roomId, const QString& eventType); - ~GetRoomStateByTypeJob() override; - - // Result properties - - /// The content of the state event. - StateEventPtr&& data(); - - protected: - Status parseJson(const QJsonDocument& data) override; - - private: - class Private; - QScopedPointer d; }; /// Get all state events in the current state of a room. -- cgit v1.2.3 From c665883be52016be51f5b0a902e43885b024a8ac Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Thu, 6 Dec 2018 20:57:37 +0900 Subject: Connection: Avoid Omittable<>::operator bool It was accidentally (and incorrectly) used in tags sorting code; will be dropped from Omittable<> in a later commit. --- lib/connection.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/connection.cpp b/lib/connection.cpp index 9372acd5..26c33767 100644 --- a/lib/connection.cpp +++ b/lib/connection.cpp @@ -825,7 +825,7 @@ QHash> Connection::tagsToRooms() const for (auto it = result.begin(); it != result.end(); ++it) std::sort(it->begin(), it->end(), [t=it.key()] (Room* r1, Room* r2) { - return r1->tags().value(t).order < r2->tags().value(t).order; + return r1->tags().value(t) < r2->tags().value(t); }); return result; } -- cgit v1.2.3 From be4a16cd4188ebeeba60768deadd88de5cc5be7b Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Thu, 6 Dec 2018 21:23:07 +0900 Subject: function_traits<>: support any arity; add compile-time tests --- lib/util.cpp | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ lib/util.h | 68 ++++++++++++++++++++++++++++++++++++++++++------------------ 2 files changed, 112 insertions(+), 20 deletions(-) diff --git a/lib/util.cpp b/lib/util.cpp index af06013c..4c176fc7 100644 --- a/lib/util.cpp +++ b/lib/util.cpp @@ -75,3 +75,67 @@ QString QMatrixClient::cacheLocation(const QString& dirName) dir.mkpath(cachePath); return cachePath; } + +// Tests for function_traits<> + +#ifdef Q_CC_CLANG +#pragma clang diagnostic push +#pragma ide diagnostic ignored "OCSimplifyInspection" +#endif +using namespace QMatrixClient; + +int f(); +static_assert(std::is_same, int>::value, + "Test fn_return_t<>"); + +void f1(int); +static_assert(function_traits::arg_number == 1, + "Test fn_arg_number"); + +void f2(int, QString); +static_assert(std::is_same, QString>::value, + "Test fn_arg_t<>"); + +struct S { int mf(); }; +static_assert(is_callable_v, "Test member function"); +static_assert(returns(), "Test returns<> with member function"); + +struct Fo { void operator()(int); }; +static_assert(function_traits::arg_number == 1, "Test function object 1"); +static_assert(is_callable_v, "Test is_callable<>"); +static_assert(std::is_same, int>(), + "Test fn_arg_t defaulting to first argument"); + +static auto l = [] { return 1; }; +static_assert(is_callable_v, "Test is_callable_v<> with lambda"); +static_assert(std::is_same, int>::value, + "Test fn_return_t<> with lambda"); + +template +struct fn_object +{ + static int smf(double) { return 0; } +}; +template <> +struct fn_object +{ + void operator()(QString); +}; +static_assert(is_callable_v>, "Test function object"); +static_assert(returns>(), + "Test returns<> with function object"); +static_assert(!is_callable_v>, "Test non-function object"); +// FIXME: These two don't work +//static_assert(is_callable_v::smf)>, +// "Test static member function"); +//static_assert(returns::smf)>(), +// "Test returns<> with static member function"); + +template +QString ft(T&&); +static_assert(std::is_same)>, QString&&>(), + "Test function templates"); + +#ifdef Q_CC_CLANG +#pragma clang diagnostic pop +#endif diff --git a/lib/util.h b/lib/util.h index 88c756a1..3f5bcb5f 100644 --- a/lib/util.h +++ b/lib/util.h @@ -119,41 +119,69 @@ namespace QMatrixClient bool _omitted = false; }; + namespace _impl { + template struct fn_traits; + } + /** Determine traits of an arbitrary function/lambda/functor - * This only works with arity of 1 (1-argument) for now but is extendable - * to other cases. Also, doesn't work with generic lambdas and function - * objects that have operator() overloaded + * Doesn't work with generic lambdas and function objects that have + * operator() overloaded. * \sa https://stackoverflow.com/questions/7943525/is-it-possible-to-figure-out-the-parameter-type-and-return-type-of-a-lambda#7943765 */ template - struct function_traits : public function_traits - { }; // A generic function object that has (non-overloaded) operator() + struct function_traits : public _impl::fn_traits {}; // Specialisation for a function - template - struct function_traits + template + struct function_traits { + static constexpr auto is_callable = true; using return_type = ReturnT; - using arg_type = ArgT; + using arg_types = std::tuple; + static constexpr auto arg_number = std::tuple_size::value - 1; }; - // Specialisation for a member function - template - struct function_traits - : function_traits - { }; + namespace _impl { + template + struct fn_traits + { + static constexpr auto is_callable = false; + }; + + template + struct fn_traits + : public fn_traits + { }; // A generic function object that has (non-overloaded) operator() - // Specialisation for a const member function - template - struct function_traits - : function_traits - { }; + // Specialisation for a member function + template + struct fn_traits + : function_traits + { }; + + // Specialisation for a const member function + template + struct fn_traits + : function_traits + { }; + } // namespace _impl template using fn_return_t = typename function_traits::return_type; - template - using fn_arg_t = typename function_traits::arg_type; + template + using fn_arg_t = + std::tuple_element_t::arg_types>; + + template + constexpr bool returns() + { + return std::is_same, R>::value; + } + + // Poor-man's is_invokable + template + constexpr auto is_callable_v = function_traits::is_callable; inline auto operator"" _ls(const char* s, std::size_t size) { -- cgit v1.2.3 From 1de8d511251163ed35e0647c70c3e94e071b2fe0 Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Thu, 6 Dec 2018 19:12:28 +0900 Subject: Special-case FALLTHROUGH for Clang --- lib/util.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/util.h b/lib/util.h index 3f5bcb5f..6b5c89e6 100644 --- a/lib/util.h +++ b/lib/util.h @@ -31,6 +31,8 @@ #define FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define FALLTHROUGH [[clang::fallthrough]] +#elif __has_cpp_attribute(gnu::fallthrough) +#define FALLTHROUGH [[gnu::fallthrough]] #else #define FALLTHROUGH // -fallthrough #endif -- cgit v1.2.3 From 1414f3b5cc2bca3a3871bfe569510c1a422629fe Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Sat, 8 Dec 2018 15:24:45 +0900 Subject: RoomMemberEvent: cleanup Don't make JSON for event content only to parse it again; drop extraneous constructs. --- lib/events/roommemberevent.h | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/lib/events/roommemberevent.h b/lib/events/roommemberevent.h index db25d026..149d74f8 100644 --- a/lib/events/roommemberevent.h +++ b/lib/events/roommemberevent.h @@ -29,13 +29,10 @@ namespace QMatrixClient enum MembershipType : size_t { Invite = 0, Join, Knock, Leave, Ban, Undefined }; - explicit MemberEventContent(MembershipType mt = MembershipType::Join) + explicit MemberEventContent(MembershipType mt = Join) : membership(mt) { } explicit MemberEventContent(const QJsonObject& json); - explicit MemberEventContent(const QJsonValue& jv) - : MemberEventContent(jv.toObject()) - { } MembershipType membership; bool isDirect = false; @@ -60,7 +57,7 @@ namespace QMatrixClient : StateEvent(typeId(), obj) { } RoomMemberEvent(MemberEventContent&& c) - : StateEvent(typeId(), matrixTypeId(), c.toJson()) + : StateEvent(typeId(), matrixTypeId(), c) { } // This is a special constructor enabling RoomMemberEvent to be -- cgit v1.2.3 From ced7179117fd67cb1632f943f4ba1fde96423c0c Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Sat, 8 Dec 2018 15:26:35 +0900 Subject: StateEvent<>: make data members private Keeping them protected extends API surface with no reasonable use from it (and for now derived classes don't access StateEvent<> data members directly, anyway). --- lib/events/stateevent.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/events/stateevent.h b/lib/events/stateevent.h index d4a7e8b3..d82de7e1 100644 --- a/lib/events/stateevent.h +++ b/lib/events/stateevent.h @@ -95,7 +95,7 @@ namespace QMatrixClient { QString prevSenderId() const { return _prev ? _prev->senderId : QString(); } - protected: + private: ContentT _content; std::unique_ptr> _prev; }; -- cgit v1.2.3 From ed1f15151babee9ebc690ffa5c2593119540e8f0 Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Fri, 23 Nov 2018 19:18:51 +0900 Subject: Omittable: make operator-> and operator* return an empty object if omitted == true That is, instead of Q_ASSERTing in debug builds (release builds already work that way). The idea is that since the value is default-initialised anyway it can be used as a "blank canvas" to access specific fields inside the value's structure. The next commit will use that. --- lib/util.h | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/lib/util.h b/lib/util.h index 6b5c89e6..1028e059 100644 --- a/lib/util.h +++ b/lib/util.h @@ -88,17 +88,19 @@ namespace QMatrixClient static_assert(!std::is_reference::value, "You cannot make an Omittable<> with a reference type"); public: + using value_type = std::decay_t; + explicit Omittable() : Omittable(none) { } - Omittable(NoneTag) : _value(std::decay_t()), _omitted(true) { } - Omittable(const std::decay_t& val) : _value(val) { } - Omittable(std::decay_t&& val) : _value(std::move(val)) { } - Omittable& operator=(const std::decay_t& val) + Omittable(NoneTag) : _value(value_type()), _omitted(true) { } + Omittable(const value_type& val) : _value(val) { } + Omittable(value_type&& val) : _value(std::move(val)) { } + Omittable& operator=(const value_type& val) { _value = val; _omitted = false; return *this; } - Omittable& operator=(std::decay_t&& val) + Omittable& operator=(value_type&& val) { _value = std::move(val); _omitted = false; @@ -106,15 +108,15 @@ namespace QMatrixClient } bool omitted() const { return _omitted; } - const std::decay_t& value() const { Q_ASSERT(!_omitted); return _value; } - std::decay_t& value() { Q_ASSERT(!_omitted); return _value; } - std::decay_t&& release() { _omitted = true; return std::move(_value); } + const value_type& value() const { Q_ASSERT(!_omitted); return _value; } + value_type& value() { Q_ASSERT(!_omitted); return _value; } + value_type&& release() { _omitted = true; return std::move(_value); } operator bool() const { return !omitted(); } - const std::decay* operator->() const { return &value(); } - std::decay_t* operator->() { return &value(); } - const std::decay_t& operator*() const { return value(); } - std::decay_t& operator*() { return value(); } + const value_type* operator->() const { return &_value; } + value_type* operator->() { return &_value; } + const value_type& operator*() const { return _value; } + value_type& operator*() { return _value; } private: T _value; -- cgit v1.2.3 From 5ea115d6eb0b60dfd0c2be5fbe5e69615b133238 Mon Sep 17 00:00:00 2001 From: Kitsune Ral Date: Sat, 24 Nov 2018 11:58:43 +0900 Subject: Omittable: better editability; drop implicit cast to bool --- lib/util.h | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/lib/util.h b/lib/util.h index 1028e059..722a7e3d 100644 --- a/lib/util.h +++ b/lib/util.h @@ -108,15 +108,23 @@ namespace QMatrixClient } bool omitted() const { return _omitted; } - const value_type& value() const { Q_ASSERT(!_omitted); return _value; } - value_type& value() { Q_ASSERT(!_omitted); return _value; } + const value_type& value() const + { + Q_ASSERT(!_omitted); + return _value; + } + value_type& editValue() + { + _omitted = false; + return _value; + } value_type&& release() { _omitted = true; return std::move(_value); } - operator bool() const { return !omitted(); } - const value_type* operator->() const { return &_value; } - value_type* operator->() { return &_value; } - const value_type& operator*() const { return _value; } - value_type& operator*() { return _value; } + operator value_type&() & { return editValue(); } + const value_type* operator->() const & { return &value(); } + value_type* operator->() & { return &editValue(); } + const value_type& operator*() const & { return value(); } + value_type& operator*() & { return editValue(); } private: T _value; -- cgit v1.2.3