owning_mutex.hpp

Go to the documentation of this file.

 
#ifndef MRS_LIB_UTILITY_OWNING_MUTEX_HPP_
#define MRS_LIB_UTILITY_OWNING_MUTEX_HPP_
 
 
#include <concepts>
#include <memory>
#include <mutex>
#include <type_traits>
#include <utility>
 
 
namespace mrs_lib
{

  template <typename T, typename Mutex = std::mutex>
    requires(std::same_as<T, std::remove_cvref_t<T>> && std::default_initializable<Mutex>)
  class OwningMutex
  {
  private:
    template <bool Mutable>
    class [[nodiscard]] OwningMutexGuard;
 
  public:
    OwningMutex()
      requires(std::default_initializable<T>)
    = default;

    OwningMutex(const T& val) : data_(val)
    {
    }

    OwningMutex(T&& val) : data_(std::move(val))
    {
    }

    ~OwningMutex() = default;

    OwningMutex(const OwningMutex&) = delete;
    OwningMutex& operator=(const OwningMutex&) = delete;
    OwningMutex(OwningMutex&&) = delete;
    OwningMutex& operator=(OwningMutex&&) = delete;

    OwningMutexGuard<true> acquire()
    {
      return OwningMutexGuard<true>(*this);
    }

    OwningMutexGuard<false> acquire() const
    {
      return OwningMutexGuard<false>(*this);
    }

    [[nodiscard]] T load() const
    {
      std::lock_guard lock(mutex_);
      return data_;
    }

    void store(T val)
      requires(std::is_nothrow_move_assignable_v<T>)
    {
      std::lock_guard lock(mutex_);
      data_ = std::move(val);
    }
 
  private:
    mutable Mutex mutex_;
    T data_;
  };

  template <typename T, typename Mutex>
    requires(std::same_as<T, std::remove_cvref_t<T>> && std::default_initializable<Mutex>)
  template <bool Mutable>
  class OwningMutex<T, Mutex>::OwningMutexGuard
  {
  public:
    ~OwningMutexGuard() = default;

    OwningMutexGuard(const OwningMutexGuard&) = delete;
    OwningMutexGuard& operator=(const OwningMutexGuard&) = delete;
    OwningMutexGuard(OwningMutexGuard&&) = delete;
    OwningMutexGuard& operator=(OwningMutexGuard&&) = delete;

    T& operator*() &
      requires(Mutable)
    {
      return parent_.data_;
    }

    const T& operator*() const&
    {
      return parent_.data_;
    }

    T& operator*() && = delete;
    const T& operator*() const&& = delete;

    T* operator->() &
      requires(Mutable)
    {
      return std::addressof(parent_.data_);
    }

    const T* operator->() const&
    {
      return std::addressof(parent_.data_);
    }

    T* operator->() && = delete;
    const T* operator->() const&& = delete;
 
  private:
    using RefType = std::conditional_t<Mutable, OwningMutex&, const OwningMutex&>;

    explicit OwningMutexGuard(RefType parent) : lock_(parent.mutex_), parent_(parent)
    {
    }
 
    std::lock_guard<Mutex> lock_;
    RefType parent_;
 
    friend class OwningMutex;
  };
 
} // namespace mrs_lib
 
 
#endif // MRS_LIB_UTILITY_OWNING_MUTEX_HPP_