]>
Commit | Line | Data |
---|---|---|
c910ceff JW |
1 | // <future> -*- C++ -*- |
2 | ||
7a0269de | 3 | // Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc. |
c910ceff JW |
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 | ||
f910786b | 25 | /** @file include/future |
c910ceff JW |
26 | * This is a Standard C++ Library header. |
27 | */ | |
28 | ||
29 | #ifndef _GLIBCXX_FUTURE | |
30 | #define _GLIBCXX_FUTURE 1 | |
31 | ||
32 | #pragma GCC system_header | |
33 | ||
34 | #ifndef __GXX_EXPERIMENTAL_CXX0X__ | |
ab65a4c7 | 35 | # include <bits/c++0x_warning.h> |
c910ceff JW |
36 | #else |
37 | ||
38 | #include <functional> | |
39 | #include <memory> | |
40 | #include <mutex> | |
b3eed6fe | 41 | #include <thread> |
c910ceff JW |
42 | #include <condition_variable> |
43 | #include <system_error> | |
44 | #include <exception> | |
afd88205 | 45 | #include <atomic> |
abcd7e08 | 46 | #include <bits/functexcept.h> |
c910ceff | 47 | |
12ffa228 BK |
48 | namespace std _GLIBCXX_VISIBILITY(default) |
49 | { | |
50 | _GLIBCXX_BEGIN_NAMESPACE_VERSION | |
53dc5044 | 51 | |
c910ceff JW |
52 | /** |
53 | * @defgroup futures Futures | |
54 | * @ingroup concurrency | |
55 | * | |
56 | * Classes for futures support. | |
57 | * @{ | |
58 | */ | |
59 | ||
60 | /// Error code for futures | |
61 | enum class future_errc | |
b3eed6fe JW |
62 | { |
63 | broken_promise, | |
64 | future_already_retrieved, | |
65 | promise_already_satisfied, | |
66 | no_state | |
67 | }; | |
c910ceff | 68 | |
94a86be0 | 69 | /// Specialization. |
c910ceff JW |
70 | template<> |
71 | struct is_error_code_enum<future_errc> : public true_type { }; | |
72 | ||
73 | /// Points to a statically-allocated object derived from error_category. | |
94a86be0 | 74 | const error_category& |
84b63c01 | 75 | future_category() noexcept; |
c910ceff | 76 | |
94a86be0 | 77 | /// Overload for make_error_code. |
faa00511 | 78 | inline error_code |
84b63c01 | 79 | make_error_code(future_errc __errc) noexcept |
94a86be0 | 80 | { return error_code(static_cast<int>(__errc), future_category()); } |
c910ceff | 81 | |
94a86be0 | 82 | /// Overload for make_error_condition. |
faa00511 | 83 | inline error_condition |
84b63c01 | 84 | make_error_condition(future_errc __errc) noexcept |
94a86be0 | 85 | { return error_condition(static_cast<int>(__errc), future_category()); } |
c910ceff | 86 | |
8d1b99e2 BK |
87 | /** |
88 | * @brief Exception type thrown by futures. | |
89 | * @ingroup exceptions | |
90 | */ | |
c910ceff JW |
91 | class future_error : public logic_error |
92 | { | |
c36abf03 | 93 | error_code _M_code; |
8d1b99e2 | 94 | |
c910ceff | 95 | public: |
b3eed6fe JW |
96 | explicit future_error(error_code __ec) |
97 | : logic_error("std::future_error"), _M_code(__ec) | |
c910ceff JW |
98 | { } |
99 | ||
84b63c01 | 100 | virtual ~future_error() noexcept; |
c910ceff | 101 | |
faa00511 | 102 | virtual const char* |
84b63c01 | 103 | what() const noexcept; |
c910ceff | 104 | |
faa00511 | 105 | const error_code& |
84b63c01 | 106 | code() const noexcept { return _M_code; } |
c910ceff JW |
107 | }; |
108 | ||
3259554a | 109 | // Forward declarations. |
c36abf03 | 110 | template<typename _Res> |
b3eed6fe | 111 | class future; |
3259554a | 112 | |
c36abf03 | 113 | template<typename _Res> |
3259554a BK |
114 | class shared_future; |
115 | ||
b3eed6fe JW |
116 | template<typename _Res> |
117 | class atomic_future; | |
118 | ||
faa00511 | 119 | template<typename _Signature> |
3259554a BK |
120 | class packaged_task; |
121 | ||
c36abf03 | 122 | template<typename _Res> |
3259554a BK |
123 | class promise; |
124 | ||
94a86be0 | 125 | /// Launch code for futures |
faa00511 JW |
126 | enum class launch |
127 | { | |
128 | async = 1, | |
129 | deferred = 2 | |
94a86be0 BK |
130 | }; |
131 | ||
a4eeb822 | 132 | constexpr launch operator&(launch __x, launch __y) |
faa00511 JW |
133 | { |
134 | return static_cast<launch>( | |
135 | static_cast<int>(__x) & static_cast<int>(__y)); | |
136 | } | |
137 | ||
a4eeb822 | 138 | constexpr launch operator|(launch __x, launch __y) |
faa00511 JW |
139 | { |
140 | return static_cast<launch>( | |
141 | static_cast<int>(__x) | static_cast<int>(__y)); | |
142 | } | |
143 | ||
a4eeb822 | 144 | constexpr launch operator^(launch __x, launch __y) |
faa00511 JW |
145 | { |
146 | return static_cast<launch>( | |
147 | static_cast<int>(__x) ^ static_cast<int>(__y)); | |
148 | } | |
149 | ||
a4eeb822 | 150 | constexpr launch operator~(launch __x) |
faa00511 JW |
151 | { return static_cast<launch>(~static_cast<int>(__x)); } |
152 | ||
153 | inline launch& operator&=(launch& __x, launch __y) | |
154 | { return __x = __x & __y; } | |
155 | ||
156 | inline launch& operator|=(launch& __x, launch __y) | |
157 | { return __x = __x | __y; } | |
158 | ||
159 | inline launch& operator^=(launch& __x, launch __y) | |
160 | { return __x = __x ^ __y; } | |
161 | ||
94a86be0 | 162 | /// Status code for futures |
faa00511 | 163 | enum class future_status |
94a86be0 BK |
164 | { |
165 | ready, | |
166 | timeout, | |
167 | deferred | |
168 | }; | |
b3eed6fe JW |
169 | |
170 | template<typename _Fn, typename... _Args> | |
73c5c5bb | 171 | future<typename result_of<_Fn(_Args...)>::type> |
b3eed6fe JW |
172 | async(launch __policy, _Fn&& __fn, _Args&&... __args); |
173 | ||
be7f7822 JW |
174 | template<typename _FnCheck, typename _Fn, typename... _Args> |
175 | struct __async_sfinae_helper | |
176 | { | |
177 | typedef future<typename result_of<_Fn(_Args...)>::type> type; | |
178 | }; | |
179 | ||
180 | template<typename _Fn, typename... _Args> | |
181 | struct __async_sfinae_helper<launch, _Fn, _Args...> | |
182 | { }; | |
183 | ||
b3eed6fe | 184 | template<typename _Fn, typename... _Args> |
73c5c5bb | 185 | typename |
be7f7822 | 186 | __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type |
b3eed6fe JW |
187 | async(_Fn&& __fn, _Args&&... __args); |
188 | ||
41ca4246 BK |
189 | #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \ |
190 | && defined(_GLIBCXX_ATOMIC_BUILTINS_4) | |
191 | ||
c36abf03 BK |
192 | /// Base class and enclosing scope. |
193 | struct __future_base | |
c910ceff | 194 | { |
c36abf03 BK |
195 | /// Base class for results. |
196 | struct _Result_base | |
197 | { | |
198 | exception_ptr _M_error; | |
c910ceff | 199 | |
c36abf03 BK |
200 | _Result_base(const _Result_base&) = delete; |
201 | _Result_base& operator=(const _Result_base&) = delete; | |
c910ceff | 202 | |
b3eed6fe | 203 | // _M_destroy() allows derived classes to control deallocation |
c36abf03 | 204 | virtual void _M_destroy() = 0; |
c910ceff | 205 | |
c36abf03 BK |
206 | struct _Deleter |
207 | { | |
208 | void operator()(_Result_base* __fr) const { __fr->_M_destroy(); } | |
209 | }; | |
c910ceff | 210 | |
c36abf03 | 211 | protected: |
e9599233 BK |
212 | _Result_base(); |
213 | virtual ~_Result_base(); | |
c36abf03 | 214 | }; |
20f2653e | 215 | |
c36abf03 BK |
216 | /// Result. |
217 | template<typename _Res> | |
218 | struct _Result : _Result_base | |
219 | { | |
220 | private: | |
221 | typedef alignment_of<_Res> __a_of; | |
222 | typedef aligned_storage<sizeof(_Res), __a_of::value> __align_storage; | |
223 | typedef typename __align_storage::type __align_type; | |
224 | ||
225 | __align_type _M_storage; | |
226 | bool _M_initialized; | |
227 | ||
228 | public: | |
84b63c01 | 229 | _Result() noexcept : _M_initialized() { } |
c36abf03 BK |
230 | |
231 | ~_Result() | |
232 | { | |
233 | if (_M_initialized) | |
234 | _M_value().~_Res(); | |
235 | } | |
236 | ||
237 | // Return lvalue, future will add const or rvalue-reference | |
faa00511 | 238 | _Res& |
84b63c01 | 239 | _M_value() noexcept { return *static_cast<_Res*>(_M_addr()); } |
c36abf03 BK |
240 | |
241 | void | |
242 | _M_set(const _Res& __res) | |
243 | { | |
244 | ::new (_M_addr()) _Res(__res); | |
245 | _M_initialized = true; | |
246 | } | |
247 | ||
248 | void | |
249 | _M_set(_Res&& __res) | |
250 | { | |
abcd7e08 | 251 | ::new (_M_addr()) _Res(std::move(__res)); |
c36abf03 BK |
252 | _M_initialized = true; |
253 | } | |
254 | ||
255 | private: | |
256 | void _M_destroy() { delete this; } | |
257 | ||
84b63c01 | 258 | void* _M_addr() noexcept { return static_cast<void*>(&_M_storage); } |
c910ceff JW |
259 | }; |
260 | ||
c36abf03 BK |
261 | /// A unique_ptr based on the instantiating type. |
262 | template<typename _Res> | |
c4d9f419 | 263 | using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>; |
c910ceff | 264 | |
b3eed6fe JW |
265 | /// Result_alloc. |
266 | template<typename _Res, typename _Alloc> | |
0fd76d8e | 267 | struct _Result_alloc : _Result<_Res>, _Alloc |
b3eed6fe JW |
268 | { |
269 | typedef typename _Alloc::template rebind<_Result_alloc>::other | |
270 | __allocator_type; | |
271 | ||
272 | explicit | |
0fd76d8e | 273 | _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a) |
b3eed6fe JW |
274 | { } |
275 | ||
276 | private: | |
277 | void _M_destroy() | |
278 | { | |
0fd76d8e | 279 | __allocator_type __a(*this); |
b3eed6fe JW |
280 | __a.destroy(this); |
281 | __a.deallocate(this, 1); | |
282 | } | |
135a0d0a | 283 | }; |
b3eed6fe JW |
284 | |
285 | template<typename _Res, typename _Allocator> | |
c4d9f419 | 286 | static _Ptr<_Result_alloc<_Res, _Allocator>> |
b3eed6fe JW |
287 | _S_allocate_result(const _Allocator& __a) |
288 | { | |
289 | typedef _Result_alloc<_Res, _Allocator> __result_type; | |
290 | typename __result_type::__allocator_type __a2(__a); | |
291 | __result_type* __p = __a2.allocate(1); | |
292 | __try | |
135a0d0a | 293 | { |
b3eed6fe JW |
294 | __a2.construct(__p, __a); |
295 | } | |
296 | __catch(...) | |
297 | { | |
298 | __a2.deallocate(__p, 1); | |
299 | __throw_exception_again; | |
300 | } | |
c4d9f419 | 301 | return _Ptr<__result_type>(__p); |
b3eed6fe | 302 | } |
b3eed6fe | 303 | |
c910ceff | 304 | |
e9599233 BK |
305 | /// Base class for state between a promise and one or more |
306 | /// associated futures. | |
307 | class _State_base | |
c910ceff | 308 | { |
c4d9f419 | 309 | typedef _Ptr<_Result_base> _Ptr_type; |
c910ceff | 310 | |
c36abf03 BK |
311 | _Ptr_type _M_result; |
312 | mutex _M_mutex; | |
313 | condition_variable _M_cond; | |
314 | atomic_flag _M_retrieved; | |
b3eed6fe | 315 | once_flag _M_once; |
c910ceff | 316 | |
c36abf03 | 317 | public: |
84b63c01 | 318 | _State_base() noexcept : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { } |
e9599233 BK |
319 | _State_base(const _State_base&) = delete; |
320 | _State_base& operator=(const _State_base&) = delete; | |
321 | virtual ~_State_base(); | |
c910ceff | 322 | |
c36abf03 BK |
323 | _Result_base& |
324 | wait() | |
c910ceff | 325 | { |
b3eed6fe | 326 | _M_run_deferred(); |
c36abf03 BK |
327 | unique_lock<mutex> __lock(_M_mutex); |
328 | if (!_M_ready()) | |
e9599233 | 329 | _M_cond.wait(__lock, std::bind<bool>(&_State_base::_M_ready, this)); |
c36abf03 | 330 | return *_M_result; |
c910ceff | 331 | } |
c910ceff | 332 | |
c36abf03 BK |
333 | template<typename _Rep, typename _Period> |
334 | bool | |
335 | wait_for(const chrono::duration<_Rep, _Period>& __rel) | |
336 | { | |
337 | unique_lock<mutex> __lock(_M_mutex); | |
e9599233 | 338 | auto __bound = std::bind<bool>(&_State_base::_M_ready, this); |
c36abf03 BK |
339 | return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound); |
340 | } | |
c910ceff | 341 | |
c36abf03 BK |
342 | template<typename _Clock, typename _Duration> |
343 | bool | |
344 | wait_until(const chrono::time_point<_Clock, _Duration>& __abs) | |
345 | { | |
346 | unique_lock<mutex> __lock(_M_mutex); | |
e9599233 | 347 | auto __bound = std::bind<bool>(&_State_base::_M_ready, this); |
c36abf03 BK |
348 | return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound); |
349 | } | |
c910ceff | 350 | |
c36abf03 | 351 | void |
b3eed6fe | 352 | _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false) |
c910ceff | 353 | { |
b3eed6fe JW |
354 | bool __set = __ignore_failure; |
355 | // all calls to this function are serialized, | |
356 | // side-effects of invoking __res only happen once | |
e9599233 | 357 | call_once(_M_once, &_State_base::_M_do_set, this, ref(__res), |
b3eed6fe JW |
358 | ref(__set)); |
359 | if (!__set) | |
360 | __throw_future_error(int(future_errc::promise_already_satisfied)); | |
c910ceff JW |
361 | } |
362 | ||
c910ceff | 363 | void |
c36abf03 | 364 | _M_break_promise(_Ptr_type __res) |
c910ceff | 365 | { |
c36abf03 BK |
366 | if (static_cast<bool>(__res)) |
367 | { | |
b3eed6fe | 368 | error_code __ec(make_error_code(future_errc::broken_promise)); |
c36abf03 BK |
369 | __res->_M_error = copy_exception(future_error(__ec)); |
370 | { | |
371 | lock_guard<mutex> __lock(_M_mutex); | |
372 | _M_result.swap(__res); | |
373 | } | |
374 | _M_cond.notify_all(); | |
375 | } | |
c910ceff JW |
376 | } |
377 | ||
b3eed6fe | 378 | // Called when this object is passed to a future. |
c910ceff | 379 | void |
c36abf03 | 380 | _M_set_retrieved_flag() |
c910ceff | 381 | { |
c36abf03 BK |
382 | if (_M_retrieved.test_and_set()) |
383 | __throw_future_error(int(future_errc::future_already_retrieved)); | |
c910ceff JW |
384 | } |
385 | ||
b3eed6fe JW |
386 | template<typename _Res, typename _Arg> |
387 | struct _Setter; | |
388 | ||
389 | // set lvalues | |
390 | template<typename _Res, typename _Arg> | |
391 | struct _Setter<_Res, _Arg&> | |
392 | { | |
393 | // check this is only used by promise<R>::set_value(const R&) | |
394 | // or promise<R>::set_value(R&) | |
395 | static_assert(is_same<_Res, _Arg&>::value // promise<R&> | |
396 | || is_same<const _Res, _Arg>::value, // promise<R> | |
397 | "Invalid specialisation"); | |
398 | ||
399 | typename promise<_Res>::_Ptr_type operator()() | |
400 | { | |
e9599233 | 401 | _State_base::_S_check(_M_promise->_M_future); |
b3eed6fe JW |
402 | _M_promise->_M_storage->_M_set(_M_arg); |
403 | return std::move(_M_promise->_M_storage); | |
404 | } | |
405 | promise<_Res>* _M_promise; | |
406 | _Arg& _M_arg; | |
407 | }; | |
408 | ||
409 | // set rvalues | |
410 | template<typename _Res> | |
411 | struct _Setter<_Res, _Res&&> | |
412 | { | |
413 | typename promise<_Res>::_Ptr_type operator()() | |
414 | { | |
e9599233 | 415 | _State_base::_S_check(_M_promise->_M_future); |
b3eed6fe JW |
416 | _M_promise->_M_storage->_M_set(std::move(_M_arg)); |
417 | return std::move(_M_promise->_M_storage); | |
418 | } | |
419 | promise<_Res>* _M_promise; | |
420 | _Res& _M_arg; | |
421 | }; | |
422 | ||
423 | struct __exception_ptr_tag { }; | |
424 | ||
425 | // set exceptions | |
426 | template<typename _Res> | |
427 | struct _Setter<_Res, __exception_ptr_tag> | |
428 | { | |
429 | typename promise<_Res>::_Ptr_type operator()() | |
430 | { | |
e9599233 | 431 | _State_base::_S_check(_M_promise->_M_future); |
b3eed6fe JW |
432 | _M_promise->_M_storage->_M_error = _M_ex; |
433 | return std::move(_M_promise->_M_storage); | |
434 | } | |
435 | ||
436 | promise<_Res>* _M_promise; | |
437 | exception_ptr& _M_ex; | |
438 | }; | |
439 | ||
440 | template<typename _Res, typename _Arg> | |
441 | static _Setter<_Res, _Arg&&> | |
442 | __setter(promise<_Res>* __prom, _Arg&& __arg) | |
443 | { | |
444 | return _Setter<_Res, _Arg&&>{ __prom, __arg }; | |
445 | } | |
446 | ||
447 | template<typename _Res> | |
448 | static _Setter<_Res, __exception_ptr_tag> | |
449 | __setter(exception_ptr& __ex, promise<_Res>* __prom) | |
450 | { | |
451 | return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex }; | |
452 | } | |
453 | ||
454 | static _Setter<void, void> | |
455 | __setter(promise<void>* __prom); | |
456 | ||
457 | template<typename _Tp> | |
458 | static bool | |
459 | _S_check(const shared_ptr<_Tp>& __p) | |
460 | { | |
461 | if (!static_cast<bool>(__p)) | |
462 | __throw_future_error((int)future_errc::no_state); | |
463 | } | |
464 | ||
c910ceff | 465 | private: |
b3eed6fe JW |
466 | void |
467 | _M_do_set(function<_Ptr_type()>& __f, bool& __set) | |
c36abf03 | 468 | { |
b3eed6fe JW |
469 | _Ptr_type __res = __f(); |
470 | { | |
471 | lock_guard<mutex> __lock(_M_mutex); | |
472 | _M_result.swap(__res); | |
473 | } | |
474 | _M_cond.notify_all(); | |
475 | __set = true; | |
c36abf03 | 476 | } |
c910ceff | 477 | |
84b63c01 | 478 | bool _M_ready() const noexcept { return static_cast<bool>(_M_result); } |
b3eed6fe JW |
479 | |
480 | virtual void _M_run_deferred() { } | |
c910ceff | 481 | }; |
b3eed6fe | 482 | |
4880236e | 483 | template<typename _BoundFn, typename = typename _BoundFn::result_type> |
b3eed6fe JW |
484 | class _Deferred_state; |
485 | ||
4880236e | 486 | template<typename _BoundFn, typename = typename _BoundFn::result_type> |
b3eed6fe JW |
487 | class _Async_state; |
488 | ||
489 | template<typename _Signature> | |
490 | class _Task_state; | |
491 | ||
4880236e JW |
492 | template<typename _BoundFn> |
493 | static std::shared_ptr<_State_base> | |
494 | _S_make_deferred_state(_BoundFn&& __fn); | |
495 | ||
496 | template<typename _BoundFn> | |
497 | static std::shared_ptr<_State_base> | |
498 | _S_make_async_state(_BoundFn&& __fn); | |
499 | ||
500 | template<typename _Res_ptr, typename _Res> | |
b3eed6fe | 501 | struct _Task_setter; |
4880236e JW |
502 | |
503 | template<typename _Res_ptr, typename _BoundFn> | |
504 | class _Task_setter_helper | |
505 | { | |
506 | typedef typename remove_reference<_BoundFn>::type::result_type __res; | |
507 | public: | |
508 | typedef _Task_setter<_Res_ptr, __res> __type; | |
509 | }; | |
510 | ||
511 | template<typename _Res_ptr, typename _BoundFn> | |
512 | static typename _Task_setter_helper<_Res_ptr, _BoundFn>::__type | |
513 | _S_task_setter(_Res_ptr& __ptr, _BoundFn&& __call) | |
514 | { | |
515 | typedef _Task_setter_helper<_Res_ptr, _BoundFn> __helper_type; | |
516 | typedef typename __helper_type::__type _Setter; | |
517 | return _Setter{ __ptr, std::ref(__call) }; | |
518 | } | |
c36abf03 | 519 | }; |
c910ceff | 520 | |
c36abf03 BK |
521 | /// Partial specialization for reference types. |
522 | template<typename _Res> | |
523 | struct __future_base::_Result<_Res&> : __future_base::_Result_base | |
524 | { | |
84b63c01 | 525 | _Result() noexcept : _M_value_ptr() { } |
c910ceff | 526 | |
84b63c01 | 527 | void _M_set(_Res& __res) noexcept { _M_value_ptr = &__res; } |
b3eed6fe | 528 | |
84b63c01 | 529 | _Res& _M_get() noexcept { return *_M_value_ptr; } |
b3eed6fe JW |
530 | |
531 | private: | |
c36abf03 | 532 | _Res* _M_value_ptr; |
faa00511 | 533 | |
c910ceff JW |
534 | void _M_destroy() { delete this; } |
535 | }; | |
536 | ||
c36abf03 | 537 | /// Explicit specialization for void. |
c910ceff | 538 | template<> |
c36abf03 | 539 | struct __future_base::_Result<void> : __future_base::_Result_base |
c910ceff | 540 | { |
c36abf03 | 541 | private: |
c910ceff JW |
542 | void _M_destroy() { delete this; } |
543 | }; | |
544 | ||
c36abf03 | 545 | |
b3eed6fe | 546 | /// Common implementation for future and shared_future. |
c36abf03 BK |
547 | template<typename _Res> |
548 | class __basic_future : public __future_base | |
c910ceff | 549 | { |
c36abf03 | 550 | protected: |
e9599233 | 551 | typedef shared_ptr<_State_base> __state_type; |
c36abf03 BK |
552 | typedef __future_base::_Result<_Res>& __result_type; |
553 | ||
554 | private: | |
555 | __state_type _M_state; | |
556 | ||
c910ceff | 557 | public: |
c36abf03 BK |
558 | // Disable copying. |
559 | __basic_future(const __basic_future&) = delete; | |
560 | __basic_future& operator=(const __basic_future&) = delete; | |
c910ceff | 561 | |
faa00511 | 562 | bool |
84b63c01 | 563 | valid() const noexcept { return static_cast<bool>(_M_state); } |
c910ceff | 564 | |
faa00511 | 565 | void |
5262c72a JW |
566 | wait() const |
567 | { | |
e9599233 | 568 | _State_base::_S_check(_M_state); |
5262c72a JW |
569 | _M_state->wait(); |
570 | } | |
c910ceff JW |
571 | |
572 | template<typename _Rep, typename _Period> | |
573 | bool | |
574 | wait_for(const chrono::duration<_Rep, _Period>& __rel) const | |
5262c72a | 575 | { |
e9599233 | 576 | _State_base::_S_check(_M_state); |
5262c72a JW |
577 | return _M_state->wait_for(__rel); |
578 | } | |
c910ceff JW |
579 | |
580 | template<typename _Clock, typename _Duration> | |
581 | bool | |
582 | wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const | |
5262c72a | 583 | { |
e9599233 | 584 | _State_base::_S_check(_M_state); |
5262c72a JW |
585 | return _M_state->wait_until(__abs); |
586 | } | |
c910ceff JW |
587 | |
588 | protected: | |
c36abf03 BK |
589 | /// Wait for the state to be ready and rethrow any stored exception |
590 | __result_type | |
c910ceff JW |
591 | _M_get_result() |
592 | { | |
e9599233 | 593 | _State_base::_S_check(_M_state); |
b3eed6fe | 594 | _Result_base& __res = _M_state->wait(); |
c910ceff JW |
595 | if (!(__res._M_error == 0)) |
596 | rethrow_exception(__res._M_error); | |
c36abf03 | 597 | return static_cast<__result_type>(__res); |
c910ceff JW |
598 | } |
599 | ||
84b63c01 | 600 | void _M_swap(__basic_future& __that) noexcept |
b3eed6fe JW |
601 | { |
602 | _M_state.swap(__that._M_state); | |
603 | } | |
604 | ||
605 | // Construction of a future by promise::get_future() | |
c910ceff | 606 | explicit |
c36abf03 | 607 | __basic_future(const __state_type& __state) : _M_state(__state) |
c910ceff | 608 | { |
e9599233 | 609 | _State_base::_S_check(_M_state); |
b3eed6fe | 610 | _M_state->_M_set_retrieved_flag(); |
c910ceff JW |
611 | } |
612 | ||
c36abf03 | 613 | // Copy construction from a shared_future |
c910ceff | 614 | explicit |
84b63c01 | 615 | __basic_future(const shared_future<_Res>&) noexcept; |
c910ceff | 616 | |
b3eed6fe | 617 | // Move construction from a shared_future |
c910ceff | 618 | explicit |
84b63c01 | 619 | __basic_future(shared_future<_Res>&&) noexcept; |
b3eed6fe JW |
620 | |
621 | // Move construction from a future | |
622 | explicit | |
84b63c01 | 623 | __basic_future(future<_Res>&&) noexcept; |
b3eed6fe | 624 | |
84b63c01 | 625 | constexpr __basic_future() noexcept : _M_state() { } |
b3eed6fe JW |
626 | |
627 | struct _Reset | |
628 | { | |
84b63c01 | 629 | explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { } |
b3eed6fe JW |
630 | ~_Reset() { _M_fut._M_state.reset(); } |
631 | __basic_future& _M_fut; | |
632 | }; | |
c910ceff JW |
633 | }; |
634 | ||
c36abf03 | 635 | |
b3eed6fe | 636 | /// Primary template for future. |
c36abf03 | 637 | template<typename _Res> |
b3eed6fe | 638 | class future : public __basic_future<_Res> |
c910ceff | 639 | { |
c36abf03 | 640 | friend class promise<_Res>; |
b3eed6fe JW |
641 | template<typename> friend class packaged_task; |
642 | template<typename _Fn, typename... _Args> | |
73c5c5bb | 643 | friend future<typename result_of<_Fn(_Args...)>::type> |
b3eed6fe | 644 | async(launch, _Fn&&, _Args&&...); |
c36abf03 BK |
645 | |
646 | typedef __basic_future<_Res> _Base_type; | |
647 | typedef typename _Base_type::__state_type __state_type; | |
c36abf03 BK |
648 | |
649 | explicit | |
b3eed6fe | 650 | future(const __state_type& __state) : _Base_type(__state) { } |
c910ceff JW |
651 | |
652 | public: | |
84b63c01 | 653 | constexpr future() noexcept : _Base_type() { } |
b3eed6fe | 654 | |
c910ceff | 655 | /// Move constructor |
84b63c01 | 656 | future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } |
c910ceff | 657 | |
c36abf03 | 658 | // Disable copying |
b3eed6fe JW |
659 | future(const future&) = delete; |
660 | future& operator=(const future&) = delete; | |
661 | ||
84b63c01 | 662 | future& operator=(future&& __fut) noexcept |
b3eed6fe JW |
663 | { |
664 | future(std::move(__fut))._M_swap(*this); | |
665 | return *this; | |
666 | } | |
c910ceff | 667 | |
c36abf03 | 668 | /// Retrieving the value |
b3eed6fe | 669 | _Res |
c910ceff | 670 | get() |
b3eed6fe JW |
671 | { |
672 | typename _Base_type::_Reset __reset(*this); | |
673 | return std::move(this->_M_get_result()._M_value()); | |
674 | } | |
e3e08a1d JW |
675 | |
676 | shared_future<_Res> share(); | |
c910ceff | 677 | }; |
faa00511 | 678 | |
b3eed6fe | 679 | /// Partial specialization for future<R&> |
c36abf03 | 680 | template<typename _Res> |
b3eed6fe | 681 | class future<_Res&> : public __basic_future<_Res&> |
c910ceff | 682 | { |
c36abf03 | 683 | friend class promise<_Res&>; |
b3eed6fe JW |
684 | template<typename> friend class packaged_task; |
685 | template<typename _Fn, typename... _Args> | |
73c5c5bb | 686 | friend future<typename result_of<_Fn(_Args...)>::type> |
b3eed6fe | 687 | async(launch, _Fn&&, _Args&&...); |
c36abf03 BK |
688 | |
689 | typedef __basic_future<_Res&> _Base_type; | |
690 | typedef typename _Base_type::__state_type __state_type; | |
691 | ||
692 | explicit | |
b3eed6fe | 693 | future(const __state_type& __state) : _Base_type(__state) { } |
c36abf03 | 694 | |
c910ceff | 695 | public: |
84b63c01 | 696 | constexpr future() noexcept : _Base_type() { } |
b3eed6fe | 697 | |
c910ceff | 698 | /// Move constructor |
84b63c01 | 699 | future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } |
c910ceff | 700 | |
c36abf03 | 701 | // Disable copying |
b3eed6fe JW |
702 | future(const future&) = delete; |
703 | future& operator=(const future&) = delete; | |
704 | ||
84b63c01 | 705 | future& operator=(future&& __fut) noexcept |
b3eed6fe JW |
706 | { |
707 | future(std::move(__fut))._M_swap(*this); | |
708 | return *this; | |
709 | } | |
c910ceff | 710 | |
c36abf03 | 711 | /// Retrieving the value |
faa00511 | 712 | _Res& |
b3eed6fe JW |
713 | get() |
714 | { | |
715 | typename _Base_type::_Reset __reset(*this); | |
716 | return this->_M_get_result()._M_get(); | |
717 | } | |
e3e08a1d JW |
718 | |
719 | shared_future<_Res&> share(); | |
c36abf03 | 720 | }; |
c910ceff | 721 | |
b3eed6fe | 722 | /// Explicit specialization for future<void> |
c36abf03 | 723 | template<> |
b3eed6fe | 724 | class future<void> : public __basic_future<void> |
c36abf03 BK |
725 | { |
726 | friend class promise<void>; | |
b3eed6fe JW |
727 | template<typename> friend class packaged_task; |
728 | template<typename _Fn, typename... _Args> | |
73c5c5bb | 729 | friend future<typename result_of<_Fn(_Args...)>::type> |
b3eed6fe | 730 | async(launch, _Fn&&, _Args&&...); |
c910ceff | 731 | |
c36abf03 BK |
732 | typedef __basic_future<void> _Base_type; |
733 | typedef typename _Base_type::__state_type __state_type; | |
c910ceff JW |
734 | |
735 | explicit | |
b3eed6fe | 736 | future(const __state_type& __state) : _Base_type(__state) { } |
c910ceff | 737 | |
c910ceff | 738 | public: |
84b63c01 | 739 | constexpr future() noexcept : _Base_type() { } |
b3eed6fe | 740 | |
c910ceff | 741 | /// Move constructor |
84b63c01 | 742 | future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } |
c910ceff | 743 | |
c36abf03 | 744 | // Disable copying |
b3eed6fe JW |
745 | future(const future&) = delete; |
746 | future& operator=(const future&) = delete; | |
747 | ||
84b63c01 | 748 | future& operator=(future&& __fut) noexcept |
b3eed6fe JW |
749 | { |
750 | future(std::move(__fut))._M_swap(*this); | |
751 | return *this; | |
752 | } | |
c910ceff | 753 | |
c36abf03 | 754 | /// Retrieving the value |
faa00511 | 755 | void |
b3eed6fe JW |
756 | get() |
757 | { | |
758 | typename _Base_type::_Reset __reset(*this); | |
759 | this->_M_get_result(); | |
760 | } | |
e3e08a1d JW |
761 | |
762 | shared_future<void> share(); | |
c910ceff JW |
763 | }; |
764 | ||
c36abf03 BK |
765 | |
766 | /// Primary template for shared_future. | |
767 | template<typename _Res> | |
768 | class shared_future : public __basic_future<_Res> | |
c910ceff | 769 | { |
c36abf03 BK |
770 | typedef __basic_future<_Res> _Base_type; |
771 | ||
c910ceff | 772 | public: |
84b63c01 | 773 | constexpr shared_future() noexcept : _Base_type() { } |
b3eed6fe | 774 | |
c910ceff JW |
775 | /// Copy constructor |
776 | shared_future(const shared_future& __sf) : _Base_type(__sf) { } | |
777 | ||
b3eed6fe | 778 | /// Construct from a future rvalue |
84b63c01 | 779 | shared_future(future<_Res>&& __uf) noexcept |
c910ceff JW |
780 | : _Base_type(std::move(__uf)) |
781 | { } | |
782 | ||
b3eed6fe | 783 | /// Construct from a shared_future rvalue |
84b63c01 | 784 | shared_future(shared_future&& __sf) noexcept |
b3eed6fe JW |
785 | : _Base_type(std::move(__sf)) |
786 | { } | |
787 | ||
788 | shared_future& operator=(const shared_future& __sf) | |
789 | { | |
790 | shared_future(__sf)._M_swap(*this); | |
791 | return *this; | |
792 | } | |
793 | ||
84b63c01 | 794 | shared_future& operator=(shared_future&& __sf) noexcept |
b3eed6fe JW |
795 | { |
796 | shared_future(std::move(__sf))._M_swap(*this); | |
797 | return *this; | |
798 | } | |
c910ceff | 799 | |
c36abf03 BK |
800 | /// Retrieving the value |
801 | const _Res& | |
c910ceff | 802 | get() |
b3eed6fe | 803 | { |
c36abf03 BK |
804 | typename _Base_type::__result_type __r = this->_M_get_result(); |
805 | _Res& __rs(__r._M_value()); | |
806 | return __rs; | |
807 | } | |
c910ceff | 808 | }; |
faa00511 | 809 | |
c36abf03 BK |
810 | /// Partial specialization for shared_future<R&> |
811 | template<typename _Res> | |
812 | class shared_future<_Res&> : public __basic_future<_Res&> | |
c910ceff | 813 | { |
c36abf03 BK |
814 | typedef __basic_future<_Res&> _Base_type; |
815 | ||
c910ceff | 816 | public: |
84b63c01 | 817 | constexpr shared_future() noexcept : _Base_type() { } |
b3eed6fe | 818 | |
c910ceff JW |
819 | /// Copy constructor |
820 | shared_future(const shared_future& __sf) : _Base_type(__sf) { } | |
821 | ||
b3eed6fe | 822 | /// Construct from a future rvalue |
84b63c01 | 823 | shared_future(future<_Res&>&& __uf) noexcept |
c910ceff JW |
824 | : _Base_type(std::move(__uf)) |
825 | { } | |
826 | ||
b3eed6fe | 827 | /// Construct from a shared_future rvalue |
84b63c01 | 828 | shared_future(shared_future&& __sf) noexcept |
b3eed6fe JW |
829 | : _Base_type(std::move(__sf)) |
830 | { } | |
831 | ||
832 | shared_future& operator=(const shared_future& __sf) | |
833 | { | |
834 | shared_future(__sf)._M_swap(*this); | |
835 | return *this; | |
836 | } | |
837 | ||
84b63c01 | 838 | shared_future& operator=(shared_future&& __sf) noexcept |
b3eed6fe JW |
839 | { |
840 | shared_future(std::move(__sf))._M_swap(*this); | |
841 | return *this; | |
842 | } | |
c910ceff | 843 | |
c36abf03 | 844 | /// Retrieving the value |
faa00511 | 845 | _Res& |
b3eed6fe | 846 | get() { return this->_M_get_result()._M_get(); } |
c910ceff JW |
847 | }; |
848 | ||
c36abf03 | 849 | /// Explicit specialization for shared_future<void> |
c910ceff | 850 | template<> |
c36abf03 | 851 | class shared_future<void> : public __basic_future<void> |
c910ceff | 852 | { |
c36abf03 BK |
853 | typedef __basic_future<void> _Base_type; |
854 | ||
c910ceff | 855 | public: |
84b63c01 | 856 | constexpr shared_future() noexcept : _Base_type() { } |
b3eed6fe | 857 | |
c910ceff JW |
858 | /// Copy constructor |
859 | shared_future(const shared_future& __sf) : _Base_type(__sf) { } | |
860 | ||
b3eed6fe | 861 | /// Construct from a future rvalue |
84b63c01 | 862 | shared_future(future<void>&& __uf) noexcept |
c910ceff JW |
863 | : _Base_type(std::move(__uf)) |
864 | { } | |
865 | ||
b3eed6fe | 866 | /// Construct from a shared_future rvalue |
84b63c01 | 867 | shared_future(shared_future&& __sf) noexcept |
b3eed6fe JW |
868 | : _Base_type(std::move(__sf)) |
869 | { } | |
870 | ||
871 | shared_future& operator=(const shared_future& __sf) | |
872 | { | |
873 | shared_future(__sf)._M_swap(*this); | |
874 | return *this; | |
875 | } | |
876 | ||
84b63c01 | 877 | shared_future& operator=(shared_future&& __sf) noexcept |
b3eed6fe JW |
878 | { |
879 | shared_future(std::move(__sf))._M_swap(*this); | |
880 | return *this; | |
881 | } | |
c910ceff | 882 | |
c36abf03 | 883 | // Retrieving the value |
faa00511 | 884 | void |
c36abf03 | 885 | get() { this->_M_get_result(); } |
c910ceff JW |
886 | }; |
887 | ||
c36abf03 BK |
888 | // Now we can define the protected __basic_future constructors. |
889 | template<typename _Res> | |
19501406 | 890 | inline __basic_future<_Res>:: |
84b63c01 | 891 | __basic_future(const shared_future<_Res>& __sf) noexcept |
c910ceff JW |
892 | : _M_state(__sf._M_state) |
893 | { } | |
894 | ||
c36abf03 | 895 | template<typename _Res> |
19501406 | 896 | inline __basic_future<_Res>:: |
84b63c01 | 897 | __basic_future(shared_future<_Res>&& __sf) noexcept |
b3eed6fe JW |
898 | : _M_state(std::move(__sf._M_state)) |
899 | { } | |
900 | ||
901 | template<typename _Res> | |
19501406 | 902 | inline __basic_future<_Res>:: |
84b63c01 | 903 | __basic_future(future<_Res>&& __uf) noexcept |
c910ceff JW |
904 | : _M_state(std::move(__uf._M_state)) |
905 | { } | |
906 | ||
e3e08a1d JW |
907 | template<typename _Res> |
908 | inline shared_future<_Res> | |
909 | future<_Res>::share() | |
910 | { return shared_future<_Res>(std::move(*this)); } | |
911 | ||
912 | template<typename _Res> | |
913 | inline shared_future<_Res&> | |
914 | future<_Res&>::share() | |
915 | { return shared_future<_Res&>(std::move(*this)); } | |
916 | ||
917 | inline shared_future<void> | |
918 | future<void>::share() | |
919 | { return shared_future<void>(std::move(*this)); } | |
c36abf03 BK |
920 | |
921 | /// Primary template for promise | |
922 | template<typename _Res> | |
c910ceff JW |
923 | class promise |
924 | { | |
c4d9f419 JW |
925 | typedef __future_base::_State_base _State; |
926 | typedef __future_base::_Result<_Res> _Res_type; | |
927 | typedef __future_base::_Ptr<_Res_type> _Ptr_type; | |
b3eed6fe | 928 | template<typename, typename> friend class _State::_Setter; |
faa00511 | 929 | |
c36abf03 | 930 | shared_ptr<_State> _M_future; |
b3eed6fe | 931 | _Ptr_type _M_storage; |
c36abf03 | 932 | |
c910ceff JW |
933 | public: |
934 | promise() | |
19501406 PC |
935 | : _M_future(std::make_shared<_State>()), |
936 | _M_storage(new _Res_type()) | |
c910ceff JW |
937 | { } |
938 | ||
84b63c01 | 939 | promise(promise&& __rhs) noexcept |
c910ceff | 940 | : _M_future(std::move(__rhs._M_future)), |
19501406 | 941 | _M_storage(std::move(__rhs._M_storage)) |
c910ceff JW |
942 | { } |
943 | ||
c910ceff | 944 | template<typename _Allocator> |
b3eed6fe JW |
945 | promise(allocator_arg_t, const _Allocator& __a) |
946 | : _M_future(std::allocate_shared<_State>(__a)), | |
135a0d0a | 947 | _M_storage(__future_base::_S_allocate_result<_Res>(__a)) |
b3eed6fe | 948 | { } |
c910ceff | 949 | |
376d7c51 JW |
950 | template<typename _Allocator> |
951 | promise(allocator_arg_t, const _Allocator&, promise&& __rhs) | |
952 | : _M_future(std::move(__rhs._M_future)), | |
953 | _M_storage(std::move(__rhs._M_storage)) | |
954 | { } | |
955 | ||
c910ceff JW |
956 | promise(const promise&) = delete; |
957 | ||
958 | ~promise() | |
959 | { | |
960 | if (static_cast<bool>(_M_future) && !_M_future.unique()) | |
961 | _M_future->_M_break_promise(std::move(_M_storage)); | |
962 | } | |
963 | ||
c36abf03 | 964 | // Assignment |
c910ceff | 965 | promise& |
84b63c01 | 966 | operator=(promise&& __rhs) noexcept |
c910ceff JW |
967 | { |
968 | promise(std::move(__rhs)).swap(*this); | |
969 | return *this; | |
970 | } | |
971 | ||
972 | promise& operator=(const promise&) = delete; | |
973 | ||
974 | void | |
84b63c01 | 975 | swap(promise& __rhs) noexcept |
c910ceff JW |
976 | { |
977 | _M_future.swap(__rhs._M_future); | |
978 | _M_storage.swap(__rhs._M_storage); | |
979 | } | |
980 | ||
c36abf03 | 981 | // Retrieving the result |
b3eed6fe | 982 | future<_Res> |
c910ceff | 983 | get_future() |
b3eed6fe | 984 | { return future<_Res>(_M_future); } |
c910ceff | 985 | |
c36abf03 | 986 | // Setting the result |
c910ceff | 987 | void |
c36abf03 | 988 | set_value(const _Res& __r) |
c910ceff | 989 | { |
b3eed6fe JW |
990 | auto __setter = _State::__setter(this, __r); |
991 | _M_future->_M_set_result(std::move(__setter)); | |
c910ceff JW |
992 | } |
993 | ||
994 | void | |
c36abf03 | 995 | set_value(_Res&& __r) |
c910ceff | 996 | { |
b3eed6fe JW |
997 | auto __setter = _State::__setter(this, std::move(__r)); |
998 | _M_future->_M_set_result(std::move(__setter)); | |
c910ceff JW |
999 | } |
1000 | ||
1001 | void | |
1002 | set_exception(exception_ptr __p) | |
1003 | { | |
b3eed6fe JW |
1004 | auto __setter = _State::__setter(__p, this); |
1005 | _M_future->_M_set_result(std::move(__setter)); | |
c910ceff | 1006 | } |
c910ceff JW |
1007 | }; |
1008 | ||
19501406 PC |
1009 | template<typename _Res> |
1010 | inline void | |
84b63c01 | 1011 | swap(promise<_Res>& __x, promise<_Res>& __y) noexcept |
19501406 PC |
1012 | { __x.swap(__y); } |
1013 | ||
135a0d0a PC |
1014 | template<typename _Res, typename _Alloc> |
1015 | struct uses_allocator<promise<_Res>, _Alloc> | |
1016 | : public true_type { }; | |
1017 | ||
1018 | ||
c36abf03 BK |
1019 | /// Partial specialization for promise<R&> |
1020 | template<typename _Res> | |
1021 | class promise<_Res&> | |
c910ceff | 1022 | { |
c4d9f419 JW |
1023 | typedef __future_base::_State_base _State; |
1024 | typedef __future_base::_Result<_Res&> _Res_type; | |
1025 | typedef __future_base::_Ptr<_Res_type> _Ptr_type; | |
b3eed6fe | 1026 | template<typename, typename> friend class _State::_Setter; |
c36abf03 BK |
1027 | |
1028 | shared_ptr<_State> _M_future; | |
b3eed6fe | 1029 | _Ptr_type _M_storage; |
c36abf03 | 1030 | |
c910ceff JW |
1031 | public: |
1032 | promise() | |
19501406 PC |
1033 | : _M_future(std::make_shared<_State>()), |
1034 | _M_storage(new _Res_type()) | |
c910ceff JW |
1035 | { } |
1036 | ||
84b63c01 | 1037 | promise(promise&& __rhs) noexcept |
faa00511 | 1038 | : _M_future(std::move(__rhs._M_future)), |
c36abf03 | 1039 | _M_storage(std::move(__rhs._M_storage)) |
c910ceff JW |
1040 | { } |
1041 | ||
c910ceff | 1042 | template<typename _Allocator> |
b3eed6fe JW |
1043 | promise(allocator_arg_t, const _Allocator& __a) |
1044 | : _M_future(std::allocate_shared<_State>(__a)), | |
135a0d0a | 1045 | _M_storage(__future_base::_S_allocate_result<_Res&>(__a)) |
b3eed6fe | 1046 | { } |
c910ceff | 1047 | |
376d7c51 JW |
1048 | template<typename _Allocator> |
1049 | promise(allocator_arg_t, const _Allocator&, promise&& __rhs) | |
1050 | : _M_future(std::move(__rhs._M_future)), | |
1051 | _M_storage(std::move(__rhs._M_storage)) | |
1052 | { } | |
1053 | ||
c910ceff JW |
1054 | promise(const promise&) = delete; |
1055 | ||
1056 | ~promise() | |
1057 | { | |
1058 | if (static_cast<bool>(_M_future) && !_M_future.unique()) | |
1059 | _M_future->_M_break_promise(std::move(_M_storage)); | |
1060 | } | |
1061 | ||
c36abf03 | 1062 | // Assignment |
c910ceff | 1063 | promise& |
84b63c01 | 1064 | operator=(promise&& __rhs) noexcept |
c910ceff JW |
1065 | { |
1066 | promise(std::move(__rhs)).swap(*this); | |
1067 | return *this; | |
1068 | } | |
1069 | ||
1070 | promise& operator=(const promise&) = delete; | |
1071 | ||
1072 | void | |
84b63c01 | 1073 | swap(promise& __rhs) noexcept |
c910ceff JW |
1074 | { |
1075 | _M_future.swap(__rhs._M_future); | |
1076 | _M_storage.swap(__rhs._M_storage); | |
1077 | } | |
1078 | ||
c36abf03 | 1079 | // Retrieving the result |
b3eed6fe | 1080 | future<_Res&> |
c910ceff | 1081 | get_future() |
b3eed6fe | 1082 | { return future<_Res&>(_M_future); } |
c910ceff | 1083 | |
c36abf03 | 1084 | // Setting the result |
c910ceff | 1085 | void |
c36abf03 | 1086 | set_value(_Res& __r) |
c910ceff | 1087 | { |
b3eed6fe JW |
1088 | auto __setter = _State::__setter(this, __r); |
1089 | _M_future->_M_set_result(std::move(__setter)); | |
c910ceff JW |
1090 | } |
1091 | ||
1092 | void | |
1093 | set_exception(exception_ptr __p) | |
1094 | { | |
b3eed6fe JW |
1095 | auto __setter = _State::__setter(__p, this); |
1096 | _M_future->_M_set_result(std::move(__setter)); | |
c910ceff | 1097 | } |
c910ceff JW |
1098 | }; |
1099 | ||
c36abf03 | 1100 | /// Explicit specialization for promise<void> |
c910ceff JW |
1101 | template<> |
1102 | class promise<void> | |
1103 | { | |
c4d9f419 JW |
1104 | typedef __future_base::_State_base _State; |
1105 | typedef __future_base::_Result<void> _Res_type; | |
1106 | typedef __future_base::_Ptr<_Res_type> _Ptr_type; | |
b3eed6fe | 1107 | template<typename, typename> friend class _State::_Setter; |
c36abf03 | 1108 | |
b3eed6fe JW |
1109 | shared_ptr<_State> _M_future; |
1110 | _Ptr_type _M_storage; | |
c36abf03 | 1111 | |
c910ceff JW |
1112 | public: |
1113 | promise() | |
c36abf03 | 1114 | : _M_future(std::make_shared<_State>()), |
b3eed6fe | 1115 | _M_storage(new _Res_type()) |
c910ceff JW |
1116 | { } |
1117 | ||
84b63c01 | 1118 | promise(promise&& __rhs) noexcept |
c910ceff | 1119 | : _M_future(std::move(__rhs._M_future)), |
19501406 | 1120 | _M_storage(std::move(__rhs._M_storage)) |
c910ceff JW |
1121 | { } |
1122 | ||
c910ceff | 1123 | template<typename _Allocator> |
b3eed6fe JW |
1124 | promise(allocator_arg_t, const _Allocator& __a) |
1125 | : _M_future(std::allocate_shared<_State>(__a)), | |
135a0d0a | 1126 | _M_storage(__future_base::_S_allocate_result<void>(__a)) |
b3eed6fe | 1127 | { } |
c910ceff | 1128 | |
376d7c51 JW |
1129 | template<typename _Allocator> |
1130 | promise(allocator_arg_t, const _Allocator&, promise&& __rhs) | |
1131 | : _M_future(std::move(__rhs._M_future)), | |
1132 | _M_storage(std::move(__rhs._M_storage)) | |
1133 | { } | |
1134 | ||
c910ceff JW |
1135 | promise(const promise&) = delete; |
1136 | ||
1137 | ~promise() | |
1138 | { | |
1139 | if (static_cast<bool>(_M_future) && !_M_future.unique()) | |
1140 | _M_future->_M_break_promise(std::move(_M_storage)); | |
1141 | } | |
1142 | ||
c36abf03 | 1143 | // Assignment |
c910ceff | 1144 | promise& |
84b63c01 | 1145 | operator=(promise&& __rhs) noexcept |
c910ceff JW |
1146 | { |
1147 | promise(std::move(__rhs)).swap(*this); | |
1148 | return *this; | |
1149 | } | |
1150 | ||
1151 | promise& operator=(const promise&) = delete; | |
1152 | ||
1153 | void | |
84b63c01 | 1154 | swap(promise& __rhs) noexcept |
c910ceff JW |
1155 | { |
1156 | _M_future.swap(__rhs._M_future); | |
1157 | _M_storage.swap(__rhs._M_storage); | |
1158 | } | |
1159 | ||
c36abf03 | 1160 | // Retrieving the result |
b3eed6fe | 1161 | future<void> |
c910ceff | 1162 | get_future() |
b3eed6fe | 1163 | { return future<void>(_M_future); } |
c910ceff | 1164 | |
c36abf03 | 1165 | // Setting the result |
b3eed6fe JW |
1166 | void set_value(); |
1167 | ||
c910ceff | 1168 | void |
b3eed6fe | 1169 | set_exception(exception_ptr __p) |
c910ceff | 1170 | { |
b3eed6fe JW |
1171 | auto __setter = _State::__setter(__p, this); |
1172 | _M_future->_M_set_result(std::move(__setter)); | |
c910ceff | 1173 | } |
b3eed6fe | 1174 | }; |
c910ceff | 1175 | |
b3eed6fe JW |
1176 | // set void |
1177 | template<> | |
e9599233 | 1178 | struct __future_base::_State_base::_Setter<void, void> |
b3eed6fe JW |
1179 | { |
1180 | promise<void>::_Ptr_type operator()() | |
c910ceff | 1181 | { |
e9599233 | 1182 | _State_base::_S_check(_M_promise->_M_future); |
b3eed6fe | 1183 | return std::move(_M_promise->_M_storage); |
c910ceff JW |
1184 | } |
1185 | ||
b3eed6fe | 1186 | promise<void>* _M_promise; |
c910ceff JW |
1187 | }; |
1188 | ||
e9599233 BK |
1189 | inline __future_base::_State_base::_Setter<void, void> |
1190 | __future_base::_State_base::__setter(promise<void>* __prom) | |
b3eed6fe JW |
1191 | { |
1192 | return _Setter<void, void>{ __prom }; | |
1193 | } | |
1194 | ||
1195 | inline void | |
1196 | promise<void>::set_value() | |
1197 | { | |
1198 | auto __setter = _State::__setter(this); | |
1199 | _M_future->_M_set_result(std::move(__setter)); | |
1200 | } | |
1201 | ||
b3eed6fe | 1202 | |
4880236e | 1203 | template<typename _Ptr_type, typename _Res> |
b3eed6fe | 1204 | struct __future_base::_Task_setter |
c910ceff | 1205 | { |
4880236e | 1206 | _Ptr_type operator()() |
c910ceff | 1207 | { |
19501406 PC |
1208 | __try |
1209 | { | |
4880236e | 1210 | _M_result->_M_set(_M_fn()); |
19501406 PC |
1211 | } |
1212 | __catch(...) | |
1213 | { | |
4880236e | 1214 | _M_result->_M_error = current_exception(); |
19501406 | 1215 | } |
4880236e | 1216 | return std::move(_M_result); |
c910ceff | 1217 | } |
4880236e | 1218 | _Ptr_type& _M_result; |
b3eed6fe | 1219 | std::function<_Res()> _M_fn; |
c910ceff JW |
1220 | }; |
1221 | ||
4880236e JW |
1222 | template<typename _Ptr_type> |
1223 | struct __future_base::_Task_setter<_Ptr_type, void> | |
c910ceff | 1224 | { |
4880236e | 1225 | _Ptr_type operator()() |
c910ceff | 1226 | { |
19501406 PC |
1227 | __try |
1228 | { | |
1229 | _M_fn(); | |
1230 | } | |
1231 | __catch(...) | |
1232 | { | |
4880236e | 1233 | _M_result->_M_error = current_exception(); |
19501406 | 1234 | } |
4880236e | 1235 | return std::move(_M_result); |
c910ceff | 1236 | } |
4880236e | 1237 | _Ptr_type& _M_result; |
b3eed6fe | 1238 | std::function<void()> _M_fn; |
c910ceff JW |
1239 | }; |
1240 | ||
b3eed6fe | 1241 | template<typename _Res, typename... _Args> |
faa00511 | 1242 | struct __future_base::_Task_state<_Res(_Args...)> |
e9599233 | 1243 | : __future_base::_State_base |
b3eed6fe JW |
1244 | { |
1245 | typedef _Res _Res_type; | |
1246 | ||
1247 | _Task_state(std::function<_Res(_Args...)> __task) | |
1248 | : _M_result(new _Result<_Res>()), _M_task(std::move(__task)) | |
1249 | { } | |
1250 | ||
b3eed6fe JW |
1251 | template<typename _Func, typename _Alloc> |
1252 | _Task_state(_Func&& __task, const _Alloc& __a) | |
135a0d0a PC |
1253 | : _M_result(_S_allocate_result<_Res>(__a)), |
1254 | _M_task(allocator_arg, __a, std::move(__task)) | |
b3eed6fe | 1255 | { } |
b3eed6fe JW |
1256 | |
1257 | void | |
1258 | _M_run(_Args... __args) | |
1259 | { | |
1260 | // bound arguments decay so wrap lvalue references | |
4880236e JW |
1261 | auto __boundfn = std::__bind_simple(std::ref(_M_task), |
1262 | _S_maybe_wrap_ref(std::forward<_Args>(__args))...); | |
1263 | auto __setter = _S_task_setter(_M_result, std::move(__boundfn)); | |
b3eed6fe JW |
1264 | _M_set_result(std::move(__setter)); |
1265 | } | |
1266 | ||
c4d9f419 | 1267 | typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; |
b3eed6fe JW |
1268 | _Ptr_type _M_result; |
1269 | std::function<_Res(_Args...)> _M_task; | |
1270 | ||
1271 | template<typename _Tp> | |
1272 | static reference_wrapper<_Tp> | |
1273 | _S_maybe_wrap_ref(_Tp& __t) | |
1274 | { return std::ref(__t); } | |
1275 | ||
1276 | template<typename _Tp> | |
1277 | static typename enable_if<!is_lvalue_reference<_Tp>::value, | |
1278 | _Tp>::type&& | |
1279 | _S_maybe_wrap_ref(_Tp&& __t) | |
1280 | { return std::forward<_Tp>(__t); } | |
1281 | }; | |
c36abf03 | 1282 | |
376d7c51 | 1283 | template<typename _Task, typename _Fn, bool |
c4d9f419 JW |
1284 | = is_same<_Task, typename decay<_Fn>::type>::value> |
1285 | struct __constrain_pkgdtask | |
376d7c51 JW |
1286 | { typedef void __type; }; |
1287 | ||
1288 | template<typename _Task, typename _Fn> | |
c4d9f419 | 1289 | struct __constrain_pkgdtask<_Task, _Fn, true> |
376d7c51 JW |
1290 | { }; |
1291 | ||
3259554a | 1292 | /// packaged_task |
c36abf03 BK |
1293 | template<typename _Res, typename... _ArgTypes> |
1294 | class packaged_task<_Res(_ArgTypes...)> | |
c910ceff | 1295 | { |
b3eed6fe JW |
1296 | typedef __future_base::_Task_state<_Res(_ArgTypes...)> _State_type; |
1297 | shared_ptr<_State_type> _M_state; | |
c36abf03 | 1298 | |
c910ceff | 1299 | public: |
c36abf03 | 1300 | // Construction and destruction |
84b63c01 | 1301 | packaged_task() noexcept { } |
c910ceff | 1302 | |
376d7c51 JW |
1303 | template<typename _Allocator> |
1304 | explicit | |
1305 | packaged_task(allocator_arg_t, const _Allocator& __a) noexcept | |
1306 | { } | |
1307 | ||
1308 | template<typename _Fn, typename = typename | |
c4d9f419 | 1309 | __constrain_pkgdtask<packaged_task, _Fn>::__type> |
c910ceff | 1310 | explicit |
b3eed6fe | 1311 | packaged_task(_Fn&& __fn) |
e3e08a1d | 1312 | : _M_state(std::make_shared<_State_type>(std::forward<_Fn>(__fn))) |
b3eed6fe | 1313 | { } |
c910ceff | 1314 | |
376d7c51 | 1315 | template<typename _Fn, typename _Allocator, typename = typename |
c4d9f419 | 1316 | __constrain_pkgdtask<packaged_task, _Fn>::__type> |
c910ceff | 1317 | explicit |
e3e08a1d JW |
1318 | packaged_task(allocator_arg_t, const _Allocator& __a, _Fn&& __fn) |
1319 | : _M_state(std::allocate_shared<_State_type>(__a, | |
1320 | std::forward<_Fn>(__fn))) | |
c910ceff | 1321 | { } |
c910ceff | 1322 | |
b3eed6fe JW |
1323 | ~packaged_task() |
1324 | { | |
1325 | if (static_cast<bool>(_M_state) && !_M_state.unique()) | |
1326 | _M_state->_M_break_promise(std::move(_M_state->_M_result)); | |
1327 | } | |
c910ceff | 1328 | |
c36abf03 | 1329 | // No copy |
376d7c51 JW |
1330 | packaged_task(const packaged_task&) = delete; |
1331 | packaged_task& operator=(const packaged_task&) = delete; | |
1332 | ||
1333 | template<typename _Allocator> | |
1334 | explicit | |
1335 | packaged_task(allocator_arg_t, const _Allocator&, | |
1336 | const packaged_task&) = delete; | |
c910ceff | 1337 | |
c36abf03 | 1338 | // Move support |
84b63c01 | 1339 | packaged_task(packaged_task&& __other) noexcept |
c910ceff JW |
1340 | { this->swap(__other); } |
1341 | ||
376d7c51 JW |
1342 | template<typename _Allocator> |
1343 | explicit | |
1344 | packaged_task(allocator_arg_t, const _Allocator&, | |
1345 | packaged_task&& __other) noexcept | |
1346 | { this->swap(__other); } | |
1347 | ||
84b63c01 | 1348 | packaged_task& operator=(packaged_task&& __other) noexcept |
c910ceff JW |
1349 | { |
1350 | packaged_task(std::move(__other)).swap(*this); | |
1351 | return *this; | |
1352 | } | |
1353 | ||
1354 | void | |
84b63c01 | 1355 | swap(packaged_task& __other) noexcept |
b3eed6fe | 1356 | { _M_state.swap(__other._M_state); } |
c910ceff | 1357 | |
7a0269de | 1358 | bool |
84b63c01 | 1359 | valid() const noexcept |
7a0269de | 1360 | { return static_cast<bool>(_M_state); } |
c910ceff | 1361 | |
c36abf03 | 1362 | // Result retrieval |
b3eed6fe | 1363 | future<_Res> |
c910ceff | 1364 | get_future() |
b3eed6fe | 1365 | { return future<_Res>(_M_state); } |
c910ceff | 1366 | |
c36abf03 | 1367 | // Execution |
c910ceff JW |
1368 | void |
1369 | operator()(_ArgTypes... __args) | |
1370 | { | |
e9599233 | 1371 | __future_base::_State_base::_S_check(_M_state); |
b3eed6fe JW |
1372 | _M_state->_M_run(std::forward<_ArgTypes>(__args)...); |
1373 | } | |
8d1b99e2 | 1374 | |
b3eed6fe JW |
1375 | void |
1376 | reset() | |
1377 | { | |
e9599233 | 1378 | __future_base::_State_base::_S_check(_M_state); |
b3eed6fe JW |
1379 | packaged_task(std::move(_M_state->_M_task)).swap(*this); |
1380 | } | |
1381 | }; | |
1382 | ||
94a86be0 | 1383 | /// swap |
19501406 | 1384 | template<typename _Res, typename... _ArgTypes> |
4e4d27aa | 1385 | inline void |
19501406 | 1386 | swap(packaged_task<_Res(_ArgTypes...)>& __x, |
84b63c01 | 1387 | packaged_task<_Res(_ArgTypes...)>& __y) noexcept |
19501406 | 1388 | { __x.swap(__y); } |
135a0d0a PC |
1389 | |
1390 | template<typename _Res, typename _Alloc> | |
1391 | struct uses_allocator<packaged_task<_Res>, _Alloc> | |
1392 | : public true_type { }; | |
1393 | ||
1394 | ||
4880236e | 1395 | template<typename _BoundFn, typename _Res> |
e9599233 | 1396 | class __future_base::_Deferred_state : public __future_base::_State_base |
b3eed6fe JW |
1397 | { |
1398 | public: | |
b3eed6fe | 1399 | explicit |
4880236e | 1400 | _Deferred_state(_BoundFn&& __fn) |
b3eed6fe JW |
1401 | : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) |
1402 | { } | |
1403 | ||
1404 | private: | |
c4d9f419 | 1405 | typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; |
b3eed6fe | 1406 | _Ptr_type _M_result; |
4880236e | 1407 | _BoundFn _M_fn; |
b3eed6fe JW |
1408 | |
1409 | virtual void | |
1410 | _M_run_deferred() | |
1411 | { | |
b3eed6fe | 1412 | // safe to call multiple times so ignore failure |
4880236e | 1413 | _M_set_result(_S_task_setter(_M_result, _M_fn), true); |
b3eed6fe JW |
1414 | } |
1415 | }; | |
1416 | ||
4880236e | 1417 | template<typename _BoundFn, typename _Res> |
e9599233 | 1418 | class __future_base::_Async_state : public __future_base::_State_base |
b3eed6fe JW |
1419 | { |
1420 | public: | |
faa00511 | 1421 | explicit |
4880236e | 1422 | _Async_state(_BoundFn&& __fn) |
b3eed6fe | 1423 | : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)), |
19501406 | 1424 | _M_thread(mem_fn(&_Async_state::_M_do_run), this) |
b3eed6fe JW |
1425 | { } |
1426 | ||
1427 | ~_Async_state() { _M_thread.join(); } | |
1428 | ||
1429 | private: | |
1430 | void _M_do_run() | |
1431 | { | |
4880236e | 1432 | _M_set_result(_S_task_setter(_M_result, _M_fn)); |
c910ceff JW |
1433 | } |
1434 | ||
c4d9f419 | 1435 | typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; |
b3eed6fe | 1436 | _Ptr_type _M_result; |
4880236e | 1437 | _BoundFn _M_fn; |
b3eed6fe | 1438 | thread _M_thread; |
c910ceff JW |
1439 | }; |
1440 | ||
4880236e JW |
1441 | template<typename _BoundFn> |
1442 | inline std::shared_ptr<__future_base::_State_base> | |
1443 | __future_base::_S_make_deferred_state(_BoundFn&& __fn) | |
1444 | { | |
1445 | typedef typename remove_reference<_BoundFn>::type __fn_type; | |
1446 | typedef _Deferred_state<__fn_type> __state_type; | |
1447 | return std::make_shared<__state_type>(std::move(__fn)); | |
1448 | } | |
1449 | ||
1450 | template<typename _BoundFn> | |
1451 | inline std::shared_ptr<__future_base::_State_base> | |
1452 | __future_base::_S_make_async_state(_BoundFn&& __fn) | |
1453 | { | |
1454 | typedef typename remove_reference<_BoundFn>::type __fn_type; | |
1455 | typedef _Async_state<__fn_type> __state_type; | |
1456 | return std::make_shared<__state_type>(std::move(__fn)); | |
1457 | } | |
1458 | ||
1459 | ||
faa00511 | 1460 | /// async |
b3eed6fe | 1461 | template<typename _Fn, typename... _Args> |
73c5c5bb | 1462 | future<typename result_of<_Fn(_Args...)>::type> |
b3eed6fe JW |
1463 | async(launch __policy, _Fn&& __fn, _Args&&... __args) |
1464 | { | |
73c5c5bb | 1465 | typedef typename result_of<_Fn(_Args...)>::type result_type; |
e9599233 | 1466 | std::shared_ptr<__future_base::_State_base> __state; |
faa00511 | 1467 | if ((__policy & (launch::async|launch::deferred)) == launch::async) |
19501406 | 1468 | { |
4880236e | 1469 | __state = __future_base::_S_make_async_state(std::__bind_simple( |
b3eed6fe | 1470 | std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); |
19501406 | 1471 | } |
b3eed6fe | 1472 | else |
19501406 | 1473 | { |
4880236e | 1474 | __state = __future_base::_S_make_deferred_state(std::__bind_simple( |
b3eed6fe | 1475 | std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); |
19501406 | 1476 | } |
b3eed6fe JW |
1477 | return future<result_type>(__state); |
1478 | } | |
1479 | ||
94a86be0 | 1480 | /// async, potential overload |
b3eed6fe | 1481 | template<typename _Fn, typename... _Args> |
73c5c5bb | 1482 | inline typename |
be7f7822 | 1483 | __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type |
b3eed6fe JW |
1484 | async(_Fn&& __fn, _Args&&... __args) |
1485 | { | |
faa00511 | 1486 | return async(launch::async|launch::deferred, std::forward<_Fn>(__fn), |
19501406 | 1487 | std::forward<_Args>(__args)...); |
b3eed6fe JW |
1488 | } |
1489 | ||
c910ceff JW |
1490 | #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 |
1491 | // && _GLIBCXX_ATOMIC_BUILTINS_4 | |
1492 | ||
41ca4246 | 1493 | // @} group futures |
12ffa228 BK |
1494 | _GLIBCXX_END_NAMESPACE_VERSION |
1495 | } // namespace | |
41ca4246 | 1496 | |
c910ceff JW |
1497 | #endif // __GXX_EXPERIMENTAL_CXX0X__ |
1498 | ||
1499 | #endif // _GLIBCXX_FUTURE |