observable_base.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)
 
#pragma once
 
#include <functional>
#include "../cpu_utc_clock.hpp"
#include "../unfair_mutex.hpp"
#include "../notifier.hpp"
#include "../required.hpp"
 
namespace tt::detail {
 
template<typename T>
class observable_base {
public:
    using value_type = T;
    using notifier_type = notifier<void()>;
    using callback_type = typename notifier_type::callback_type;
    using callback_ptr_type = typename notifier_type::callback_ptr_type;
    using time_point = typename hires_utc_clock::time_point;
    using duration = typename hires_utc_clock::duration;
 
    observable_base(observable_base const &) = delete;
    observable_base(observable_base &&) = delete;
    observable_base &operator=(observable_base const &) = delete;
    observable_base &operator=(observable_base &&) = delete;
    virtual ~observable_base() = default;
 
    observable_base() noexcept : _previous_value(), _last_modified(), _notifier() {}
 
    [[nodiscard]] value_type previous_value() const noexcept
    {
        ttlet lock = std::scoped_lock(_mutex);
        return _previous_value;
    }
 
    [[nodiscard]] time_point time_when_last_modified() const noexcept
    {
        ttlet lock = std::scoped_lock(_mutex);
        return _last_modified;
    }
 
    [[nodiscard]] duration duration_since_last_modified() const noexcept
    {
        return cpu_utc_clock::now() - time_when_last_modified();
    }
 
    [[nodiscard]] float animation_progress(duration animation_duration) const noexcept
    {
        tt_axiom(animation_duration.count() != 0);
 
        return std::clamp(
            narrow_cast<float>(duration_since_last_modified().count()) / narrow_cast<float>(animation_duration.count()),
            0.0f,
            1.0f);
    }
 
    [[nodiscard]] virtual value_type load() const noexcept = 0;
 
    [[nodiscard]] value_type load(duration animation_duration) const noexcept
    {
        return mix(animation_progress(animation_duration), previous_value(), load());
    }
 
    virtual bool store(value_type const &new_value) noexcept = 0;
 
    template<typename Callback>
    [[nodiscard]] callback_ptr_type subscribe(Callback &&callback) noexcept
    {
        return _notifier.subscribe(std::forward<Callback>(callback));
    }
 
    void unsubscribe(callback_ptr_type callback_ptr) noexcept
    {
        _notifier.unsubscribe(callback_ptr);
    }
 
protected:
    mutable unfair_mutex _mutex;
 
    void notify(value_type const &old_value, value_type const &new_value) noexcept
    {
        {
            ttlet lock = std::scoped_lock(_mutex);
            _previous_value = old_value;
            _last_modified = cpu_utc_clock::now();
        }
        _notifier();
    }
 
private:
    value_type _previous_value;
    time_point _last_modified;
    notifier_type _notifier;
};
 
} // namespace tt::detail