libcxx/include/__cxx03/__mutex/unique_lock.h

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef _LIBCPP___MUTEX_UNIQUE_LOCK_H
  10 #define _LIBCPP___MUTEX_UNIQUE_LOCK_H
  11
  12 #include <__cxx03/__chrono/duration.h>
  13 #include <__cxx03/__chrono/time_point.h>
  14 #include <__cxx03/__config>
  15 #include <__cxx03/__memory/addressof.h>
  16 #include <__cxx03/__mutex/tag_types.h>
  17 #include <__cxx03/__system_error/system_error.h>
  18 #include <__cxx03/__utility/swap.h>
  19 #include <__cxx03/cerrno>
  20
  21 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  22 #  pragma GCC system_header
  23 #endif
  24
  25 #ifndef _LIBCPP_HAS_NO_THREADS
  26
  27 _LIBCPP_BEGIN_NAMESPACE_STD
  28
  29 template <class _Mutex>
  30 class _LIBCPP_TEMPLATE_VIS unique_lock {
  31 public:
  32   typedef _Mutex mutex_type;
  33
  34 private:
  35   mutex_type* __m_;
  36   bool __owns_;
  37
  38 public:
  39   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
  40   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI explicit unique_lock(mutex_type& __m)
  41       : __m_(std::addressof(__m)), __owns_(true) {
  42     __m_->lock();
  43   }
  44
  45   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
  46       : __m_(std::addressof(__m)),
  47         __owns_(false) {}
  48
  49   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, try_to_lock_t)
  50       : __m_(std::addressof(__m)), __owns_(__m.try_lock()) {}
  51
  52   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, adopt_lock_t)
  53       : __m_(std::addressof(__m)), __owns_(true) {}
  54
  55   template <class _Clock, class _Duration>
  56   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
  57       : __m_(std::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
  58
  59   template <class _Rep, class _Period>
  60   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
  61       : __m_(std::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
  62
  63   _LIBCPP_HIDE_FROM_ABI ~unique_lock() {
  64     if (__owns_)
  65       __m_->unlock();
  66   }
  67
  68   unique_lock(unique_lock const&)            = delete;
  69   unique_lock& operator=(unique_lock const&) = delete;
  70
  71   _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(unique_lock&& __u) _NOEXCEPT
  72       : __m_(__u.__m_),
  73         __owns_(__u.__owns_) {
  74     __u.__m_    = nullptr;
  75     __u.__owns_ = false;
  76   }
  77
  78   _LIBCPP_HIDE_FROM_ABI unique_lock& operator=(unique_lock&& __u) _NOEXCEPT {
  79     if (__owns_)
  80       __m_->unlock();
  81
  82     __m_        = __u.__m_;
  83     __owns_     = __u.__owns_;
  84     __u.__m_    = nullptr;
  85     __u.__owns_ = false;
  86     return *this;
  87   }
  88
  89   void lock();
  90   bool try_lock();
  91
  92   template <class _Rep, class _Period>
  93   bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
  94
  95   template <class _Clock, class _Duration>
  96   bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
  97
  98   void unlock();
  99
 100   _LIBCPP_HIDE_FROM_ABI void swap(unique_lock& __u) _NOEXCEPT {
 101     std::swap(__m_, __u.__m_);
 102     std::swap(__owns_, __u.__owns_);
 103   }
 104
 105   _LIBCPP_HIDE_FROM_ABI mutex_type* release() _NOEXCEPT {
 106     mutex_type* __m = __m_;
 107     __m_            = nullptr;
 108     __owns_         = false;
 109     return __m;
 110   }
 111
 112   _LIBCPP_HIDE_FROM_ABI bool owns_lock() const _NOEXCEPT { return __owns_; }
 113   _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __owns_; }
 114   _LIBCPP_HIDE_FROM_ABI mutex_type* mutex() const _NOEXCEPT { return __m_; }
 115 };
 116 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
 117
 118 template <class _Mutex>
 119 void unique_lock<_Mutex>::lock() {
 120   if (__m_ == nullptr)
 121     __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
 122   if (__owns_)
 123     __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
 124   __m_->lock();
 125   __owns_ = true;
 126 }
 127
 128 template <class _Mutex>
 129 bool unique_lock<_Mutex>::try_lock() {
 130   if (__m_ == nullptr)
 131     __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
 132   if (__owns_)
 133     __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
 134   __owns_ = __m_->try_lock();
 135   return __owns_;
 136 }
 137
 138 template <class _Mutex>
 139 template <class _Rep, class _Period>
 140 bool unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
 141   if (__m_ == nullptr)
 142     __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
 143   if (__owns_)
 144     __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
 145   __owns_ = __m_->try_lock_for(__d);
 146   return __owns_;
 147 }
 148
 149 template <class _Mutex>
 150 template <class _Clock, class _Duration>
 151 bool unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
 152   if (__m_ == nullptr)
 153     __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
 154   if (__owns_)
 155     __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
 156   __owns_ = __m_->try_lock_until(__t);
 157   return __owns_;
 158 }
 159
 160 template <class _Mutex>
 161 void unique_lock<_Mutex>::unlock() {
 162   if (!__owns_)
 163     __throw_system_error(EPERM, "unique_lock::unlock: not locked");
 164   __m_->unlock();
 165   __owns_ = false;
 166 }
 167
 168 template <class _Mutex>
 169 inline _LIBCPP_HIDE_FROM_ABI void swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT {
 170   __x.swap(__y);
 171 }
 172
 173 _LIBCPP_END_NAMESPACE_STD
 174
 175 #endif // _LIBCPP_HAS_NO_THREADS
 176
 177 #endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H