TSynchronized.h

Go to the documentation of this file.

#pragma once
 
#include "Utility/INoCopyAndMove.h"
 
#include <Common/assertion.h>
#include <Common/exceptions.h>
 
#include <shared_mutex>
#include <type_traits>
#include <utility>
#include <memory>
 
namespace ph
{
 
template<typename T, typename Mutex = std::shared_mutex>
class TSynchronized final : private INoCopyAndMove
{
private:
    class AutoLockingPtr final : private INoCopyAndMove
    {
    public:
        explicit AutoLockingPtr(TSynchronized& parent)
            : m_parent(parent)
        {
            m_parent.m_mutex.lock();
        }
 
        ~AutoLockingPtr()
        {
            m_parent.m_mutex.unlock();
        }
 
        T* operator -> ()
        {
            return std::addressof(m_parent.m_value);
        }
 
        T& operator * ()
        {
            return m_parent.m_value;
        }
 
    private:
        TSynchronized& m_parent;
    };
 
    class AutoConstLockingPtr final : private INoCopyAndMove
    {
    public:
        explicit AutoConstLockingPtr(const TSynchronized& parent)
            : m_parent(parent)
        {
            m_parent.m_mutex.lock_shared();
        }
 
        ~AutoConstLockingPtr()
        {
            m_parent.m_mutex.unlock_shared();
        }
 
        const T* operator -> () const
        {
            return std::addressof(m_parent.m_value);
        }
 
        const T& operator * () const
        {
            return m_parent.m_value;
        }
 
    private:
        const TSynchronized& m_parent;
    };
 
    class AutoTryLockingPtr final : private INoCopyAndMove
    {
    public:
        explicit AutoTryLockingPtr(TSynchronized& parent)
            : m_parent(parent)
            , m_isLocked(false)
        {
            m_isLocked = m_parent.m_mutex.try_lock();
        }
 
        ~AutoTryLockingPtr()
        {
            if(m_isLocked)
            {
                m_parent.m_mutex.unlock();
            }
        }
 
        T* operator -> ()
        {
            if(m_isLocked)
            {
                return std::addressof(m_parent.m_value);
            }
            else
            {
                return nullptr;
            }
        }
 
        T& operator * ()
        {
            if(m_isLocked)
            {
                return m_parent.m_value;
            }
            else
            {
                throw IllegalOperationException(
                    "Accessing value without successful non-const locking.");
            }
        }
 
        operator bool () const
        {
            return m_isLocked;
        }
 
    private:
        TSynchronized& m_parent;
        bool m_isLocked;
    };
 
    class AutoTryConstLockingPtr final : private INoCopyAndMove
    {
    public:
        explicit AutoTryConstLockingPtr(const TSynchronized& parent)
            : m_parent(parent)
            , m_isLocked(false)
        {
            m_isLocked = m_parent.m_mutex.try_lock_shared();
        }
 
        ~AutoTryConstLockingPtr()
        {
            if(m_isLocked)
            {
                m_parent.m_mutex.unlock_shared();
            }
        }
 
        const T* operator -> () const
        {
            if(m_isLocked)
            {
                return std::addressof(m_parent.m_value);
            }
            else
            {
                return nullptr;
            }
        }
 
        const T& operator * () const
        {
            if(m_isLocked)
            {
                return m_parent.m_value;
            }
            else
            {
                throw IllegalOperationException(
                    "Accessing value without successful const locking.");
            }
        }
 
        operator bool () const
        {
            return m_isLocked;
        }
 
    private:
        const TSynchronized& m_parent;
        bool m_isLocked;
    };
 
public:
    TSynchronized() = default;
 
    explicit TSynchronized(const T& value) noexcept(std::is_nothrow_copy_constructible_v<T>)
        : m_value(value)
        , m_mutex()
    {}
 
    explicit TSynchronized(T&& value) noexcept(std::is_nothrow_move_constructible_v<T>)
        : m_value(std::move(value))
        , m_mutex()
    {}
 
    const TSynchronized& asConst() const
    {
        return *this;
    }
 
    AutoLockingPtr lockedPtr()
    {
        // Relied on mandatory copy elision
        return AutoLockingPtr(*this);
    }
 
    AutoConstLockingPtr constLockedPtr() const
    {
        // Relied on mandatory copy elision
        return AutoConstLockingPtr(*this);
    }
 
    template<typename LockedFunc>
    void locked(LockedFunc func)
    {
        static_assert(std::is_invocable_v<LockedFunc, T&>,
            "LockedFunc must take (T&).");
 
        AutoLockingPtr lockedPtr(*this);
        func(*lockedPtr);
    }
 
    template<typename ConstLockedFunc>
    void constLocked(ConstLockedFunc func) const
    {
        static_assert(std::is_invocable_v<ConstLockedFunc, const T&>,
            "ConstLockedFunc must take (const T&).");
 
        AutoConstLockingPtr lockedPtr(*this);
        func(*lockedPtr);
    }
 
    AutoTryLockingPtr tryLock()
    {
        // Relied on mandatory copy elision
        return AutoTryLockingPtr(*this);
    }
 
    AutoTryConstLockingPtr tryConstLock() const
    {
        // Relied on mandatory copy elision
        return AutoTryConstLockingPtr(*this);
    }
 
    T makeCopy() const
    {
        AutoConstLockingPtr lockedPtr(*this);
        return *lockedPtr;
    }
 
    T& unsafeGetReference()
    {
        return m_value;
    }
 
    const T& unsafeGetReference() const
    {
        return m_value;
    }
 
    TSynchronized& operator = (const T& rhsValue)
    {
        PH_ASSERT(&m_value != &rhsValue);
 
        AutoLockingPtr lockedPtr(*this);
        *lockedPtr = rhsValue;
 
        return *this;
    }
 
    TSynchronized& operator = (T&& rhsValue)
    {
        PH_ASSERT(&m_value != &rhsValue);
 
        AutoLockingPtr lockedPtr(*this);
        *lockedPtr = std::move(rhsValue);
 
        return *this;
    }
 
    AutoLockingPtr operator -> ()
    {
        // Relied on mandatory copy elision
        return AutoLockingPtr(*this);
    }
 
    AutoConstLockingPtr operator -> () const
    {
        // Relied on mandatory copy elision
        return AutoConstLockingPtr(*this);
    }
 
private:
    T m_value;
    mutable Mutex m_mutex;
};
 
}// end namespace ph