lockable.h

#pragma once
 
#include <mutex>
 
#if MRS_LIB_IGNORE_DEPRECATED_LOCKABLE
#define MRS_LIB_DEPRECATED_LOCKABLE
#else
#define MRS_LIB_DEPRECATED_LOCKABLE [[deprecated("Use mrs_lib::OwningMutex instead.")]]
#endif
 
namespace mrs_lib
{
  template <typename LockedVarT, typename MutexT>
  class Unlocker;

  template <typename LockedVarT, typename MutexT = std::mutex>
  class MRS_LIB_DEPRECATED_LOCKABLE 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 MRS_LIB_DEPRECATED_LOCKABLE 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;
  };
 
} // namespace mrs_lib
 
#undef MRS_LIB_DEPRECATED_LOCKABLE