preferences.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#include "URL.hpp"
#include "datum.hpp"
#include "log.hpp"
#include "jsonpath.hpp"
#include "observable.hpp"
#include "pickle.hpp"
#include <typeinfo>
 
#pragma once
 
namespace hi::inline v1 {
class preferences;
 
namespace detail {
 
class preference_item_base {
public:
    preference_item_base(preferences &parent, std::string_view path) noexcept;
 
    preference_item_base(preference_item_base const &) = delete;
    preference_item_base(preference_item_base &&) = delete;
    preference_item_base &operator=(preference_item_base const &) = delete;
    preference_item_base &operator=(preference_item_base &&) = delete;
    virtual ~preference_item_base() = default;
 
    virtual void reset() noexcept = 0;
 
    void load() noexcept;
 
protected:
    preferences &_parent;
    jsonpath _path;
 
    [[nodiscard]] virtual datum encode() const noexcept = 0;
 
    virtual void decode(datum const &data) = 0;
};
 
template<typename T>
class preference_item : public preference_item_base {
public:
    preference_item(preferences &parent, std::string_view path, observable<T> const &value, T init) noexcept :
        preference_item_base(parent, path), _value(value), _init(std::move(init))
    {
        _value_cbt = _value.subscribe([this](auto...) {
            if (auto tmp = this->encode(); not holds_alternative<std::monostate>(tmp)) {
                this->_parent.write(_path, this->encode());
            } else {
                this->_parent.remove(_path);
            }
        });
    }
 
    void reset() noexcept override
    {
        _value = _init;
    }
 
protected:
    [[nodiscard]] datum encode() const noexcept override
    {
        if (*_value != _init) {
            return hi::pickle<T>{}.encode(*_value);
        } else {
            return datum{std::monostate{}};
        }
    }
 
    void decode(datum const &data) override
    {
        _value = hi::pickle<T>{}.decode(data);
    }
 
private:
    T _init;
    observable<T> _value;
    typename decltype(_value)::token_type _value_cbt;
};
 
} // namespace detail
 
class preferences {
public:
    mutable std::mutex mutex;
 
    preferences() noexcept;
 
    preferences(URL location) noexcept;
 
    ~preferences();
    preferences(preferences const &) = delete;
    preferences(preferences &&) = delete;
    preferences &operator=(preferences const &) = delete;
    preferences &operator=(preferences &&) = delete;
 
    void save() const noexcept;
 
    void save(URL location) noexcept;
 
    void load() noexcept;
 
    void load(URL location) noexcept;
 
    void reset() noexcept;
 
    template<typename T>
    void add(std::string_view path, observable<T> const &item, T init = T{}) noexcept
    {
        auto item_ = std::make_unique<detail::preference_item<T>>(*this, path, item, std::move(init));
        item_->load();
        _items.push_back(std::move(item_));
    }
 
private:
    URL _location;
 
    datum _data;
 
    mutable bool _modified = false;
 
    loop::timer_token_type _check_modified_cbt;
 
    std::vector<std::unique_ptr<detail::preference_item_base>> _items;
 
    void _load() noexcept;
    void _save() const noexcept;
 
    void check_modified() noexcept;
 
    void write(jsonpath const &path, datum const value) noexcept;
 
    datum read(jsonpath const &path) noexcept;
 
    void remove(jsonpath const &path) noexcept;
 
    friend class detail::preference_item_base;
    template<typename T>
    friend class detail::preference_item;
};
 
} // namespace hi::inline v1