Move source files to a separate folder

It's been long overdue to separate them from the rest of the stuff (docs etc.). Also, this allows installing to a directory within the checked out git tree (say, ./install/, similar to ./build/).

1 files changed, 0 insertions, 314 deletions

diff --git a/events/event.h b/events/event.h
deleted file mode 100644
index eccfec41..00000000
--- a/events/event.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/******************************************************************************
- * Copyright (C) 2015 Felix Rohrbach <kde@fxrh.de>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * 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
- */
-
-#pragma once
-
-#include <QtCore/QString>
-#include <QtCore/QDateTime>
-#include <QtCore/QJsonObject>
-#include <QtCore/QJsonArray>
-
-#include "util.h"
-
-#include <memory>
-
-namespace QMatrixClient
-{
-    template <typename EventT>
-    using event_ptr_tt = std::unique_ptr<EventT>;
-
-    namespace _impl
-    {
-        template <typename EventT>
-        event_ptr_tt<EventT> doMakeEvent(const QJsonObject& obj);
-    }
-
-    class Event
-    {
-            Q_GADGET
-        public:
-            enum class Type : quint16
-            {
-                Unknown = 0,
-                Typing, Receipt, Tag, DirectChat, ReadMarker,
-                RoomEventBase = 0x1000,
-                RoomMessage = RoomEventBase + 1,
-                RoomEncryptedMessage, Redaction,
-                RoomStateEventBase = 0x1800,
-                RoomName = RoomStateEventBase + 1,
-                RoomAliases, RoomCanonicalAlias, RoomMember, RoomTopic,
-                RoomAvatar, RoomEncryption, RoomCreate, RoomJoinRules,
-                RoomPowerLevels,
-                Reserved = 0x2000
-            };
-
-            explicit Event(Type type) : _type(type) { }
-            Event(Type type, const QJsonObject& rep);
-            Event(const Event&) = delete;
-            virtual ~Event();
-
-            Type type() const { return _type; }
-            QString jsonType() const;
-            bool isStateEvent() const
-            {
-                return (quint16(_type) & 0x1800) == 0x1800;
-            }
-            QByteArray originalJson() const;
-            QJsonObject originalJsonObject() const;
-
-            // According to the CS API spec, every event also has
-            // a "content" object; but since its structure is different for
-            // different types, we're implementing it per-event type
-            // (and in most cases it will be a combination of other fields
-            // instead of "content" field).
-
-            const QJsonObject contentJson() const;
-
-        private:
-            Type _type;
-            QJsonObject _originalJson;
-
-            REGISTER_ENUM(Type)
-            Q_PROPERTY(Type type READ type CONSTANT)
-            Q_PROPERTY(QJsonObject contentJson READ contentJson CONSTANT)
-    };
-    using EventType = Event::Type;
-    using EventPtr = event_ptr_tt<Event>;
-
-    /** Create an event with proper type from a JSON object
-     * Use this factory template to detect the type from the JSON object
-     * contents (the detected event type should derive from the template
-     * parameter type) and create an event object of that type.
-     */
-    template <typename EventT>
-    event_ptr_tt<EventT> makeEvent(const QJsonObject& obj)
-    {
-        auto e = _impl::doMakeEvent<EventT>(obj);
-        if (!e)
-            e = std::make_unique<EventT>(EventType::Unknown, obj);
-        return e;
-    }
-
-    namespace _impl
-    {
-        template <>
-        EventPtr doMakeEvent<Event>(const QJsonObject& obj);
-    }
-
-    /**
-     * \brief A vector of pointers to events with deserialisation capabilities
-     *
-     * This is a simple wrapper over a generic vector type that adds
-     * a convenience method to deserialise events from QJsonArray.
-     * \tparam EventT base type of all events in the vector
-     */
-    template <typename EventT>
-    class EventsBatch : public std::vector<event_ptr_tt<EventT>>
-    {
-        public:
-            /**
-             * \brief Deserialise events from an array
-             *
-             * Given the following JSON construct, creates events from
-             * the array stored at key "node":
-             * \code
-             * "container": {
-             *     "node": [ { "event_id": "!evt1:srv.org", ... }, ... ]
-             * }
-             * \endcode
-             * \param container - the wrapping JSON object
-             * \param node - the key in container that holds the array of events
-             */
-            void fromJson(const QJsonObject& container, const QString& node)
-            {
-                const auto objs = container.value(node).toArray();
-                using size_type = typename std::vector<event_ptr_tt<EventT>>::size_type;
-                // The below line accommodates the difference in size types of
-                // STL and Qt containers.
-                this->reserve(static_cast<size_type>(objs.size()));
-                for (auto objValue: objs)
-                    this->emplace_back(makeEvent<EventT>(objValue.toObject()));
-            }
-    };
-    using Events = EventsBatch<Event>;
-
-    class RedactionEvent;
-
-    /** This class corresponds to m.room.* events */
-    class RoomEvent : public Event
-    {
-            Q_GADGET
-            Q_PROPERTY(QString id READ id)
-            Q_PROPERTY(QDateTime timestamp READ timestamp CONSTANT)
-            Q_PROPERTY(QString roomId READ roomId CONSTANT)
-            Q_PROPERTY(QString senderId READ senderId CONSTANT)
-            Q_PROPERTY(QString redactionReason READ redactionReason)
-            Q_PROPERTY(bool isRedacted READ isRedacted)
-            Q_PROPERTY(QString transactionId READ transactionId)
-        public:
-            // RedactionEvent is an incomplete type here so we cannot inline
-            // constructors and destructors
-            explicit RoomEvent(Type type);
-            RoomEvent(Type type, const QJsonObject& rep);
-            ~RoomEvent();
-
-            QString id() const { return _id; }
-            QDateTime timestamp() const;
-            QString roomId() const;
-            QString senderId() const;
-            bool isRedacted() const { return bool(_redactedBecause); }
-            const RedactionEvent* redactedBecause() const
-            {
-                return _redactedBecause.get();
-            }
-            QString redactionReason() const;
-            const QString& transactionId() const { return _txnId; }
-
-            /**
-             * Sets the transaction id for locally created events. This should be
-             * done before the event is exposed to any code using the respective
-             * Q_PROPERTY.
-             *
-             * \param txnId - transaction id, normally obtained from
-             * Connection::generateTxnId()
-             */
-            void setTransactionId(const QString& txnId) { _txnId = txnId; }
-
-            /**
-             * Sets event id for locally created events
-             *
-             * When a new event is created locally, it has no server id yet.
-             * This function allows to add the id once the confirmation from
-             * the server is received. There should be no id set previously
-             * in the event. It's the responsibility of the code calling addId()
-             * to notify clients that use Q_PROPERTY(id) about its change
-             */
-            void addId(const QString& id);
-
-        private:
-            QString _id;
-//            QString _roomId;
-//            QString _senderId;
-//            QDateTime _serverTimestamp;
-            event_ptr_tt<RedactionEvent> _redactedBecause;
-            QString _txnId;
-    };
-    using RoomEvents = EventsBatch<RoomEvent>;
-    using RoomEventPtr = event_ptr_tt<RoomEvent>;
-
-    namespace _impl
-    {
-        template <>
-        RoomEventPtr doMakeEvent<RoomEvent>(const QJsonObject& obj);
-    }
-
-    /**
-     * Conceptually similar to QStringView (but much more primitive), it's a
-     * simple abstraction over a pair of RoomEvents::const_iterator values
-     * referring to the beginning and the end of a range in a RoomEvents
-     * container.
-     */
-    struct RoomEventsRange
-    {
-        RoomEvents::iterator from;
-        RoomEvents::iterator to;
-
-        RoomEvents::size_type size() const
-        {
-            Q_ASSERT(std::distance(from, to) >= 0);
-            return RoomEvents::size_type(std::distance(from, to));
-        }
-        bool empty() const { return from == to; }
-        RoomEvents::const_iterator begin() const { return from; }
-        RoomEvents::const_iterator end() const { return to; }
-        RoomEvents::iterator begin() { return from; }
-        RoomEvents::iterator end() { return to; }
-    };
-
-    class StateEventBase: public RoomEvent
-    {
-        public:
-            explicit StateEventBase(Type type, const QJsonObject& obj)
-                : RoomEvent(obj.contains("state_key") ? type : Type::Unknown,
-                            obj)
-            { }
-            explicit StateEventBase(Type type)
-                : RoomEvent(type)
-            { }
-            ~StateEventBase() override = 0;
-
-            virtual bool repeatsState() const;
-    };
-
-    template <typename ContentT>
-    struct Prev
-    {
-        template <typename... ContentParamTs>
-        explicit Prev(const QJsonObject& unsignedJson,
-                      ContentParamTs&&... contentParams)
-            : senderId(unsignedJson.value("prev_sender").toString())
-            , content(unsignedJson.value("prev_content").toObject(),
-                       std::forward<ContentParamTs>(contentParams)...)
-        { }
-
-        QString senderId;
-        ContentT content;
-    };
-
-    template <typename ContentT>
-    class StateEvent: public StateEventBase
-    {
-        public:
-            using content_type = ContentT;
-
-            template <typename... ContentParamTs>
-            explicit StateEvent(Type type, const QJsonObject& obj,
-                                ContentParamTs&&... contentParams)
-                : StateEventBase(type, obj)
-                , _content(contentJson(),
-                           std::forward<ContentParamTs>(contentParams)...)
-            {
-                auto unsignedData = obj.value("unsigned").toObject();
-                if (unsignedData.contains("prev_content"))
-                    _prev = std::make_unique<Prev<ContentT>>(unsignedData,
-                        std::forward<ContentParamTs>(contentParams)...);
-            }
-            template <typename... ContentParamTs>
-            explicit StateEvent(Type type, ContentParamTs&&... contentParams)
-                : StateEventBase(type)
-                , _content(std::forward<ContentParamTs>(contentParams)...)
-            { }
-
-            QJsonObject toJson() const { return _content.toJson(); }
-
-            const ContentT& content() const { return _content; }
-            /** @deprecated Use prevContent instead */
-            const ContentT* prev_content() const { return prevContent(); }
-            const ContentT* prevContent() const
-            { return _prev ? &_prev->content : nullptr; }
-            QString prevSenderId() const { return _prev ? _prev->senderId : ""; }
-
-        protected:
-            ContentT _content;
-            std::unique_ptr<Prev<ContentT>> _prev;
-    };
-}  // namespace QMatrixClient
-Q_DECLARE_METATYPE(QMatrixClient::Event*)
-Q_DECLARE_METATYPE(QMatrixClient::RoomEvent*)
-Q_DECLARE_METATYPE(const QMatrixClient::Event*)
-Q_DECLARE_METATYPE(const QMatrixClient::RoomEvent*)