settingsentry.h

#ifndef QTMVVM_SETTINGSENTRY_H
#define QTMVVM_SETTINGSENTRY_H

#include <functional>

#include <QtCore/qlist.h>
#include <QtCore/qregularexpression.h>
#include <QtCore/qhash.h>
#include <QtCore/qsharedpointer.h>

#include "QtMvvmCore/qtmvvmcore_global.h"
#include "QtMvvmCore/isettingsaccessor.h"

namespace QtMvvm {

template <typename T>
class SettingsEntry
{
    Q_DISABLE_COPY(SettingsEntry)

public:
    SettingsEntry() = default;

    bool isSet() const;
    QString key() const;

    T get() const;
    void set(const T &value);
    void reset();

    SettingsEntry<T> &operator=(const T &value);
    operator T() const;

    void addChangeCallback(const std::function<void(T)> &callback);
    void addChangeCallback(QObject *scope, const std::function<void(T)> &callback);

    void setup(QString key, ISettingsAccessor *accessor, QVariant defaultValue = {});

private:
    QString _key;
    ISettingsAccessor *_accessor = nullptr;
    QVariant _default;
};

template <>
class SettingsEntry<void>
{
    Q_DISABLE_COPY(SettingsEntry)

public:
    inline SettingsEntry() = default;

    inline void setup(const QString &, ISettingsAccessor *, const QVariant & = {}) {}
};

template <typename TType>
class SettingsListNode
{
    Q_DISABLE_COPY(SettingsListNode)

public:
    class Deferred
    {
        Q_DISABLE_COPY(Deferred)

    public:
        inline Deferred(Deferred &&other) noexcept = default;
        inline Deferred &operator=(Deferred &&other) noexcept = default;
        inline ~Deferred() { commit(); }

        inline TType &element() { return _element; }

        inline TType &operator*() { return _element; }
        inline TType *operator->() { return &_element; }

        inline void commit() { if(!_commited) { _commited = true; _node->commit(_index);} }

    private:
        friend class SettingsListNode<TType>;

        SettingsListNode<TType> *_node;
        TType &_element;
        bool _commited = false;
        int _index;

        inline Deferred(SettingsListNode<TType> *node, TType &element, int index) :
            _node{node},
            _element{element},
            _index{index}
        {}
    };

    template <typename T>
    class iterator_base
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using difference_type = int;
        using value_type = T;
        using pointer = value_type*;
        using reference = value_type&;

        inline iterator_base() = default;
        inline iterator_base(const iterator_base<T> &other) = default;
        inline iterator_base &operator=(const iterator_base<T> &other) = default;
        inline iterator_base(iterator_base<T> &&other) noexcept = default;
        inline iterator_base &operator=(iterator_base<T> &&other) noexcept = default;

        inline iterator_base<T> &operator++() { ++_index; return *this; }
        inline iterator_base<T> operator++(int) { return iterator_base<T>{_node, _index++}; }
        inline iterator_base<T> &operator--() { --_index; return *this; }
        inline iterator_base<T> operator--(int) { return iterator_base<T>{_node, _index--}; }

        inline reference operator*() const { return _node->at(_index); }
        inline pointer operator->() const { return &_node->at(_index); }
        inline friend void swap(iterator_base<T> &lhs, iterator_base<T> &rhs) noexcept { std::swap(lhs._node, rhs._node); std::swap(lhs._index, rhs._index); }

        inline friend bool operator==(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index == rhs._index; }
        inline friend bool operator!=(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index != rhs._index; }
        inline friend bool operator<(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index < rhs._index; }
        inline friend bool operator>(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index > rhs._index; }
        inline friend bool operator<=(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index <= rhs._index; }
        inline friend bool operator>=(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index >= rhs._index; }

        inline iterator_base<T> &operator+=(difference_type delta) { _index += delta; return *this; }
        inline friend iterator_base<T> operator+(const iterator_base<T> &iter, difference_type delta) { return iterator_base<T>{iter._node, iter._index + delta}; }
        inline friend iterator_base<T> operator+(difference_type delta, const iterator_base<T> &iter) { return iterator_base<T>{iter._node, iter._index + delta}; }
        inline iterator_base<T> &operator-=(difference_type delta) { _index -= delta; return *this; }
        inline friend iterator_base<T> operator-(const iterator_base<T> &iter, difference_type delta) { return iterator_base<T>{iter._node, iter._index - delta}; }
        inline friend difference_type operator-(const iterator_base<T> &lhs, const iterator_base<T> &rhs) { assert(lhs._node == rhs._node); return lhs._index - rhs._index; }

        inline reference operator[](difference_type delta) const { return _node->at(_index + delta); }

    private:
        friend class SettingsListNode<TType>;

        SettingsListNode<TType> *_node;
        int _index;

        inline iterator_base(SettingsListNode<TType> *node, int index) :
            _node{node},
            _index{index}
        {}
    };

    using iterator = iterator_base<TType>;
    using const_iterator = iterator_base<const TType>;

    SettingsListNode() = default;

    bool isSet() const;
    QString key() const;
    int size() const;
    const TType &at(int index) const;
    TType &at(int index);

    TType &push();
    Deferred push_deferred();
    void pop(int count = 1);
    void reset();

    TType &operator[](int index);
    const TType &operator[](int index) const;

    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
    const_iterator constBegin() const;
    const_iterator constEnd() const;

    void addChangeCallback(const std::function<void(int)> &callback); // size
    void addChangeCallback(QObject *scope, const std::function<void(int)> &callback);

    void setup(QString key, ISettingsAccessor *accessor, std::function<void(int, TType&)> setupFn);
    void commit(int index);

private:
    struct ElementHolder {
        bool __initialized = false;
        QSharedPointer<TType> _element;
        inline ElementHolder() : _element{new TType{}} {}
    };

    QString _key;
    QString _sizeKey;
    ISettingsAccessor *_accessor = nullptr;
    std::function<void(int, TType&)> _setupFn;
    mutable QHash<int, ElementHolder> _cache;
};

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

template<typename T>
bool SettingsEntry<T>::isSet() const
{
    return _accessor->contains(_key);
}

template<typename T>
QString SettingsEntry<T>::key() const
{
    return _key;
}

template<typename T>
T SettingsEntry<T>::get() const
{
    return _accessor->load(_key, _default).template value<T>();
}

template<>
Q_MVVMCORE_EXPORT QVariant SettingsEntry<QVariant>::get() const;

template<typename T>
void SettingsEntry<T>::set(const T &value)
{
    _accessor->save(_key, QVariant::fromValue(value));
}

template<>
Q_MVVMCORE_EXPORT void SettingsEntry<QVariant>::set(const QVariant &value);

template<typename T>
void SettingsEntry<T>::reset()
{
    _accessor->remove(_key);
}

template<typename T>
SettingsEntry<T> &SettingsEntry<T>::operator=(const T &value)
{
    set(value);
    return (*this);
}

template<typename T>
SettingsEntry<T>::operator T() const
{
    return get();
}

template<typename T>
void SettingsEntry<T>::addChangeCallback(const std::function<void (T)> &callback)
{
    addChangeCallback(_accessor, callback);
}

template<typename T>
void SettingsEntry<T>::addChangeCallback(QObject *scope, const std::function<void (T)> &callback)
{
    auto mKey = _key;
    auto mDefault = _default;
    QObject::connect(_accessor, &ISettingsAccessor::entryChanged,
                     scope, [mKey, callback](const QString &key, const QVariant &value) {
        if(key == mKey)
            callback(value.template value<T>());
    });
    QObject::connect(_accessor, &ISettingsAccessor::entryRemoved,
                     scope, [mKey, mDefault, callback](const QString &key) {
        if(key == mKey)
            callback(mDefault.template value<T>());
    });
}

template<>
Q_MVVMCORE_EXPORT void SettingsEntry<QVariant>::addChangeCallback(QObject *scope, const std::function<void (QVariant)> &callback);

template<typename T>
void SettingsEntry<T>::setup(QString key, ISettingsAccessor *accessor, QVariant defaultValue)
{
    Q_ASSERT_X(accessor, Q_FUNC_INFO, "You must set a valid accessor before initializing the settings!");
    _key = std::move(key);
    _accessor = accessor;
    _default = std::move(defaultValue);
}

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

template<typename TType>
bool SettingsListNode<TType>::isSet() const
{
    return _accessor->contains(_sizeKey);
}

template<typename TType>
QString SettingsListNode<TType>::key() const
{
    return _key;
}

template<typename TType>
int SettingsListNode<TType>::size() const
{
    return _accessor->load(_sizeKey, 0).toInt();
}

template<typename TType>
const TType &SettingsListNode<TType>::at(int index) const
{
    auto &value = _cache[index];
    if(!value.__initialized) {
        _setupFn(index, *(value._element));
        value.__initialized = true;
    }
    return *(value._element);
}

template<typename TType>
TType &SettingsListNode<TType>::at(int index)
{
    auto &value = _cache[index];
    if(!value.__initialized) {
        _setupFn(index, *(value._element));
        value.__initialized = true;
    }
    return *(value._element);
}

template<typename TType>
TType &SettingsListNode<TType>::push()
{
    auto cIndex = size();
    _accessor->save(_sizeKey, cIndex + 1);
    return at(cIndex);
}

template<typename TType>
typename SettingsListNode<TType>::Deferred SettingsListNode<TType>::push_deferred()
{
    auto cIndex = size();
    return {this, at(cIndex), cIndex};
}

template<typename TType>
void SettingsListNode<TType>::pop(int count)
{
    auto cSize = size();
    auto nSize = qMax(size() - count, 0);
    for(auto i = cSize - 1; i >= nSize; --i)
        _accessor->remove(_key + QStringLiteral("/%1").arg(i));
    _accessor->save(_sizeKey, nSize);
}

template<typename TType>
void SettingsListNode<TType>::reset()
{
    _accessor->remove(_key);
}

template<typename TType>
const TType &SettingsListNode<TType>::operator[](int index) const
{
    return at(index);
}


template<typename TType>
TType &SettingsListNode<TType>::operator[](int index)
{
    return at(index);
}

template<typename TType>
typename SettingsListNode<TType>::iterator SettingsListNode<TType>::begin()
{
    return iterator{this, 0};
}

template<typename TType>
typename SettingsListNode<TType>::iterator SettingsListNode<TType>::end()
{
    return iterator{this, size()};
}

template<typename TType>
typename SettingsListNode<TType>::const_iterator SettingsListNode<TType>::begin() const
{
    return constBegin();
}

template<typename TType>
typename SettingsListNode<TType>::const_iterator SettingsListNode<TType>::end() const
{
    return constEnd();
}

template<typename TType>
typename SettingsListNode<TType>::const_iterator SettingsListNode<TType>::constBegin() const
{
    return const_iterator{const_cast<SettingsListNode<TType>*>(this), 0};
}

template<typename TType>
typename SettingsListNode<TType>::const_iterator SettingsListNode<TType>::constEnd() const
{
    return const_iterator{const_cast<SettingsListNode<TType>*>(this), size()};
}

template<typename TType>
void SettingsListNode<TType>::addChangeCallback(const std::function<void (int)> &callback)
{
    addChangeCallback(_accessor, callback);
}

template<typename TType>
void SettingsListNode<TType>::addChangeCallback(QObject *scope, const std::function<void (int)> &callback)
{
    QString mKey = _sizeKey;
    QObject::connect(_accessor, &ISettingsAccessor::entryChanged,
                     scope, [mKey, callback](const QString &key, const QVariant &value) {
        if(key == mKey)
            callback(value.toInt());
    });
    QObject::connect(_accessor, &ISettingsAccessor::entryRemoved,
                     scope, [mKey, callback](const QString &key) {
        if(key == mKey)
            callback(0);
    });
}

template<typename TType>
void SettingsListNode<TType>::setup(QString key, ISettingsAccessor *accessor, std::function<void(int, TType&)> setupFn)
{
    Q_ASSERT_X(accessor, Q_FUNC_INFO, "You must set a valid accessor before initializing the settings!");
    _key = std::move(key);
    _sizeKey = _key + QStringLiteral("/size");
    _accessor = accessor;
    _setupFn = std::move(setupFn);
}

template<typename TType>
void SettingsListNode<TType>::commit(int index)
{
    _accessor->save(_sizeKey, qMax(size(), index + 1));
}

}


#endif // QTMVVM_SETTINGSENTRY_H