LockedAccess.h

#pragma once
#include <memory>
#include <mutex>
#include <utility>
 
namespace valor {
namespace util {
template <typename T>
class LockedAccess {
   public:
    LockedAccess(T& object, std::mutex& mutex) : object{object}, lock{mutex} {}
 
    auto operator->() {
        if constexpr (requires(T t) { t.operator->(); })
            return object.operator->();
        else
            return &object;
    }
 
    LockedAccess& operator=(T&& other) {
        object = std::move(other);
        return *this;
    }
 
    T& value() { return object; }
 
   private:
    T& object;
    std::unique_lock<std::mutex> lock;
};
 
template <typename T>
class Locked {
   public:
    template <typename... Args>
    explicit Locked(Args&&... args) : object{std::forward<Args>(args)...} {}
 
    LockedAccess<T> lock() { return {object, mutex}; }
 
    LockedAccess<const T> lock() const { return {object, mutex}; }
 
    LockedAccess<T> operator->() { return lock(); }
 
    LockedAccess<const T> operator->() const { return lock(); }
 
   private:
    T object;
    mutable std::mutex mutex;
};
}  // namespace util
}  // namespace valor