eventcursor.h

#ifndef QTDATASYNC_EVENTCURSOR_H
#define QTDATASYNC_EVENTCURSOR_H

#include <functional>

#include <QtCore/qobject.h>
#include <QtCore/qscopedpointer.h>
#include <QtCore/qdatetime.h>
#include <QtCore/qbytearray.h>

#include "QtDataSync/qtdatasync_global.h"
#include "QtDataSync/objectkey.h"
#include "QtDataSync/exception.h"

namespace QtDataSync {

class EventCursorPrivate;
class Q_DATASYNC_EXPORT EventCursor : public QObject
{
    Q_OBJECT

    Q_PROPERTY(bool valid READ isValid CONSTANT)
    Q_PROPERTY(QString setupName READ setupName CONSTANT)

    Q_PROPERTY(quint64 index READ index NOTIFY indexChanged USER true)
    Q_PROPERTY(QtDataSync::ObjectKey key READ key NOTIFY keyChanged)
    Q_PROPERTY(bool wasRemoved READ wasRemoved NOTIFY wasRemovedChanged)
    Q_PROPERTY(QDateTime timestamp READ timestamp NOTIFY timestampChanged)

    Q_PROPERTY(bool skipObsolete READ skipObsolete WRITE setSkipObsolete NOTIFY skipObsoleteChanged)

public:
    ~EventCursor() override;

    static bool isEventLogActive(const QString &setupName = DefaultSetup);

    static EventCursor *first(QObject *parent = nullptr);
    static EventCursor *first(const QString &setupName, QObject *parent = nullptr);
    static EventCursor *last(QObject *parent = nullptr);
    static EventCursor *last(const QString &setupName, QObject *parent = nullptr);
    static EventCursor *create(quint64 index, QObject *parent = nullptr);
    static EventCursor *create(quint64 index, const QString &setupName, QObject *parent = nullptr);
    static EventCursor *load(const QByteArray &data, QObject *parent = nullptr);
    static EventCursor *load(const QByteArray &data, const QString &setupName, QObject *parent = nullptr);
    Q_INVOKABLE QByteArray save() const;

    bool isValid() const;
    QString setupName() const;

    quint64 index() const;
    QtDataSync::ObjectKey key() const;
    bool wasRemoved() const;
    QDateTime timestamp() const;

    bool skipObsolete() const;

    Q_INVOKABLE bool hasNext() const;
    Q_INVOKABLE bool next();

    Q_INVOKABLE void autoScanLog();
    void autoScanLog(std::function<bool(const EventCursor *)> function, bool scanCurrent = true);
    void autoScanLog(QObject *scope, std::function<bool(const EventCursor *)> function, bool scanCurrent = true);
    template <typename TClass>
    void autoScanLog(TClass *scope, bool(TClass::* function)(const EventCursor *), bool scanCurrent = true);

public Q_SLOTS:
    void setSkipObsolete(bool skipObsolete);

    void clearEventLog(quint64 offset = 0);

Q_SIGNALS:
    void eventLogChanged(QPrivateSignal);

    void indexChanged(quint64 index, QPrivateSignal);
    void keyChanged(const QtDataSync::ObjectKey &key, QPrivateSignal);
    void wasRemovedChanged(bool wasRemoved, QPrivateSignal);
    void timestampChanged(const QDateTime &timestamp, QPrivateSignal);
    void skipObsoleteChanged(bool skipObsolete, QPrivateSignal);

private:
    friend class QtDataSync::EventCursorPrivate;
    QScopedPointer<EventCursorPrivate> d;

    explicit EventCursor(const QString &setupName, QObject *parent = nullptr);
};

class Q_DATASYNC_EXPORT EventCursorException : public Exception
{
public:
    EventCursorException(const Defaults &defaults,
                         quint64 index,
                         QString context,
                         const QString &message);

    quint64 index() const;
    QString context() const;

    QByteArray className() const noexcept override;
    QString qWhat() const override;
    void raise() const override;
    QException *clone() const override;

protected:
    EventCursorException(const EventCursorException * const other);

    quint64 _index;
    QString _context;
};

// ------------- GENERIC IMPLEMENTATION -------------


template<typename TClass>
void EventCursor::autoScanLog(TClass *scope, bool (TClass::*function)(const EventCursor *), bool scanCurrent)
{
    static_assert(std::is_base_of<QObject, TClass>::value, "TClass must extend QObject");
    autoScanLog(scope, [scope, function](const EventCursor *cursor) -> bool {
        return (scope->*function)(cursor);
    }, scanCurrent);
}

}

#endif // QTDATASYNC_EVENTCURSOR_H