spk_stateful_object.hpp

#pragma once
 
#include <mutex>
#include <unordered_map>
 
#include "structure/design_pattern/spk_contract_provider.hpp"
 
#include "utils/spk_debug_macro.hpp"
 
namespace spk
{
    template <typename TType>
    class StatefulObject
    {
    public:
        using Contract = ContractProvider::Contract;
        using Job = ContractProvider::Job;
 
    private:
        TType _state;
        std::unordered_map<TType, ContractProvider> _callbacks;
        mutable std::mutex _mutex;
 
    public:
        StatefulObject(const TType &p_initialState) :
            _state(p_initialState)
        {
        }
 
        StatefulObject(const StatefulObject &p_other) = delete;
        StatefulObject &operator=(const StatefulObject &p_other) = delete;

        StatefulObject(StatefulObject &&p_other) noexcept :
            _state(std::move(p_other._state)),
            _callbacks(std::move(p_other._callbacks))
        {
        }

        StatefulObject &operator=(StatefulObject &&p_other) noexcept
        {
            if (this != &p_other)
            {
                std::scoped_lock lock(_mutex, p_other._mutex);
 
                _state = std::move(p_other._state);
                _callbacks = std::move(p_other._callbacks);
            }
            return *this;
        }
 
        virtual ~StatefulObject() = default;

        void setState(const TType &p_newState)
        {
            std::scoped_lock lock(_mutex);
 
            if (_state != p_newState)
            {
                _state = p_newState;
                _callbacks[_state].trigger();
            }
        }

        TType state() const
        {
            std::scoped_lock lock(_mutex);
            return _state;
        }

        Contract addCallback(const TType &p_state, const Job &p_callback)
        {
            std::scoped_lock lock(_mutex);
            return (std::move(_callbacks[p_state].subscribe(p_callback)));
        }
    };
}