ObservableValue.hpp

#pragma once
 
#include <boost/signals2/connection.hpp>
#include <boost/signals2/signal.hpp>
#include <boost/signals2/variadic_signal.hpp>
 
#include <atomic>
#include <concepts>
#include <type_traits>
 
namespace util {
 
template <typename T>
concept SomeAtomic =
    std::same_as<std::remove_cvref_t<T>, std::atomic<std::remove_cvref_t<typename T::value_type>>>;

template <typename T>
concept Observable =
    std::equality_comparable<T> && std::copy_constructible<T> && std::move_constructible<T>;
 
namespace impl {

template <Observable T>
class ObservableValueBase {
protected:
    boost::signals2::signal<void(T const&)> onUpdate_;
 
public:
    virtual ~ObservableValueBase() = default;

    boost::signals2::connection
    observe(std::invocable<T const&> auto&& fn)
    {
        return onUpdate_.connect(std::forward<decltype(fn)>(fn));
    }

    [[nodiscard]] bool
    hasObservers() const
    {
        return not onUpdate_.empty();
    }

    virtual void
    forceNotify() = 0;
 
protected:
    void
    notifyObservers(T const& value)
    {
        onUpdate_(value);
    }
};
 
}  // namespace impl
 
// Forward declaration
template <typename T>
class ObservableValue;

template <Observable T>
    requires(not SomeAtomic<T>)
class ObservableValue<T> : public impl::ObservableValueBase<T> {
    T value_;

    struct ObservableGuard {
        T const oldValue;         
        ObservableValue<T>& ref;  

        ObservableGuard(ObservableValue<T>& observable) : oldValue(observable), ref(observable)
        {
        }

        ~ObservableGuard()
        {
            if (oldValue != ref.value_)
                ref.notifyObservers(ref.value_);
        }

        [[nodiscard]]
        operator T&()
        {
            return ref.value_;
        }
    };
 
public:
    ObservableValue(std::convertible_to<T> auto&& value)
        : value_{std::forward<decltype(value)>(value)}
    {
    }

    ObservableValue()
        requires std::default_initializable<T>
        : value_{}
    {
    }
 
    ObservableValue(ObservableValue const&) = delete;
    ObservableValue(ObservableValue&&) = default;
    ObservableValue&
    operator=(ObservableValue const&) = delete;
    ObservableValue&
    operator=(ObservableValue&&) = default;

    ObservableValue&
    operator=(std::convertible_to<T> auto&& val)
    {
        set(val);
        return *this;
    }

    [[nodiscard]] ObservableGuard
    operator->()
    {
        return {*this};
    }

    [[nodiscard]]
    operator T const&() const
    {
        return value_;
    }

    [[nodiscard]] T const&
    get() const
    {
        return value_;
    }

    void
    set(std::convertible_to<T> auto&& val)
    {
        if (value_ != val) {
            value_ = std::forward<decltype(val)>(val);
            this->notifyObservers(value_);
        }
    }

    void
    forceNotify() override
    {
        this->notifyObservers(value_);
    }
};

template <Observable T>
class ObservableValue<std::atomic<T>> : public impl::ObservableValueBase<T> {
    std::atomic<T> value_;
 
public:
    ObservableValue(std::convertible_to<T> auto&& value)
        : value_{std::forward<decltype(value)>(value)}
    {
    }

    ObservableValue()
        requires std::default_initializable<T>
        : value_{}
    {
    }
 
    ObservableValue(ObservableValue const&) = delete;
    ObservableValue(ObservableValue&&) = default;
    ObservableValue&
    operator=(ObservableValue const&) = delete;
    ObservableValue&
    operator=(ObservableValue&&) = default;

    ObservableValue&
    operator=(std::convertible_to<T> auto&& val)
    {
        set(std::forward<decltype(val)>(val));
        return *this;
    }

    [[nodiscard]] T
    get() const
    {
        return value_.load();
    }

    [[nodiscard]]
    operator T() const
    {
        return get();
    }

    void
    set(std::convertible_to<T> auto&& val)
    {
        T newValue = std::forward<decltype(val)>(val);
        T oldValue = value_.load();
 
        // Use compare-and-swap to atomically update
        while (!value_.compare_exchange_weak(oldValue, newValue)) {
            // compare_exchange_weak updates oldValue with current value on failure
            // Continue until we succeed
        }
 
        // Notify observers if we actually changed the value
        // Note: oldValue now contains the actual previous value that was replaced
        if (oldValue != newValue) {
            this->notifyObservers(newValue);
        }
    }

    void
    forceNotify() override
    {
        this->notifyObservers(value_.load());
    }
};
 
}  // namespace util