lockable.h

#pragma once
 
#include <mutex>
 
namespace mrs_lib
{
  template <typename LockedVarT, typename MutexT>
  class Unlocker;
 
  template <typename LockedVarT, typename MutexT = std::mutex>
  class Lockable
  {
    MutexT mtx;
    LockedVarT locked_var;
 
    friend Unlocker<LockedVarT, MutexT>;
 
  public:
    Lockable() = default;
 
    Lockable(const LockedVarT& init_val)
      : locked_var(init_val)
    {}
 
    Lockable(const LockedVarT&& init_val)
      : locked_var(init_val)
    {}
 
    LockedVarT& unsafe_access()
    {
      return locked_var;
    }
 
    void set_mutexed(const LockedVarT& val)
    {
      std::scoped_lock lock(mtx);
      locked_var = val;
    }
 
    LockedVarT get_mutexed()
    {
      std::scoped_lock lock(mtx);
      return locked_var;
    }
 
    MutexT& mutex()
    {
      return mtx;
    }
  };
 
  template <typename LockedVarT, typename MutexT>
  class Unlocker
  {
  public:
    Unlocker(Lockable<LockedVarT, MutexT>& lockable)
      : lock(lockable.mtx), lockable(lockable)
    {}
 
    LockedVarT& operator*()
    {
      return lockable.locked_var;
    }
 
    LockedVarT* operator->()
    {
      return &(lockable.locked_var);
    }
 
  private:
    std::scoped_lock<MutexT> lock;
    Lockable<LockedVarT>& lockable;
  };
 
}