datastoremodel.h

#ifndef QTDATASYNC_DATASTOREMODEL_H
#define QTDATASYNC_DATASTOREMODEL_H

#include <QtCore/qabstractitemmodel.h>

#include "QtDataSync/qtdatasync_global.h"
#include "QtDataSync/datastore.h"

namespace QtDataSync {

class DataStoreModelPrivate;
class Q_DATASYNC_EXPORT DataStoreModel : public QAbstractTableModel
{
    Q_OBJECT
    friend class DataStoreModelPrivate;

    Q_PROPERTY(int typeId READ typeId WRITE setTypeId NOTIFY typeIdChanged)
    Q_PROPERTY(bool editable READ isEditable WRITE setEditable NOTIFY editableChanged)

public:
    explicit DataStoreModel(QObject *parent = nullptr);
    explicit DataStoreModel(const QString &setupName, QObject *parent = nullptr);
    explicit DataStoreModel(DataStore *store, QObject *parent = nullptr);
    ~DataStoreModel() override;

    DataStore *store() const;
    QString setupName() const;

    int typeId() const;
    template <typename T>
    inline void setTypeId(bool resetColumns = true);
    bool isEditable() const;

    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent) const override;
    bool canFetchMore(const QModelIndex &parent) const override;
    void fetchMore(const QModelIndex &parent) override;

    QModelIndex index(int row, int column = 0, const QModelIndex &parent = QModelIndex()) const override;
    Q_INVOKABLE QModelIndex idIndex(const QString &id) const;
    template <typename T>
    inline QModelIndex idIndex(const T &id) const;

    Q_INVOKABLE QString key(const QModelIndex &index) const;
    template <typename T>
    inline T key(const QModelIndex &index) const;

    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    bool setData(const QModelIndex &index, const QVariant &value, int role) override;

    Q_INVOKABLE QVariant object(const QModelIndex &index) const;
    template <typename T>
    inline T object(const QModelIndex &index) const;
    Q_INVOKABLE QVariant loadObject(const QModelIndex &index) const;
    template <typename T>
    T loadObject(const QModelIndex &index) const;

    Qt::ItemFlags flags(const QModelIndex &index) const override;
    QHash<int, QByteArray> roleNames() const override;

    int addColumn(const QString &text);
    int addColumn(const QString &text, const char *propertyName);
    void addRole(int column, int role, const char *propertyName);
    void clearColumns();

public Q_SLOTS:
    void setTypeId(int typeId); //MAJOR merge methods
    void setTypeId(int typeId, bool resetColumns);
    void setEditable(bool editable);

    void reload();

Q_SIGNALS:
    void storeError(const QException &exception, QPrivateSignal);
    void typeIdChanged(int typeId, QPrivateSignal);
    void editableChanged(bool editable, QPrivateSignal);

protected:
    explicit DataStoreModel(QObject *parent, void*);
    void initStore(DataStore *store);

private Q_SLOTS:
    void storeChanged(int metaTypeId, const QString &key, bool wasDeleted);
    void storeResetted();

private:
    QScopedPointer<DataStoreModelPrivate> d;
};

// ------------- Generic Implementation -------------

template <typename T>
inline void DataStoreModel::setTypeId(bool resetColumns) {
    QTDATASYNC_STORE_ASSERT(T);
    setTypeId(qMetaTypeId<T>(), resetColumns);
}

template <typename T>
inline QModelIndex DataStoreModel::idIndex(const T &id) const {
    return idIndex(QVariant::fromValue<T>(id).toString());
}

template <typename T>
inline T DataStoreModel::key(const QModelIndex &index) const {
    return QVariant(key(index)).value<T>();
}

template <typename T>
inline T DataStoreModel::object(const QModelIndex &index) const {
    QTDATASYNC_STORE_ASSERT(T);
    Q_ASSERT_X(qMetaTypeId<T>() == typeId(), Q_FUNC_INFO, "object must be used with the stores typeId");
    return object(index).value<T>();
}

template <typename T>
T DataStoreModel::loadObject(const QModelIndex &index) const {
    QTDATASYNC_STORE_ASSERT(T);
    Q_ASSERT_X(qMetaTypeId<T>() == typeId(), Q_FUNC_INFO, "object must be used with the stores typeId");
    return loadObject(index).value<T>();
}

}

#endif // QTDATASYNC_DATASTOREMODEL_H