178 lines · c
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-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef _LIBCPP___CXX03___MUTEX_UNIQUE_LOCK_H10#define _LIBCPP___CXX03___MUTEX_UNIQUE_LOCK_H11 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_header23#endif24 25#ifndef _LIBCPP_HAS_NO_THREADS26 27_LIBCPP_BEGIN_NAMESPACE_STD28 29template <class _Mutex>30class _LIBCPP_TEMPLATE_VIS unique_lock {31public:32 typedef _Mutex mutex_type;33 34private:35 mutex_type* __m_;36 bool __owns_;37 38public: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) _NOEXCEPT46 : __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) _NOEXCEPT72 : __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 118template <class _Mutex>119void 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 128template <class _Mutex>129bool 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 138template <class _Mutex>139template <class _Rep, class _Period>140bool 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 149template <class _Mutex>150template <class _Clock, class _Duration>151bool 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 160template <class _Mutex>161void 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 168template <class _Mutex>169inline _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_STD174 175#endif // _LIBCPP_HAS_NO_THREADS176 177#endif // _LIBCPP___CXX03___MUTEX_UNIQUE_LOCK_H178