spk_cached_data.hpp

#pragma once
 
#include <functional>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <utility>
 
#include "utils/spk_debug_macro.hpp"
 
namespace spk
{
    template <typename TType>
    class CachedData
    {
        static_assert(!std::is_void_v<TType>, "TType must not be void");
 
    public:
        using value_type = TType;
        using Generator = std::function<TType()>;
        using Destructor = std::function<void(TType &)>;
 
    private:
        Generator _generator;
        Destructor _destructor;
        mutable std::optional<TType> _data;
        mutable std::mutex _mutex;
 
        void _destroyDataLocked() const
        {
            if (_data.has_value() == false)
            {
                return;
            }
 
            if (_destructor != nullptr)
            {
                _destructor(*_data);
            }
            _data.reset();
        }
 
        void _generateData() const
        {
            if (_data.has_value() == true)
            {
                return;
            }
 
            std::scoped_lock lock(_mutex);
            if (_data.has_value() == false)
            {
                if (_generator == nullptr)
                {
                    throw std::logic_error("CachedData: generator not set");
                }
                _data = _generator();
            }
        }
 
        void _destroyData() const
        {
            std::scoped_lock lock(_mutex);
            if (_data.has_value() == false)
            {
                return;
            }
 
            _destroyDataLocked();
        }
 
    public:
        explicit CachedData(Generator p_generator, Destructor p_destructor = nullptr) :
            _generator(std::move(p_generator)),
            _destructor(std::move(p_destructor))
        {
        }

        ~CachedData()
        {
            _destroyData();
        }
 
        CachedData(const CachedData &) = delete;
        CachedData &operator=(const CachedData &) = delete;
 
        CachedData(CachedData &&p_other) = delete;
        CachedData &operator=(CachedData &&p_other) = delete;

        TType &get()
        {
            _generateData();
            return _data.value();
        }

        const TType &get() const
        {
            _generateData();
            return _data.value();
        }

        TType &operator*()
        {
            return get();
        }

        const TType &operator*() const
        {
            return get();
        }

        TType *operator->()
        {
            _generateData();
            return &(_data.value());
        }

        const TType *operator->() const
        {
            _generateData();
            return &(_data.value());
        }

        operator TType &()
        {
            return get();
        }

        operator const TType &() const
        {
            return get();
        }

        void release() const
        {
            _destroyData();
        }

        void configure(Generator p_generator, Destructor p_destructor = nullptr)
        {
            std::scoped_lock lock(_mutex);
            _destroyDataLocked();
            _generator = std::move(p_generator);
            _destructor = std::move(p_destructor);
        }

        void set(const TType &p_value)
        {
            std::scoped_lock lock(_mutex);
            _destroyDataLocked();
            _data = p_value;
        }

        void set(TType &&p_value)
        {
            std::scoped_lock lock(_mutex);
            _destroyDataLocked();
            _data = std::move(p_value);
        }

        std::optional<TType> take()
        {
            std::scoped_lock lock(_mutex);
            std::optional<TType> extracted;
            if (_data.has_value())
            {
                extracted.emplace(std::move(*_data));
                _data.reset();
            }
            return extracted;
        }

        bool isCached() const
        {
            return _data.has_value();
        }

        TType &refresh()
        {
            release();
            return get();
        }
    };
}