datatypestore.h

#ifndef QTDATASYNC_DATATYPESTORE_H
#define QTDATASYNC_DATATYPESTORE_H

#include <type_traits>

#include <QtCore/qobject.h>
#include <QtCore/qdebug.h>

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

namespace QtDataSync {

class Q_DATASYNC_EXPORT DataTypeStoreBase : public QObject
{
    Q_OBJECT

public:
    explicit DataTypeStoreBase(QObject *parent = nullptr);

    virtual DataStore *store() const = 0;
    QString setupName() const;

Q_SIGNALS:
    void dataChanged(const QString &key, const QVariant &value);
    void dataResetted();
};

template <typename TType, typename TKey = QString>
class DataTypeStore : public DataTypeStoreBase
{
    QTDATASYNC_STORE_ASSERT(TType);

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

    DataStore *store() const override;

    qint64 count() const;
    QList<TKey> keys() const;
    QList<TType> loadAll() const;
    bool contains(const TKey &key) const;
    TType load(const TKey &key) const;
    void save(const TType &value);
    bool remove(const TKey &key);
    template <typename TX = TType>
    void update(std::enable_if_t<__helpertypes::is_object<TX>::value, TX> object) const;
    QList<TType> search(const QString &query, DataStore::SearchMode mode = DataStore::RegexpMode);
    void iterate(const std::function<bool(TType)> &iterator, bool skipBroken = false);
    void clear();

    static TKey toKey(const QString &key);

private:
    DataStore *_store;

    void evalDataChanged(int metaTypeId, const QString &key, bool wasDeleted);
};

template <typename TType, typename TKey = QString>
class CachingDataTypeStore : public DataTypeStoreBase
{
    static_assert(__helpertypes::is_gadget<TType>::value, "TType must be a Q_GADGET");

public:
    using const_iterator = typename QHash<TKey, TType>::const_iterator;
    using iterator = const_iterator;

    explicit CachingDataTypeStore(QObject *parent = nullptr);
    explicit CachingDataTypeStore(const QString &setupName, QObject *parent = nullptr);
    explicit CachingDataTypeStore(DataStore *store, QObject *parent = nullptr);

    DataStore *store() const override;

    qint64 count() const;
    QList<TKey> keys() const;
    bool contains(const TKey &key) const;
    QList<TType> loadAll() const;
    TType load(const TKey &key) const;
    void save(const TType &value);
    bool remove(const TKey &key);
    TType take(const TKey &key);
    void clear();

    const_iterator begin() const;
    const_iterator end() const;

    static TKey toKey(const QString &key);

private:
    DataStore *_store;
    QHash<TKey, TType> _data;

    void evalDataChanged(int metaTypeId, const QString &key, bool wasDeleted);
    void evalDataResetted();
};

template <typename TType, typename TKey>
class CachingDataTypeStore<TType*, TKey> : public DataTypeStoreBase
{
    static_assert(__helpertypes::is_object<TType*>::value, "TType must inherit QObject");

public:
    using const_iterator = typename QHash<TKey, TType*>::const_iterator;
    using iterator = const_iterator;

    explicit CachingDataTypeStore(QObject *parent = nullptr);
    explicit CachingDataTypeStore(const QString &setupName, QObject *parent = nullptr);
    explicit CachingDataTypeStore(DataStore *store, QObject *parent = nullptr);

    DataStore *store() const override;

    qint64 count() const;
    QList<TKey> keys() const;
    bool contains(const TKey &key) const;
    QList<TType*> loadAll() const;
    TType* load(const TKey &key) const;
    void save(TType *value);
    bool remove(const TKey &key);
    TType* take(const TKey &key);
    void clear();

    const_iterator begin() const;
    const_iterator end() const;

    static TKey toKey(const QString &key);

private:
    DataStore *_store;
    QHash<TKey, TType*> _data;

    void evalDataChanged(int metaTypeId, const QString &key, bool wasDeleted);
    void evalDataResetted();
};

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

template <typename TType, typename TKey>
DataTypeStore<TType, TKey>::DataTypeStore(QObject *parent) :
    DataTypeStore{DefaultSetup, parent}
{}

template <typename TType, typename TKey>
DataTypeStore<TType, TKey>::DataTypeStore(const QString &setupName, QObject *parent) :
    DataTypeStore{new DataStore(setupName, nullptr), parent}
{
    _store->setParent(this);
}

template <typename TType, typename TKey>
DataTypeStore<TType, TKey>::DataTypeStore(DataStore *store, QObject *parent) :
    DataTypeStoreBase{parent},
    _store{store}
{
    connect(_store, &DataStore::dataChanged,
            this, &DataTypeStore::evalDataChanged);
    connect(_store, &DataStore::dataResetted,
            this, &DataTypeStore::dataResetted);
}

template<typename TType, typename TKey>
DataStore *DataTypeStore<TType, TKey>::store() const
{
    return _store;
}

template <typename TType, typename TKey>
qint64 DataTypeStore<TType, TKey>::count() const
{
    return _store->count<TType>();
}

template <typename TType, typename TKey>
QList<TKey> DataTypeStore<TType, TKey>::keys() const
{
    return _store->keys<TType, TKey>();
}

template <typename TType, typename TKey>
QList<TType> DataTypeStore<TType, TKey>::loadAll() const
{
    return _store->loadAll<TType>();
}

template<typename TType, typename TKey>
bool DataTypeStore<TType, TKey>::contains(const TKey &key) const
{
    return _store->contains<TType>(key);
}

template <typename TType, typename TKey>
TType DataTypeStore<TType, TKey>::load(const TKey &key) const
{
    return _store->load<TType>(key);
}

template <typename TType, typename TKey>
void DataTypeStore<TType, TKey>::save(const TType &value)
{
    _store->save(value);
}

template <typename TType, typename TKey>
bool DataTypeStore<TType, TKey>::remove(const TKey &key)
{
    return _store->remove<TType>(key);
}

template<typename TType, typename TKey>
template <typename TX>
void DataTypeStore<TType, TKey>::update(std::enable_if_t<__helpertypes::is_object<TX>::value, TX> object) const
{
    _store->update<TType>(object);
}

template<typename TType, typename TKey>
QList<TType> DataTypeStore<TType, TKey>::search(const QString &query, DataStore::SearchMode mode)
{
    return _store->search<TType>(query, mode);
}

template<typename TType, typename TKey>
void DataTypeStore<TType, TKey>::iterate(const std::function<bool (TType)> &iterator, bool skipBroken)
{
    _store->iterate(iterator, skipBroken);
}

template<typename TType, typename TKey>
void DataTypeStore<TType, TKey>::clear()
{
    _store->clear<TType>();
}

template<typename TType, typename TKey>
TKey DataTypeStore<TType, TKey>::toKey(const QString &key)
{
    return QVariant(key).value<TKey>();
}

template <typename TType, typename TKey>
void DataTypeStore<TType, TKey>::evalDataChanged(int metaTypeId, const QString &key, bool wasDeleted)
{
    try {
        if(metaTypeId == qMetaTypeId<TType>()) {
            if(wasDeleted)
                emit dataChanged(key, QVariant());
            else
                emit dataChanged(key, QVariant::fromValue(_store->load<TType>(key)));
        }
    } catch(QException &e) {
        qWarning(QLoggingCategory{qUtf8Printable(QStringLiteral("qtdatasync.%1.DataTypeStore").arg(setupName()))})
                << "Failed to loaded changed data with error" << e.what();
    }
}

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

template <typename TType, typename TKey>
CachingDataTypeStore<TType, TKey>::CachingDataTypeStore(QObject *parent) :
    CachingDataTypeStore{DefaultSetup, parent}
{}

template <typename TType, typename TKey>
CachingDataTypeStore<TType, TKey>::CachingDataTypeStore(const QString &setupName, QObject *parent) :
    CachingDataTypeStore{new DataStore(setupName, nullptr), parent}
{
    _store->setParent(this);
}

template <typename TType, typename TKey>
CachingDataTypeStore<TType, TKey>::CachingDataTypeStore(DataStore *store, QObject *parent) :
    DataTypeStoreBase{parent},
    _store{store}
{
    connect(_store, &DataStore::dataChanged,
            this, &CachingDataTypeStore::evalDataChanged);
    connect(_store, &DataStore::dataResetted,
            this, &CachingDataTypeStore::evalDataResetted);

    auto userProp = TType::staticMetaObject.userProperty();
    store->iterate<TType>([&](const TType &data){
        _data.insert(userProp.readOnGadget(&data).template value<TKey>(), data);
        return true;
    }, true);
}

template<typename TType, typename TKey>
DataStore *CachingDataTypeStore<TType, TKey>::store() const
{
    return _store;
}

template <typename TType, typename TKey>
qint64 CachingDataTypeStore<TType, TKey>::count() const
{
    return _data.size();
}

template <typename TType, typename TKey>
QList<TKey> CachingDataTypeStore<TType, TKey>::keys() const
{
    return _data.keys();
}

template<typename TType, typename TKey>
bool CachingDataTypeStore<TType, TKey>::contains(const TKey &key) const
{
    return _data.contains(key);
}

template <typename TType, typename TKey>
QList<TType> CachingDataTypeStore<TType, TKey>::loadAll() const
{
    return _data.values();
}

template <typename TType, typename TKey>
TType CachingDataTypeStore<TType, TKey>::load(const TKey &key) const
{
    return _data.value(key);
}

template <typename TType, typename TKey>
void CachingDataTypeStore<TType, TKey>::save(const TType &value)
{
    _store->save(value);
}

template <typename TType, typename TKey>
bool CachingDataTypeStore<TType, TKey>::remove(const TKey &key)
{
    return _store->remove<TType>(QVariant::fromValue(key).toString());
}

template<typename TType, typename TKey>
TType CachingDataTypeStore<TType, TKey>::take(const TKey &key)
{
    auto mData = _data.value(key);
    if(_store->remove<TType>(QVariant::fromValue(key).toString()))
        return mData;
    else
        return {};
}

template<typename TType, typename TKey>
void CachingDataTypeStore<TType, TKey>::clear()
{
    _store->clear<TType>();
}

template<typename TType, typename TKey>
typename CachingDataTypeStore<TType, TKey>::const_iterator CachingDataTypeStore<TType, TKey>::begin() const
{
    return _data.constBegin();
}

template<typename TType, typename TKey>
typename CachingDataTypeStore<TType, TKey>::const_iterator CachingDataTypeStore<TType, TKey>::end() const
{
    return _data.constEnd();
}

template<typename TType, typename TKey>
TKey CachingDataTypeStore<TType, TKey>::toKey(const QString &key)
{
    return QVariant(key).value<TKey>();
}

template <typename TType, typename TKey>
void CachingDataTypeStore<TType, TKey>::evalDataChanged(int metaTypeId, const QString &key, bool wasDeleted)
{
    try {
        if(metaTypeId == qMetaTypeId<TType>()) {
            auto rKey = toKey(key);
            if(wasDeleted) {
                _data.remove(rKey);
                emit dataChanged(key, QVariant());
            } else {
                auto data = _store->load<TType>(key);
                _data.insert(rKey, data);
                emit dataChanged(key, QVariant::fromValue(data));
            }
        }
    } catch(QException &e) {
        qWarning(QLoggingCategory{qUtf8Printable(QStringLiteral("qtdatasync.%1.CachingDataTypeStore").arg(setupName()))})
                << "Failed to loaded changed data with error" << e.what();
    }
}

template <typename TType, typename TKey>
void CachingDataTypeStore<TType, TKey>::evalDataResetted()
{
    _data.clear();
    emit dataResetted();
}

// ------------- GENERIC IMPLEMENTATION CachingDataTypeStore<TType*, TKey> -------------

template <typename TType, typename TKey>
CachingDataTypeStore<TType*, TKey>::CachingDataTypeStore(QObject *parent) :
    CachingDataTypeStore{DefaultSetup, parent}
{}

template <typename TType, typename TKey>
CachingDataTypeStore<TType*, TKey>::CachingDataTypeStore(const QString &setupName, QObject *parent) :
    CachingDataTypeStore{new DataStore(setupName, nullptr), parent}
{
    _store->setParent(this);
}

template <typename TType, typename TKey>
CachingDataTypeStore<TType*, TKey>::CachingDataTypeStore(DataStore *store, QObject *parent) :
    DataTypeStoreBase{parent},
    _store{store}

{
    connect(_store, &DataStore::dataChanged,
            this, &CachingDataTypeStore::evalDataChanged);
    connect(_store, &DataStore::dataResetted,
            this, &CachingDataTypeStore::evalDataResetted);

    auto userProp = TType::staticMetaObject.userProperty();
    store->iterate<TType*>([&](TType *data){
        data->setParent(this);
        _data.insert(userProp.read(data).template value<TKey>(), data);
        return true;
    }, true);
}

template<typename TType, typename TKey>
DataStore *CachingDataTypeStore<TType*, TKey>::store() const
{
    return _store;
}

template <typename TType, typename TKey>
qint64 CachingDataTypeStore<TType*, TKey>::count() const
{
    return _data.size();
}

template <typename TType, typename TKey>
QList<TKey> CachingDataTypeStore<TType*, TKey>::keys() const
{
    return _data.keys();
}

template<typename TType, typename TKey>
bool CachingDataTypeStore<TType *, TKey>::contains(const TKey &key) const
{
    return _data.contains(key);
}

template <typename TType, typename TKey>
QList<TType*> CachingDataTypeStore<TType*, TKey>::loadAll() const
{
    return _data.values();
}

template <typename TType, typename TKey>
TType *CachingDataTypeStore<TType*, TKey>::load(const TKey &key) const
{
    return _data.value(key);
}

template <typename TType, typename TKey>
void CachingDataTypeStore<TType*, TKey>::save(TType *value)
{
    _store->save(value);
}

template <typename TType, typename TKey>
bool CachingDataTypeStore<TType*, TKey>::remove(const TKey &key)
{
    return _store->remove<TType*>(key);
}

template<typename TType, typename TKey>
TType* CachingDataTypeStore<TType*, TKey>::take(const TKey &key)
{
    auto mData = _data.take(key);
    try {
        if(!_store->remove<TType*>(QVariant::fromValue(key).toString()))
            return nullptr;
    } catch(...) {
        _data.insert(key, mData);
        throw;
    }
    mData->setParent(nullptr);
    emit dataChanged(QVariant(key).toString(), QVariant());//manual emit required, because not happening in change signal because removed before
    return mData;
}

template<typename TType, typename TKey>
void CachingDataTypeStore<TType*, TKey>::clear()
{
    _store->clear<TType*>();
}

template<typename TType, typename TKey>
typename CachingDataTypeStore<TType*, TKey>::const_iterator CachingDataTypeStore<TType*, TKey>::begin() const
{
    return _data.constBegin();
}

template<typename TType, typename TKey>
typename CachingDataTypeStore<TType*, TKey>::const_iterator CachingDataTypeStore<TType*, TKey>::end() const
{
    return _data.constEnd();
}

template<typename TType, typename TKey>
TKey CachingDataTypeStore<TType*, TKey>::toKey(const QString &key)
{
    return QVariant(key).value<TKey>();
}

template <typename TType, typename TKey>
void CachingDataTypeStore<TType*, TKey>::evalDataChanged(int metaTypeId, const QString &key, bool wasDeleted)
{
    try {
        if(metaTypeId == qMetaTypeId<TType*>()) {
            auto rKey = toKey(key);
            if(wasDeleted) {
                auto data = _data.take(rKey);
                if(data) {
                    emit dataChanged(key, QVariant());
                    data->deleteLater();
                }
            } else {
                if(_data.contains(rKey)) {
                    _store->update(_data.value(rKey));
                    emit dataChanged(key, QVariant::fromValue(_data.value(rKey)));
                } else {
                    auto data = _store->load<TType*>(key);
                    auto oldData = _data.take(rKey);
                    data->setParent(this);
                    _data.insert(rKey, data);
                    emit dataChanged(key, QVariant::fromValue(data));
                    if(oldData)
                        oldData->deleteLater();
                }
            }
        }
    } catch(QException &e) {
        qWarning(QLoggingCategory{qUtf8Printable(QStringLiteral("qtdatasync.%1.CachingDataTypeStore").arg(setupName()))})
                << "Failed to loaded changed data with error" << e.what();
    }
}

template <typename TType, typename TKey>
void CachingDataTypeStore<TType*, TKey>::evalDataResetted()
{
    auto data = _data;
    _data.clear();
    emit dataResetted();
    for(auto d : data)
        d->deleteLater();
}

}

#endif // QTDATASYNC_DATATYPESTORE_H