1 // std::unique_lock implementation -*- C++ -*-
2
3 // Copyright (C) 2008-2021 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file bits/unique_lock.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{mutex}
28 */
29
30 #ifndef _GLIBCXX_UNIQUE_LOCK_H
31 #define _GLIBCXX_UNIQUE_LOCK_H 1
32
33 #pragma GCC system_header
34
35 #if __cplusplus < 201103L
36 # include <bits/c++0x_warning.h>
37 #else
38
39 #include <chrono>
40 #include <bits/move.h> // for std::swap
41 #include <bits/std_mutex.h> // for std::defer_lock_t
42
_GLIBCXX_VISIBILITY(default)43 namespace std _GLIBCXX_VISIBILITY(default)
44 {
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47 /** @brief A movable scoped lock type.
48 *
49 * A unique_lock controls mutex ownership within a scope. Ownership of the
50 * mutex can be delayed until after construction and can be transferred
51 * to another unique_lock by move construction or move assignment. If a
52 * mutex lock is owned when the destructor runs ownership will be released.
53 *
54 * @ingroup mutexes
55 */
56 template<typename _Mutex>
57 class unique_lock
58 {
59 public:
60 typedef _Mutex mutex_type;
61
62 unique_lock() noexcept
63 : _M_device(0), _M_owns(false)
64 { }
65
66 explicit unique_lock(mutex_type& __m)
67 : _M_device(std::__addressof(__m)), _M_owns(false)
68 {
69 lock();
70 _M_owns = true;
71 }
72
73 unique_lock(mutex_type& __m, defer_lock_t) noexcept
74 : _M_device(std::__addressof(__m)), _M_owns(false)
75 { }
76
77 unique_lock(mutex_type& __m, try_to_lock_t)
78 : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock())
79 { }
80
81 unique_lock(mutex_type& __m, adopt_lock_t) noexcept
82 : _M_device(std::__addressof(__m)), _M_owns(true)
83 {
84 // XXX calling thread owns mutex
85 }
86
87 template<typename _Clock, typename _Duration>
88 unique_lock(mutex_type& __m,
89 const chrono::time_point<_Clock, _Duration>& __atime)
90 : _M_device(std::__addressof(__m)),
91 _M_owns(_M_device->try_lock_until(__atime))
92 { }
93
94 template<typename _Rep, typename _Period>
95 unique_lock(mutex_type& __m,
96 const chrono::duration<_Rep, _Period>& __rtime)
97 : _M_device(std::__addressof(__m)),
98 _M_owns(_M_device->try_lock_for(__rtime))
99 { }
100
101 ~unique_lock()
102 {
103 if (_M_owns)
104 unlock();
105 }
106
107 unique_lock(const unique_lock&) = delete;
108 unique_lock& operator=(const unique_lock&) = delete;
109
110 unique_lock(unique_lock&& __u) noexcept
111 : _M_device(__u._M_device), _M_owns(__u._M_owns)
112 {
113 __u._M_device = 0;
114 __u._M_owns = false;
115 }
116
117 unique_lock& operator=(unique_lock&& __u) noexcept
118 {
119 if(_M_owns)
120 unlock();
121
122 unique_lock(std::move(__u)).swap(*this);
123
124 __u._M_device = 0;
125 __u._M_owns = false;
126
127 return *this;
128 }
129
130 void
131 lock()
132 {
133 if (!_M_device)
134 __throw_system_error(int(errc::operation_not_permitted));
135 else if (_M_owns)
136 __throw_system_error(int(errc::resource_deadlock_would_occur));
137 else
138 {
139 _M_device->lock();
140 _M_owns = true;
141 }
142 }
143
144 bool
145 try_lock()
146 {
147 if (!_M_device)
148 __throw_system_error(int(errc::operation_not_permitted));
149 else if (_M_owns)
150 __throw_system_error(int(errc::resource_deadlock_would_occur));
151 else
152 {
153 _M_owns = _M_device->try_lock();
154 return _M_owns;
155 }
156 }
157
158 template<typename _Clock, typename _Duration>
159 bool
160 try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
161 {
162 if (!_M_device)
163 __throw_system_error(int(errc::operation_not_permitted));
164 else if (_M_owns)
165 __throw_system_error(int(errc::resource_deadlock_would_occur));
166 else
167 {
168 _M_owns = _M_device->try_lock_until(__atime);
169 return _M_owns;
170 }
171 }
172
173 template<typename _Rep, typename _Period>
174 bool
175 try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
176 {
177 if (!_M_device)
178 __throw_system_error(int(errc::operation_not_permitted));
179 else if (_M_owns)
180 __throw_system_error(int(errc::resource_deadlock_would_occur));
181 else
182 {
183 _M_owns = _M_device->try_lock_for(__rtime);
184 return _M_owns;
185 }
186 }
187
188 void
189 unlock()
190 {
191 if (!_M_owns)
192 __throw_system_error(int(errc::operation_not_permitted));
193 else if (_M_device)
194 {
195 _M_device->unlock();
196 _M_owns = false;
197 }
198 }
199
200 void
201 swap(unique_lock& __u) noexcept
202 {
203 std::swap(_M_device, __u._M_device);
204 std::swap(_M_owns, __u._M_owns);
205 }
206
207 mutex_type*
208 release() noexcept
209 {
210 mutex_type* __ret = _M_device;
211 _M_device = 0;
212 _M_owns = false;
213 return __ret;
214 }
215
216 bool
217 owns_lock() const noexcept
218 { return _M_owns; }
219
220 explicit operator bool() const noexcept
221 { return owns_lock(); }
222
223 mutex_type*
224 mutex() const noexcept
225 { return _M_device; }
226
227 private:
228 mutex_type* _M_device;
229 bool _M_owns;
230 };
231
232 /// Swap overload for unique_lock objects.
233 /// @relates unique_lock
234 template<typename _Mutex>
235 inline void
236 swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
237 { __x.swap(__y); }
238
239 _GLIBCXX_END_NAMESPACE_VERSION
240 } // namespace
241
242 #endif // C++11
243 #endif // _GLIBCXX_UNIQUE_LOCK_H
244