datastore.h

#ifndef QTDATASYNC_DATASTORE_H
#define QTDATASYNC_DATASTORE_H

#include <functional>

#include <QtCore/qobject.h>
#include <QtCore/qscopedpointer.h>
#include <QtCore/qvariant.h>

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

namespace QtDataSync {

class Defaults;

class DataStorePrivate;
class Q_DATASYNC_EXPORT DataStore : public QObject
{
    Q_OBJECT
    friend class DataStoreModel;

public:
    enum SearchMode
    {
        RegexpMode, 
        WildcardMode, 
        ContainsMode, 
        StartsWithMode, 
        EndsWithMode 
    };
    Q_ENUM(SearchMode)

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

    QString setupName() const;

    qint64 count(int metaTypeId) const;
    QStringList keys(int metaTypeId) const;
    QVariantList loadAll(int metaTypeId) const;
    bool contains(int metaTypeId, const QString &key) const;
    inline bool contains(int metaTypeId, const QVariant &key) const {
        return contains(metaTypeId, key.toString());
    }
    QVariant load(int metaTypeId, const QString &key) const;
    inline QVariant load(int metaTypeId, const QVariant &key) const {
        return load(metaTypeId, key.toString());
    }
    void save(int metaTypeId, QVariant value);
    bool remove(int metaTypeId, const QString &key);
    inline bool remove(int metaTypeId, const QVariant &key) {
        return remove(metaTypeId, key.toString());
    }
    void update(int metaTypeId, QObject *object) const;
    QVariantList search(int metaTypeId, const QString &query, SearchMode mode = RegexpMode) const;
    void iterate(int metaTypeId,
                 const std::function<bool(QVariant)> &iterator) const;
    void iterate(int metaTypeId,
                 const std::function<bool(QVariant)> &iterator,
                 bool skipBroken) const; //MAJOR merge overloads
    void clear(int metaTypeId);

    template<typename T>
    quint64 count() const;
    template<typename T>
    QStringList keys() const;
    template<typename T, typename K>
    QList<K> keys() const;
    template<typename T>
    QList<T> loadAll() const;
    template<typename T>
    bool contains(const QString &key) const;
    template<typename T, typename K>
    bool contains(const K &key) const;
    template<typename T>
    T load(const QString &key) const;
    template<typename T, typename K>
    T load(const K &key) const;
    template<typename T>
    void save(const T &value);
    template<typename T>
    bool remove(const QString &key);
    template<typename T, typename K>
    bool remove(const K &key);
    template<typename T>
    void update(T object) const;
    template<typename T>
    QList<T> search(const QString &query, SearchMode mode = RegexpMode) const;
    template<typename T>
    void iterate(const std::function<bool(T)> &iterator, bool skipBroken = false) const;
    template<typename T>
    void clear();

Q_SIGNALS:
    void dataChanged(int metaTypeId, const QString &key, bool deleted, QPrivateSignal);
    Q_DECL_DEPRECATED void dataCleared(int metaTypeId, QPrivateSignal);
    void dataResetted(QPrivateSignal);

protected:
    explicit DataStore(QObject *parent, void*);
    void initStore(const QString &setupName);

private:
    QScopedPointer<DataStorePrivate> d;
};



class Q_DATASYNC_EXPORT DataStoreException : public Exception
{
protected:
    DataStoreException(const Defaults &defaults, const QString &message);
    DataStoreException(const DataStoreException * const other);
};

class Q_DATASYNC_EXPORT LocalStoreException : public DataStoreException
{
public:
    LocalStoreException(const Defaults &defaults, const ObjectKey &key, const QString &context, const QString &message);

    ObjectKey key() const;
    QString context() const;

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

protected:
    LocalStoreException(const LocalStoreException * const other);

    ObjectKey _key;
    QString _context;
};

class Q_DATASYNC_EXPORT NoDataException : public DataStoreException
{
public:
    NoDataException(const Defaults &defaults, const ObjectKey &key);

    ObjectKey key() const;

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

protected:
    NoDataException(const NoDataException * const other);

    ObjectKey _key;
};

class Q_DATASYNC_EXPORT InvalidDataException : public DataStoreException
{
public:
    InvalidDataException(const Defaults &defaults, const QByteArray &typeName, const QString &message);

    QByteArray typeName() const;

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

protected:
    InvalidDataException(const InvalidDataException * const other);

    QByteArray _typeName;
};

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

template<typename T>
quint64 DataStore::count() const
{
    QTDATASYNC_STORE_ASSERT(T);
    return count(qMetaTypeId<T>());
}

template<typename T>
QStringList DataStore::keys() const
{
    QTDATASYNC_STORE_ASSERT(T);
    return keys(qMetaTypeId<T>());
}

template<typename T, typename K>
QList<K> DataStore::keys() const
{
    QTDATASYNC_STORE_ASSERT(T);
    QList<K> rList;
    for(auto k : keys<T>())
        rList.append(QVariant(k).template value<K>());
    return rList;
}

template<typename T>
QList<T> DataStore::loadAll() const
{
    QTDATASYNC_STORE_ASSERT(T);
    QList<T> rList;
    for(auto v : loadAll(qMetaTypeId<T>()))
        rList.append(v.template value<T>());
    return rList;
}

template<typename T>
bool DataStore::contains(const QString &key) const
{
    QTDATASYNC_STORE_ASSERT(T);
    return contains(qMetaTypeId<T>(), key);
}

template<typename T, typename K>
bool DataStore::contains(const K &key) const
{
    QTDATASYNC_STORE_ASSERT(T);
    return contains(qMetaTypeId<T>(), QVariant::fromValue(key));
}

template<typename T>
T DataStore::load(const QString &key) const
{
    QTDATASYNC_STORE_ASSERT(T);
    return load(qMetaTypeId<T>(), key).template value<T>();
}

template<typename T, typename K>
T DataStore::load(const K &key) const
{
    QTDATASYNC_STORE_ASSERT(T);
    return load(qMetaTypeId<T>(), QVariant::fromValue(key)).template value<T>();
}

template<typename T>
void DataStore::save(const T &value)
{
    QTDATASYNC_STORE_ASSERT(T);
    save(qMetaTypeId<T>(), QVariant::fromValue(value));
}

template<typename T>
bool DataStore::remove(const QString &key)
{
    QTDATASYNC_STORE_ASSERT(T);
    return remove(qMetaTypeId<T>(), key);
}

template<typename T, typename K>
bool DataStore::remove(const K &key)
{
    QTDATASYNC_STORE_ASSERT(T);
    return remove(qMetaTypeId<T>(), QVariant::fromValue(key));
}

template<typename T>
void DataStore::update(T object) const
{
    static_assert(__helpertypes::is_object<T>::value, "loadInto can only be used for pointers to QObject extending classes");
    update(qMetaTypeId<T>(), object);
}

template<typename T>
QList<T> DataStore::search(const QString &query, SearchMode mode) const
{
    QTDATASYNC_STORE_ASSERT(T);
    QList<T> rList;
    for(auto v : search(qMetaTypeId<T>(), query, mode))
        rList.append(v.template value<T>());
    return rList;
}

template<typename T>
void DataStore::iterate(const std::function<bool (T)> &iterator, bool skipBroken) const
{
    QTDATASYNC_STORE_ASSERT(T);
    iterate(qMetaTypeId<T>(), [iterator](const QVariant &v) {
        return iterator(v.template value<T>());
    }, skipBroken);
}

template<typename T>
void DataStore::clear()
{
    QTDATASYNC_STORE_ASSERT(T);
    clear(qMetaTypeId<T>());
}

}

#endif // QTDATASYNC_DATASTORE_H