observable_base.hpp

// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include <functional>
#include "TTauri/Foundation/cpu_utc_clock.hpp"
#include "TTauri/Foundation/fast_mutex.hpp"
#include "TTauri/Foundation/notifier.hpp"
#include "TTauri/Foundation/required.hpp"
 
namespace tt::detail {
 
template<typename T>
class observable_base {
public:
    using callback_type = std::function<void(T const &)>;
    using time_point = typename hires_utc_clock::time_point;
    using duration = typename hires_utc_clock::duration;
 
protected:
    mutable fast_mutex mutex;
 
private:
    T _previous_value;
    time_point _last_modified;
    notifier<T> notifier;
 
public:
    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]] T 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_assume(animation_duration.count() != 0);
 
        return std::clamp(
            numeric_cast<float>(duration_since_last_modified().count()) / numeric_cast<float>(animation_duration.count()),
            0.0f,
            1.0f
        );
    }
 
    [[nodiscard]] virtual T load() const noexcept = 0;
 
    [[nodiscard]] T load(duration animation_duration) const noexcept {
        return mix(animation_progress(animation_duration), previous_value(), load());
    }
 
    virtual bool store(T const &new_value) noexcept = 0;
 
    [[nodiscard]] size_t add_callback(callback_type callback) noexcept {
        return notifier.add(callback);
    }
 
    void remove_callback(size_t id) noexcept {
        notifier.remove(id);
    }
 
protected:
 
    void notify(T const &old_value, T const &new_value) noexcept {
        {
            ttlet lock = std::scoped_lock(mutex);
            _previous_value = old_value;
            _last_modified = cpu_utc_clock::now();
        }
        notifier(new_value);
    }
};
 
}