preferences.hpp

// Copyright Take Vos 2020-2022.
// 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 "datum.hpp"
#include "log.hpp"
#include "jsonpath.hpp"
#include "observer.hpp"
#include "pickle.hpp"
#include <typeinfo>
#include <filesystem>
 
#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, observer<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);
                }
            },
            callback_flags::local);
    }
 
    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;
    observer<T> _value;
    typename decltype(_value)::callback_token _value_cbt;
};
 
} // namespace detail
 
class preferences {
public:
    mutable std::mutex mutex;
 
    preferences() noexcept;
 
    preferences(std::filesystem::path location) noexcept;
 
    preferences(std::string_view location) : preferences(std::filesystem::path{location}) {}
    preferences(std::string const &location) : preferences(std::filesystem::path{location}) {}
    preferences(char const *location) : preferences(std::filesystem::path{location}) {}
 
    ~preferences();
    preferences(preferences const&) = delete;
    preferences(preferences&&) = delete;
    preferences& operator=(preferences const&) = delete;
    preferences& operator=(preferences&&) = delete;
 
    void save() const noexcept;
 
    void save(std::filesystem::path location) noexcept;
 
    void load() noexcept;
 
    void load(std::filesystem::path location) noexcept;
 
    void reset() noexcept;
 
    template<typename T>
    void add(std::string_view path, observer<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:
    std::filesystem::path _location;
 
    datum _data;
 
    mutable bool _modified = false;
 
    loop::timer_callback_token _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