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 "timer.hpp"
#include "logger.hpp"
#include <typeinfo>
 
#pragma once
 
namespace tt {
 
class preferences {
public:
    mutable std::recursive_mutex mutex;
 
    preferences(URL location) noexcept;
    virtual ~preferences();
    preferences(preferences const &) = delete;
    preferences(preferences &&) = delete;
    preferences &operator=(preferences const &) = delete;
    preferences &operator=(preferences &&) = delete;
 
    [[nodiscard]] virtual void reset() noexcept {}
 
    void save() const noexcept;
 
    void load() noexcept;
 
    [[nodiscard]] virtual datum serialize() const noexcept
    {
        return {datum::map{}};
    }
 
    virtual void deserialize(datum const &data) noexcept
    {
        ttlet lock = std::scoped_lock(mutex);
        tt_axiom(_deserializing >= 0);
        ++_deserializing;
 
        --_deserializing;
    }
 
protected:
    std::shared_ptr<std::function<void()>> _set_modified_ptr;
 
    int _deserializing = 0;
 
    template<typename T, typename Observable, typename Key>
    static void deserialize_value(Observable &obj, datum const &data, Key const &key) noexcept
    {
        if (data.contains(key)) {
            auto const &data_value = data[key];
            if (holds_alternative<T>(data_value)) {
                obj = static_cast<T>(data_value);
            } else {
                tt_log_error(
                    "Could not deserialize '{}' for key '{}' to a '{}' type.",
                    to_string(data_value),
                    key,
                    typeid(T).name());
            }
        }
    }
 
private:
    URL _location;
 
    mutable bool _modified = false;
 
    timer::callback_ptr_type _check_modified_ptr;
 
    void set_modified() noexcept
    {
        ttlet lock = std::scoped_lock(mutex);
        tt_axiom(_deserializing >= 0);
        if (_deserializing == 0) {
            _modified = true;
        }
    }
 
    void check_modified() noexcept
    {
        ttlet lock = std::scoped_lock(mutex);
        tt_axiom(_deserializing >= 0);
 
        if (_modified) {
            save();
        }
    }
};
 
} // namespace tt