TargetParser: AArch64: Add part numbers for Apple CPUs.
[llvm-project.git] / libcxx / include / __mutex / unique_lock.h
blob3642ab93cb1f7cbae971fb705fcee5ad0828c49b
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 //===----------------------------------------------------------------------===//
9 #ifndef _LIBCPP___MUTEX_UNIQUE_LOCK_H
10 #define _LIBCPP___MUTEX_UNIQUE_LOCK_H
12 #include <__chrono/duration.h>
13 #include <__chrono/time_point.h>
14 #include <__config>
15 #include <__memory/addressof.h>
16 #include <__mutex/tag_types.h>
17 #include <__system_error/throw_system_error.h>
18 #include <__utility/swap.h>
19 #include <cerrno>
21 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
22 # pragma GCC system_header
23 #endif
25 _LIBCPP_BEGIN_NAMESPACE_STD
27 template <class _Mutex>
28 class _LIBCPP_TEMPLATE_VIS unique_lock {
29 public:
30 typedef _Mutex mutex_type;
32 private:
33 mutex_type* __m_;
34 bool __owns_;
36 public:
37 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
38 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI explicit unique_lock(mutex_type& __m)
39 : __m_(std::addressof(__m)), __owns_(true) {
40 __m_->lock();
43 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
44 : __m_(std::addressof(__m)),
45 __owns_(false) {}
47 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, try_to_lock_t)
48 : __m_(std::addressof(__m)), __owns_(__m.try_lock()) {}
50 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, adopt_lock_t)
51 : __m_(std::addressof(__m)), __owns_(true) {}
53 template <class _Clock, class _Duration>
54 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
55 : __m_(std::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
57 template <class _Rep, class _Period>
58 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
59 : __m_(std::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
61 _LIBCPP_HIDE_FROM_ABI ~unique_lock() {
62 if (__owns_)
63 __m_->unlock();
66 unique_lock(unique_lock const&) = delete;
67 unique_lock& operator=(unique_lock const&) = delete;
69 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unique_lock(unique_lock&& __u) _NOEXCEPT
70 : __m_(__u.__m_),
71 __owns_(__u.__owns_) {
72 __u.__m_ = nullptr;
73 __u.__owns_ = false;
76 _LIBCPP_HIDE_FROM_ABI unique_lock& operator=(unique_lock&& __u) _NOEXCEPT {
77 if (__owns_)
78 __m_->unlock();
80 __m_ = __u.__m_;
81 __owns_ = __u.__owns_;
82 __u.__m_ = nullptr;
83 __u.__owns_ = false;
84 return *this;
87 _LIBCPP_HIDE_FROM_ABI void lock();
88 _LIBCPP_HIDE_FROM_ABI bool try_lock();
90 template <class _Rep, class _Period>
91 _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
93 template <class _Clock, class _Duration>
94 _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
96 _LIBCPP_HIDE_FROM_ABI void unlock();
98 _LIBCPP_HIDE_FROM_ABI void swap(unique_lock& __u) _NOEXCEPT {
99 std::swap(__m_, __u.__m_);
100 std::swap(__owns_, __u.__owns_);
103 _LIBCPP_HIDE_FROM_ABI mutex_type* release() _NOEXCEPT {
104 mutex_type* __m = __m_;
105 __m_ = nullptr;
106 __owns_ = false;
107 return __m;
110 _LIBCPP_HIDE_FROM_ABI bool owns_lock() const _NOEXCEPT { return __owns_; }
111 _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __owns_; }
112 _LIBCPP_HIDE_FROM_ABI mutex_type* mutex() const _NOEXCEPT { return __m_; }
114 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
116 template <class _Mutex>
117 _LIBCPP_HIDE_FROM_ABI void unique_lock<_Mutex>::lock() {
118 if (__m_ == nullptr)
119 __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
120 if (__owns_)
121 __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
122 __m_->lock();
123 __owns_ = true;
126 template <class _Mutex>
127 _LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock() {
128 if (__m_ == nullptr)
129 __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
130 if (__owns_)
131 __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
132 __owns_ = __m_->try_lock();
133 return __owns_;
136 template <class _Mutex>
137 template <class _Rep, class _Period>
138 _LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
139 if (__m_ == nullptr)
140 __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
141 if (__owns_)
142 __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
143 __owns_ = __m_->try_lock_for(__d);
144 return __owns_;
147 template <class _Mutex>
148 template <class _Clock, class _Duration>
149 _LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
150 if (__m_ == nullptr)
151 __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
152 if (__owns_)
153 __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
154 __owns_ = __m_->try_lock_until(__t);
155 return __owns_;
158 template <class _Mutex>
159 _LIBCPP_HIDE_FROM_ABI void unique_lock<_Mutex>::unlock() {
160 if (!__owns_)
161 __throw_system_error(EPERM, "unique_lock::unlock: not locked");
162 __m_->unlock();
163 __owns_ = false;
166 template <class _Mutex>
167 inline _LIBCPP_HIDE_FROM_ABI void swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT {
168 __x.swap(__y);
171 _LIBCPP_END_NAMESPACE_STD
173 #endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H