Class CachedValue

include/geode/basic/cached_value.hpp:38–133

{
    template < typename ReturnType >
    class CachedValue
    {
    public:
        template < typename... Args >
        using CachedFunction =
            typename std::add_pointer< ReturnType( Args... ) >::type;

        CachedValue() = default;
        CachedValue( const CachedValue& other )
        {
            value_ = other.value_;
            computed_ = other.computed_.load();
        }
        CachedValue( CachedValue&& other ) noexcept
        {
            value_ = std::move( other.value_ );
            computed_ = other.computed_.load();
        }

        CachedValue& operator=( const CachedValue& other )
        {
            value_ = other.value_;
            computed_ = other.computed_.load();
            return *this;
        }

        CachedValue& operator=( CachedValue&& other ) noexcept
        {
            value_ = std::move( other.value_ );
            computed_ = other.computed_.load();
            return *this;
        }

        template < typename... Args >
        const ReturnType& operator()(
            CachedFunction< Args... > computer, Args&&... args ) const
        {
            if( !computed_ )
            {
                absl::MutexLock lock{ mutex_ };
                if( !computed_ )
                {
                    value_ = computer( std::forward< Args >( args )... );
                    computed_ = true;
                }
            }
            return value_;
        }

        bool operator!=( const CachedValue& other ) const
        {
            if( computed() && other.computed() )
            {
                return value() != other.value();
            }
            return false;
        }