29 #ifndef _GLIBCXX_FUTURE 30 #define _GLIBCXX_FUTURE 1 32 #pragma GCC system_header 34 #if __cplusplus < 201103L 47 #include <bits/shared_ptr.h> 49 #include <bits/uses_allocator.h> 53 namespace std _GLIBCXX_VISIBILITY(default)
55 _GLIBCXX_BEGIN_NAMESPACE_VERSION
68 future_already_retrieved = 1,
69 promise_already_satisfied,
84 make_error_code(future_errc __errc) noexcept
89 make_error_condition(future_errc __errc) noexcept
107 what()
const noexcept;
110 code()
const noexcept {
return _M_code; }
115 :
logic_error(
"std::future_error: " + __ec.message()), _M_code(__ec)
118 friend void __throw_future_error(
int);
124 template<
typename _Res>
127 template<
typename _Res>
130 template<
typename _Signature>
133 template<
typename _Res>
145 return static_cast<launch>(
146 static_cast<int>(__x) & static_cast<int>(__y));
151 return static_cast<launch>(
152 static_cast<int>(__x) | static_cast<int>(__y));
157 return static_cast<launch>(
158 static_cast<int>(__x) ^ static_cast<int>(__y));
162 {
return static_cast<launch>(~static_cast<
int>(__x)); }
165 {
return __x = __x & __y; }
168 {
return __x = __x | __y; }
171 {
return __x = __x ^ __y; }
183 template<
typename _Fn,
typename... _Args>
184 using __async_result_of =
typename __invoke_result<
185 typename decay<_Fn>::type,
typename decay<_Args>::type...>::type;
187 template<
typename _Fn,
typename... _Args>
188 future<__async_result_of<_Fn, _Args...>>
189 async(
launch __policy, _Fn&& __fn, _Args&&... __args);
191 template<
typename _Fn,
typename... _Args>
192 future<__async_result_of<_Fn, _Args...>>
193 async(_Fn&& __fn, _Args&&... __args);
195 #if defined(_GLIBCXX_HAS_GTHREADS) 209 virtual void _M_destroy() = 0;
213 void operator()(
_Result_base* __fr)
const { __fr->_M_destroy(); }
222 template<
typename _Res>
226 template<
typename _Res>
230 __gnu_cxx::__aligned_buffer<_Res> _M_storage;
234 typedef _Res result_type;
236 _Result() noexcept : _M_initialized() { }
246 _M_value() noexcept {
return *_M_storage._M_ptr(); }
249 _M_set(
const _Res& __res)
251 ::new (_M_storage._M_addr()) _Res(__res);
252 _M_initialized =
true;
258 ::new (_M_storage._M_addr()) _Res(std::move(__res));
259 _M_initialized =
true;
263 void _M_destroy() {
delete this; }
267 template<
typename _Res,
typename _Alloc>
270 using __allocator_type = __alloc_rebind<_Alloc, _Result_alloc>;
279 __allocator_type __a(*
this);
286 template<
typename _Res,
typename _Allocator>
288 _S_allocate_result(
const _Allocator& __a)
291 typename __result_type::__allocator_type __a2(__a);
293 __result_type* __p = ::new((
void*)__guard.get()) __result_type{__a};
299 template<
typename _Res,
typename _Tp>
313 enum _Status :
unsigned {
319 __atomic_futex_unsigned<> _M_status;
324 _State_baseV2() noexcept : _M_result(), _M_status(_Status::__not_ready)
326 _State_baseV2(
const _State_baseV2&) =
delete;
327 _State_baseV2& operator=(
const _State_baseV2&) =
delete;
328 virtual ~_State_baseV2() =
default;
337 _M_status._M_load_when_equal(_Status::__ready, memory_order_acquire);
341 template<
typename _Rep,
typename _Period>
347 if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
348 return future_status::ready;
349 if (_M_is_deferred_future())
350 return future_status::deferred;
351 if (_M_status._M_load_when_equal_for(_Status::__ready,
352 memory_order_acquire, __rel))
365 return future_status::ready;
367 return future_status::timeout;
370 template<
typename _Clock,
typename _Duration>
376 if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
377 return future_status::ready;
378 if (_M_is_deferred_future())
379 return future_status::deferred;
380 if (_M_status._M_load_when_equal_until(_Status::__ready,
381 memory_order_acquire, __abs))
388 return future_status::ready;
390 return future_status::timeout;
396 _M_set_result(
function<_Ptr_type()> __res,
bool __ignore_failure =
false)
398 bool __did_set =
false;
401 call_once(_M_once, &_State_baseV2::_M_do_set,
this,
405 _M_status._M_store_notify_all(_Status::__ready,
406 memory_order_release);
407 else if (!__ignore_failure)
408 __throw_future_error(
int(future_errc::promise_already_satisfied));
415 _M_set_delayed_result(
function<_Ptr_type()> __res,
418 bool __did_set =
false;
422 call_once(_M_once, &_State_baseV2::_M_do_set,
this,
425 __throw_future_error(
int(future_errc::promise_already_satisfied));
426 __mr->_M_shared_state = std::move(__self);
433 _M_break_promise(_Ptr_type __res)
435 if (static_cast<bool>(__res))
443 _M_result.swap(__res);
445 _M_status._M_store_notify_all(_Status::__ready,
446 memory_order_release);
452 _M_set_retrieved_flag()
454 if (_M_retrieved.test_and_set())
455 __throw_future_error(
int(future_errc::future_already_retrieved));
458 template<
typename _Res,
typename _Arg>
462 template<
typename _Res,
typename _Arg>
463 struct _Setter<_Res, _Arg&>
469 "Invalid specialisation");
474 _M_promise->_M_storage->_M_set(*_M_arg);
475 return std::move(_M_promise->_M_storage);
482 template<
typename _Res>
483 struct _Setter<_Res, _Res&&>
488 _M_promise->_M_storage->_M_set(std::move(*_M_arg));
489 return std::move(_M_promise->_M_storage);
496 template<
typename _Res>
497 struct _Setter<_Res, void>
502 {
return std::move(_M_promise->_M_storage); }
507 struct __exception_ptr_tag { };
510 template<
typename _Res>
511 struct _Setter<_Res, __exception_ptr_tag>
516 _M_promise->_M_storage->_M_error = *_M_ex;
517 return std::move(_M_promise->_M_storage);
524 template<
typename _Res,
typename _Arg>
525 static _Setter<_Res, _Arg&&>
528 _S_check(__prom->_M_future);
532 template<
typename _Res>
533 static _Setter<_Res, __exception_ptr_tag>
536 _S_check(__prom->_M_future);
537 return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex };
540 template<
typename _Res>
541 static _Setter<_Res, void>
544 _S_check(__prom->_M_future);
545 return _Setter<_Res, void>{ __prom };
548 template<
typename _Tp>
552 if (!static_cast<bool>(__p))
553 __throw_future_error((
int)future_errc::no_state);
559 _M_do_set(
function<_Ptr_type()>* __f,
bool* __did_set)
561 _Ptr_type __res = (*__f)();
566 _M_result.
swap(__res);
570 virtual void _M_complete_async() { }
573 virtual bool _M_is_deferred_future()
const {
return false; }
575 struct _Make_ready final : __at_thread_exit_elt
578 static void _S_run(
void*);
583 #ifdef _GLIBCXX_ASYNC_ABI_COMPAT 585 class _Async_state_common;
587 using _State_base = _State_baseV2;
588 class _Async_state_commonV2;
591 template<
typename _BoundFn,
592 typename _Res = decltype(std::declval<_BoundFn&>()())>
593 class _Deferred_state;
595 template<
typename _BoundFn,
596 typename _Res = decltype(std::declval<_BoundFn&>()())>
597 class _Async_state_impl;
599 template<
typename _Signature>
600 class _Task_state_base;
602 template<
typename _Fn,
typename _Alloc,
typename _Signature>
605 template<
typename _BoundFn>
607 _S_make_deferred_state(_BoundFn&& __fn);
609 template<
typename _BoundFn>
611 _S_make_async_state(_BoundFn&& __fn);
613 template<
typename _Res_ptr,
typename _Fn,
614 typename _Res =
typename _Res_ptr::element_type::result_type>
617 template<
typename _Res_ptr,
typename _BoundFn>
618 static _Task_setter<_Res_ptr, _BoundFn>
619 _S_task_setter(_Res_ptr& __ptr, _BoundFn& __call)
626 template<
typename _Res>
629 typedef _Res& result_type;
631 _Result() noexcept : _M_value_ptr() { }
634 _M_set(_Res& __res) noexcept
637 _Res& _M_get() noexcept {
return *_M_value_ptr; }
642 void _M_destroy() {
delete this; }
649 typedef void result_type;
652 void _M_destroy() {
delete this; }
655 #ifndef _GLIBCXX_ASYNC_ABI_COMPAT 658 template<
typename _Res,
typename _Arg>
660 <__future_base::_State_base::_Setter<_Res, _Arg>>
664 template<
typename _Res_ptr,
typename _Fn,
typename _Res>
666 <__future_base::_Task_setter<_Res_ptr, _Fn, _Res>>
670 template<
typename _Res>
678 __state_type _M_state;
686 valid()
const noexcept {
return static_cast<bool>(_M_state); }
691 _State_base::_S_check(_M_state);
695 template<
typename _Rep,
typename _Period>
699 _State_base::_S_check(_M_state);
700 return _M_state->wait_for(__rel);
703 template<
typename _Clock,
typename _Duration>
707 _State_base::_S_check(_M_state);
708 return _M_state->wait_until(__abs);
716 _State_base::_S_check(_M_state);
718 if (!(__res._M_error == 0))
720 return static_cast<__result_type
>(__res);
725 _M_state.swap(__that._M_state);
732 _State_base::_S_check(_M_state);
733 _M_state->_M_set_retrieved_flag();
752 explicit _Reset(
__basic_future& __fut) noexcept : _M_fut(__fut) { }
753 ~_Reset() { _M_fut._M_state.reset(); }
760 template<
typename _Res>
764 template<
typename>
friend class packaged_task;
765 template<
typename _Fn,
typename... _Args>
766 friend future<__async_result_of<_Fn, _Args...>>
773 future(
const __state_type& __state) : _Base_type(__state) { }
776 constexpr
future() noexcept : _Base_type() { }
787 future(std::move(__fut))._M_swap(*
this);
795 typename _Base_type::_Reset __reset(*
this);
796 return std::move(this->_M_get_result()._M_value());
803 template<
typename _Res>
807 template<
typename>
friend class packaged_task;
808 template<
typename _Fn,
typename... _Args>
809 friend future<__async_result_of<_Fn, _Args...>>
816 future(
const __state_type& __state) : _Base_type(__state) { }
819 constexpr
future() noexcept : _Base_type() { }
830 future(std::move(__fut))._M_swap(*
this);
838 typename _Base_type::_Reset __reset(*
this);
839 return this->_M_get_result()._M_get();
850 template<
typename>
friend class packaged_task;
851 template<
typename _Fn,
typename... _Args>
852 friend future<__async_result_of<_Fn, _Args...>>
859 future(
const __state_type& __state) : _Base_type(__state) { }
862 constexpr
future() noexcept : _Base_type() { }
873 future(std::move(__fut))._M_swap(*
this);
881 typename _Base_type::_Reset __reset(*
this);
882 this->_M_get_result();
890 template<
typename _Res>
903 : _Base_type(std::move(__uf))
908 : _Base_type(std::move(__sf))
925 get()
const {
return this->_M_get_result()._M_value(); }
929 template<
typename _Res>
942 : _Base_type(std::move(__uf))
947 : _Base_type(std::move(__sf))
964 get()
const {
return this->_M_get_result()._M_get(); }
981 : _Base_type(std::move(__uf))
986 : _Base_type(std::move(__sf))
1003 get()
const { this->_M_get_result(); }
1007 template<
typename _Res>
1010 : _M_state(__sf._M_state)
1013 template<
typename _Res>
1016 : _M_state(std::move(__sf._M_state))
1019 template<
typename _Res>
1022 : _M_state(std::move(__uf._M_state))
1027 template<
typename _Res>
1032 template<
typename _Res>
1042 template<
typename _Res>
1045 typedef __future_base::_State_base _State;
1048 template<
typename,
typename>
friend class _State::_Setter;
1052 _Ptr_type _M_storage;
1056 : _M_future(std::make_shared<_State>()),
1057 _M_storage(
new _Res_type())
1061 : _M_future(std::move(__rhs._M_future)),
1062 _M_storage(std::move(__rhs._M_storage))
1065 template<
typename _Allocator>
1067 : _M_future(std::allocate_shared<_State>(__a)),
1068 _M_storage(__future_base::_S_allocate_result<_Res>(__a))
1071 template<
typename _Allocator>
1073 : _M_future(std::move(__rhs._M_future)),
1074 _M_storage(std::move(__rhs._M_storage))
1081 if (static_cast<bool>(_M_future) && !_M_future.unique())
1082 _M_future->_M_break_promise(std::move(_M_storage));
1087 operator=(
promise&& __rhs) noexcept
1089 promise(std::move(__rhs)).swap(*
this);
1098 _M_future.swap(__rhs._M_future);
1099 _M_storage.swap(__rhs._M_storage);
1109 set_value(
const _Res& __r)
1110 { _M_future->_M_set_result(_State::__setter(
this, __r)); }
1113 set_value(_Res&& __r)
1114 { _M_future->_M_set_result(_State::__setter(
this, std::move(__r))); }
1118 { _M_future->_M_set_result(_State::__setter(__p,
this)); }
1121 set_value_at_thread_exit(
const _Res& __r)
1123 _M_future->_M_set_delayed_result(_State::__setter(
this, __r),
1128 set_value_at_thread_exit(_Res&& __r)
1130 _M_future->_M_set_delayed_result(
1131 _State::__setter(
this, std::move(__r)), _M_future);
1137 _M_future->_M_set_delayed_result(_State::__setter(__p,
this),
1142 template<
typename _Res>
1147 template<
typename _Res,
typename _Alloc>
1153 template<
typename _Res>
1154 class promise<_Res&>
1156 typedef __future_base::_State_base _State;
1159 template<
typename,
typename>
friend class _State::_Setter;
1163 _Ptr_type _M_storage;
1167 : _M_future(std::make_shared<_State>()),
1168 _M_storage(
new _Res_type())
1171 promise(promise&& __rhs) noexcept
1172 : _M_future(std::move(__rhs._M_future)),
1173 _M_storage(std::move(__rhs._M_storage))
1176 template<
typename _Allocator>
1178 : _M_future(std::allocate_shared<_State>(__a)),
1179 _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
1182 template<
typename _Allocator>
1184 : _M_future(std::move(__rhs._M_future)),
1185 _M_storage(std::move(__rhs._M_storage))
1188 promise(
const promise&) =
delete;
1192 if (static_cast<bool>(_M_future) && !_M_future.unique())
1193 _M_future->_M_break_promise(std::move(_M_storage));
1198 operator=(promise&& __rhs) noexcept
1200 promise(std::move(__rhs)).swap(*
this);
1204 promise& operator=(
const promise&) =
delete;
1207 swap(promise& __rhs) noexcept
1209 _M_future.swap(__rhs._M_future);
1210 _M_storage.
swap(__rhs._M_storage);
1220 set_value(_Res& __r)
1221 { _M_future->_M_set_result(_State::__setter(
this, __r)); }
1225 { _M_future->_M_set_result(_State::__setter(__p,
this)); }
1228 set_value_at_thread_exit(_Res& __r)
1230 _M_future->_M_set_delayed_result(_State::__setter(
this, __r),
1237 _M_future->_M_set_delayed_result(_State::__setter(__p,
this),
1246 typedef __future_base::_State_base _State;
1249 template<
typename,
typename>
friend class _State::_Setter;
1253 _Ptr_type _M_storage;
1257 : _M_future(std::make_shared<_State>()),
1258 _M_storage(
new _Res_type())
1261 promise(promise&& __rhs) noexcept
1262 : _M_future(std::move(__rhs._M_future)),
1263 _M_storage(std::move(__rhs._M_storage))
1266 template<
typename _Allocator>
1268 : _M_future(std::allocate_shared<_State>(__a)),
1269 _M_storage(__future_base::_S_allocate_result<void>(__a))
1274 template<
typename _Allocator>
1276 : _M_future(std::move(__rhs._M_future)),
1277 _M_storage(std::move(__rhs._M_storage))
1280 promise(
const promise&) =
delete;
1284 if (static_cast<bool>(_M_future) && !_M_future.unique())
1285 _M_future->_M_break_promise(std::move(_M_storage));
1290 operator=(promise&& __rhs) noexcept
1292 promise(std::move(__rhs)).swap(*
this);
1296 promise& operator=(
const promise&) =
delete;
1299 swap(promise& __rhs) noexcept
1301 _M_future.swap(__rhs._M_future);
1302 _M_storage.
swap(__rhs._M_storage);
1313 { _M_future->_M_set_result(_State::__setter(
this)); }
1317 { _M_future->_M_set_result(_State::__setter(__p,
this)); }
1320 set_value_at_thread_exit()
1321 { _M_future->_M_set_delayed_result(_State::__setter(
this), _M_future); }
1326 _M_future->_M_set_delayed_result(_State::__setter(__p,
this),
1331 template<
typename _Ptr_type,
typename _Fn,
typename _Res>
1332 struct __future_base::_Task_setter
1339 (*_M_result)->_M_set((*_M_fn)());
1343 __throw_exception_again;
1349 return std::move(*_M_result);
1355 template<
typename _Ptr_type,
typename _Fn>
1356 struct __future_base::_Task_setter<_Ptr_type, _Fn, void>
1358 _Ptr_type operator()()
const 1366 __throw_exception_again;
1372 return std::move(*_M_result);
1374 _Ptr_type* _M_result;
1379 template<
typename _Res,
typename... _Args>
1380 struct __future_base::_Task_state_base<_Res(_Args...)>
1381 : __future_base::_State_base
1385 template<
typename _Alloc>
1386 _Task_state_base(
const _Alloc& __a)
1387 : _M_result(_S_allocate_result<_Res>(__a))
1392 _M_run(_Args&&... __args) = 0;
1402 _Ptr_type _M_result;
1406 template<
typename _Fn,
typename _Alloc,
typename _Res,
typename... _Args>
1407 struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final
1408 : __future_base::_Task_state_base<_Res(_Args...)>
1410 template<
typename _Fn2>
1411 _Task_state(_Fn2&& __fn,
const _Alloc& __a)
1412 : _Task_state_base<_Res(_Args...)>(__a),
1413 _M_impl(std::forward<_Fn2>(__fn), __a)
1418 _M_run(_Args&&... __args)
1420 auto __boundfn = [&] () ->
typename result_of<_Fn&(_Args&&...)>::type {
1421 return std::__invoke(_M_impl._M_fn, std::forward<_Args>(__args)...);
1423 this->_M_set_result(_S_task_setter(this->_M_result, __boundfn));
1429 auto __boundfn = [&] () ->
typename result_of<_Fn&(_Args&&...)>::type {
1430 return std::__invoke(_M_impl._M_fn, std::forward<_Args>(__args)...);
1432 this->_M_set_delayed_result(_S_task_setter(this->_M_result, __boundfn),
1436 virtual shared_ptr<_Task_state_base<_Res(_Args...)>>
1439 struct _Impl : _Alloc
1441 template<
typename _Fn2>
1442 _Impl(_Fn2&& __fn,
const _Alloc& __a)
1443 : _Alloc(__a), _M_fn(std::forward<_Fn2>(__fn)) { }
1448 template<
typename _Signature,
typename _Fn,
typename _Alloc>
1450 __create_task_state(_Fn&& __fn,
const _Alloc& __a)
1452 typedef typename decay<_Fn>::type _Fn2;
1453 typedef __future_base::_Task_state<_Fn2, _Alloc, _Signature> _State;
1454 return std::allocate_shared<_State>(__a, std::forward<_Fn>(__fn), __a);
1457 template<
typename _Fn,
typename _Alloc,
typename _Res,
typename... _Args>
1458 shared_ptr<__future_base::_Task_state_base<_Res(_Args...)>>
1459 __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)>::_M_reset()
1461 return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn),
1462 static_cast<_Alloc&
>(_M_impl));
1466 template<
typename _Res,
typename... _ArgTypes>
1467 class packaged_task<_Res(_ArgTypes...)>
1469 typedef __future_base::_Task_state_base<_Res(_ArgTypes...)> _State_type;
1474 template<
typename _Fn,
typename _Fn2 = __remove_cvref_t<_Fn>>
1480 packaged_task() noexcept { }
1484 template<
typename _Allocator>
1488 template<
typename _Fn,
typename = __not_same<_Fn>>
1490 packaged_task(_Fn&& __fn)
1492 std::forward<_Fn>(__fn))
1498 template<
typename _Fn,
typename _Alloc,
typename = __not_same<_Fn>>
1500 : _M_state(__create_task_state<_Res(_ArgTypes...)>(
1501 std::forward<_Fn>(__fn), __a))
1506 if (static_cast<bool>(_M_state) && !_M_state.unique())
1507 _M_state->_M_break_promise(std::move(_M_state->_M_result));
1511 packaged_task(
const packaged_task&) =
delete;
1512 packaged_task& operator=(
const packaged_task&) =
delete;
1514 template<
typename _Allocator>
1516 const packaged_task&) =
delete;
1519 packaged_task(packaged_task&& __other) noexcept
1520 { this->swap(__other); }
1522 template<
typename _Allocator>
1524 packaged_task&& __other) noexcept
1525 { this->swap(__other); }
1527 packaged_task& operator=(packaged_task&& __other) noexcept
1529 packaged_task(std::move(__other)).swap(*
this);
1534 swap(packaged_task& __other) noexcept
1535 { _M_state.swap(__other._M_state); }
1538 valid()
const noexcept
1539 {
return static_cast<bool>(_M_state); }
1548 operator()(_ArgTypes... __args)
1550 __future_base::_State_base::_S_check(_M_state);
1551 _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
1555 make_ready_at_thread_exit(_ArgTypes... __args)
1557 __future_base::_State_base::_S_check(_M_state);
1558 _M_state->_M_run_delayed(std::forward<_ArgTypes>(__args)..., _M_state);
1564 __future_base::_State_base::_S_check(_M_state);
1565 packaged_task __tmp;
1566 __tmp._M_state = _M_state;
1567 _M_state = _M_state->_M_reset();
1572 template<
typename _Res,
typename... _ArgTypes>
1574 swap(packaged_task<_Res(_ArgTypes...)>& __x,
1575 packaged_task<_Res(_ArgTypes...)>& __y) noexcept
1578 template<
typename _Res,
typename _Alloc>
1585 template<
typename _BoundFn,
typename _Res>
1586 class __future_base::_Deferred_state final
1587 :
public __future_base::_State_base
1591 _Deferred_state(_BoundFn&& __fn)
1592 : _M_result(
new _Result<_Res>()), _M_fn(std::move(__fn))
1597 _Ptr_type _M_result;
1610 _M_set_result(_S_task_setter(_M_result, _M_fn),
true);
1615 virtual bool _M_is_deferred_future()
const {
return true; }
1619 class __future_base::_Async_state_commonV2
1620 :
public __future_base::_State_base
1623 ~_Async_state_commonV2() =
default;
1640 virtual void _M_complete_async() { _M_join(); }
1642 void _M_join() {
std::call_once(_M_once, &thread::join, &_M_thread); }
1650 template<
typename _BoundFn,
typename _Res>
1651 class __future_base::_Async_state_impl final
1652 :
public __future_base::_Async_state_commonV2
1656 _Async_state_impl(_BoundFn&& __fn)
1657 : _M_result(
new _Result<_Res>()), _M_fn(std::move(__fn))
1662 _M_set_result(_S_task_setter(_M_result, _M_fn));
1667 if (static_cast<bool>(_M_result))
1668 this->_M_break_promise(std::move(_M_result));
1669 __throw_exception_again;
1677 ~_Async_state_impl() {
if (_M_thread.joinable()) _M_thread.join(); }
1681 _Ptr_type _M_result;
1685 template<
typename _BoundFn>
1687 __future_base::_S_make_deferred_state(_BoundFn&& __fn)
1689 typedef typename remove_reference<_BoundFn>::type __fn_type;
1690 typedef _Deferred_state<__fn_type> __state_type;
1691 return std::make_shared<__state_type>(std::move(__fn));
1694 template<
typename _BoundFn>
1696 __future_base::_S_make_async_state(_BoundFn&& __fn)
1698 typedef typename remove_reference<_BoundFn>::type __fn_type;
1699 typedef _Async_state_impl<__fn_type> __state_type;
1700 return std::make_shared<__state_type>(std::move(__fn));
1705 template<
typename _Fn,
typename... _Args>
1706 _GLIBCXX_NODISCARD
future<__async_result_of<_Fn, _Args...>>
1710 if ((__policy & launch::async) == launch::async)
1714 __state = __future_base::_S_make_async_state(
1715 std::thread::__make_invoker(std::forward<_Fn>(__fn),
1716 std::forward<_Args>(__args)...)
1719 #if __cpp_exceptions 1722 if (__e.code() != errc::resource_unavailable_try_again
1723 || (__policy & launch::deferred) != launch::deferred)
1730 __state = __future_base::_S_make_deferred_state(
1731 std::thread::__make_invoker(std::forward<_Fn>(__fn),
1732 std::forward<_Args>(__args)...));
1734 return future<__async_result_of<_Fn, _Args...>>(__state);
1738 template<
typename _Fn,
typename... _Args>
1739 _GLIBCXX_NODISCARD
inline future<__async_result_of<_Fn, _Args...>>
1742 return std::async(launch::async|launch::deferred,
1743 std::forward<_Fn>(__fn),
1744 std::forward<_Args>(__args)...);
1747 #endif // _GLIBCXX_ASYNC_ABI_COMPAT 1748 #endif // _GLIBCXX_HAS_GTHREADS 1751 _GLIBCXX_END_NAMESPACE_VERSION
1756 #endif // _GLIBCXX_FUTURE
Explicit specialization for future<void>
Base class and enclosing scope.
Thrown to indicate error code of underlying system.
shared_future(future< _Res &> &&__uf) noexcept
Construct from a future rvalue.
Define a member typedef type only if a boolean constant is true.
Non-standard RAII type for managing pointers obtained from allocators.
shared_future(const shared_future &__sf)
Copy constructor.
future(future &&__uf) noexcept
Move constructor.
future_errc
Error code for futures.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
const error_category & future_category() noexcept
Points to a statically-allocated object derived from error_category.
Common implementation for future and shared_future.
Primary template for shared_future.
future< __async_result_of< _Fn, _Args... > > async(launch __policy, _Fn &&__fn, _Args &&... __args)
async
void rethrow_exception(exception_ptr) __attribute__((__noreturn__))
Throw the object pointed to by the exception_ptr.
Explicit specialization for void.
ISO C++ entities toplevel namespace is std.
Declare uses_allocator so it can be specialized in <queue> etc.
future(future &&__uf) noexcept
Move constructor.
Explicit specialization for shared_future<void>
shared_future(shared_future &&__sf) noexcept
Construct from a shared_future rvalue.
Partial specialization for future<R&>
Primary template for promise.
Primary template for future.
Partial specialization for reference types.
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
_GLIBCXX_NODISCARD future< __async_result_of< _Fn, _Args... > > async(_Fn &&__fn, _Args &&... __args)
async, potential overload
shared_future(future< _Res > &&__uf) noexcept
Construct from a future rvalue.
A result object that uses an allocator.
Partial specialization for shared_future<R&>
exception_ptr make_exception_ptr(_Ex) noexcept
Obtain an exception_ptr pointing to a copy of the supplied object.
__result_type _M_get_result() const
Wait for the state to be ready and rethrow any stored exception.
shared_future(const shared_future &__sf)
Copy constructor.
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
void swap(unique_ptr &__u) noexcept
Exchange the pointer and deleter with another object.
_GLIBCXX17_CONSTEXPR _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
One of two subclasses of exception.
bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
shared_future(const shared_future &__sf) noexcept
Copy constructor.
A result object that has storage for an object of type _Res.
void call_once(once_flag &__once, _Callable &&__f, _Args &&... __args)
call_once
20.7.1.2 unique_ptr for single objects.
The standard allocator, as per [20.4].
exception_ptr current_exception() noexcept
__allocated_ptr< _Alloc > __allocate_guarded(_Alloc &__a)
Allocate space for a single object using __a.
shared_future(future< void > &&__uf) noexcept
Construct from a future rvalue.
void swap(packaged_task< _Res(_ArgTypes...)> &__x, packaged_task< _Res(_ArgTypes...)> &__y) noexcept
swap
bitset< _Nb > operator &(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
An opaque pointer to an arbitrary exception.
shared_future(shared_future &&__sf) noexcept
Construct from a shared_future rvalue.
future_status
Status code for futures.
future(future &&__uf) noexcept
Move constructor.
launch
Launch code for futures.
Exception type thrown by futures.
shared_future(shared_future &&__sf) noexcept
Construct from a shared_future rvalue.
A smart pointer with reference-counted copy semantics.