Mutex.hpp

#pragma once
 
#include <mutex>
#include <type_traits>
 
namespace util {
 
template <typename ProtectedDataType, typename MutextType>
class Mutex;

template <typename ProtectedDataType, template <typename...> typename LockType, typename MutexType>
class Lock {
    LockType<MutexType> lock_;
    ProtectedDataType& data_;
 
public:
    ProtectedDataType const&
    operator*() const
    {
        return data_;
    }
 
    ProtectedDataType&
    operator*()
    {
        return data_;
    }
 
    [[nodiscard]] ProtectedDataType const&
    get() const
    {
        return data_;
    }
 
    ProtectedDataType&
    get()
    {
        return data_;
    }
 
    ProtectedDataType const*
    operator->() const
    {
        return &data_;
    }
 
    ProtectedDataType*
    operator->()
    {
        return &data_;
    }
 
    operator LockType<MutexType>&()
    {
        return lock_;
    }
 
private:
    friend class Mutex<std::remove_const_t<ProtectedDataType>, MutexType>;
 
    Lock(MutexType& mutex, ProtectedDataType& data) : lock_(mutex), data_(data)
    {
    }
};

template <typename ProtectedDataType, typename MutexType = std::mutex>
class Mutex {
    mutable MutexType mutex_;
    ProtectedDataType data_;
 
public:
    Mutex() = default;

    explicit Mutex(ProtectedDataType data) : data_(std::move(data))
    {
    }

    template <typename... Args>
    static Mutex
    make(Args&&... args)
    {
        return Mutex{ProtectedDataType{std::forward<Args>(args)...}};
    }

    template <template <typename...> typename LockType = std::lock_guard>
    Lock<ProtectedDataType const, LockType, MutexType>
    lock() const
    {
        return {mutex_, data_};
    }

    template <template <typename...> typename LockType = std::lock_guard>
    Lock<ProtectedDataType, LockType, MutexType>
    lock()
    {
        return {mutex_, data_};
    }
};
 
}  // namespace util