libstdc++
Collaboration diagram for Futures:

Classes

class  std::future< _Res >
 
struct  std::is_error_code_enum< future_errc >
 
class  std::promise< _Res >
 
class  std::shared_future< _Res >
 

Typedefs

using std::__future_base::_Result_alloc< _Res, _Alloc >::__allocator_type = __alloc_rebind< _Alloc, _Result_alloc >
 
template<typename _Fn , typename... _Args>
using std::__async_result_of = typename __invoke_result< typename decay< _Fn >::type, typename decay< _Args >::type... >::type
 
typedef __future_base::_Result< _Res > & std::__basic_future< _Res >::__result_type
 
typedef shared_ptr< _State_base > std::__basic_future< _Res >::__state_type
 
template<typename _Res >
using std::__future_base::_Ptr = unique_ptr< _Res, _Result_base::_Deleter >
 
typedef __future_base::_Ptr< _Result< _Res > > std::__future_base::_Task_state_base< _Res(_Args...)>::_Ptr_type
 
typedef _Res std::__future_base::_Task_state_base< _Res(_Args...)>::_Res_type
 
using std::__future_base::_State_base = _State_baseV2
 
typedef _Res std::__future_base::_Result< _Res >::result_type
 
typedef _Res & std::__future_base::_Result< _Res & >::result_type
 
typedef void std::__future_base::_Result< void >::result_type
 

Enumerations

enum  std::future_errc { future_already_retrieved, promise_already_satisfied, no_state, broken_promise }
 
enum  std::future_status { ready, timeout, deferred }
 
enum  std::launch { async, deferred }
 

Functions

 std::__basic_future< _Res >::__basic_future (const __basic_future &)=delete
 
 std::__basic_future< _Res >::__basic_future (const __state_type &__state)
 
 std::__basic_future< _Res >::__basic_future (const shared_future< _Res > &) noexcept
 
 std::__basic_future< _Res >::__basic_future (future< _Res > &&) noexcept
 
 std::__basic_future< _Res >::__basic_future (shared_future< _Res > &&) noexcept
 
 std::__future_base::_Async_state_impl< _BoundFn, _Res >::_Async_state_impl (_BoundFn &&__fn)
 
 std::__future_base::_Deferred_state< _BoundFn, _Res >::_Deferred_state (_BoundFn &&__fn)
 
template<typename _Fn2 >
 std::__future_base::_Task_state< _Fn, _Alloc, _Res(_Args...)>::_Impl::_Impl (_Fn2 &&__fn, const _Alloc &__a)
 
 std::__basic_future< _Res >::_Reset::_Reset (__basic_future &__fut) noexcept
 
 std::__future_base::_Result_alloc< _Res, _Alloc >::_Result_alloc (const _Alloc &__a)
 
 std::__future_base::_Result_base::_Result_base (const _Result_base &)=delete
 
 std::__future_base::_State_baseV2::_State_baseV2 (const _State_baseV2 &)=delete
 
template<typename _Fn2 >
 std::__future_base::_Task_state< _Fn, _Alloc, _Res(_Args...)>::_Task_state (_Fn2 &&__fn, const _Alloc &__a)
 
template<typename _Alloc >
 std::__future_base::_Task_state_base< _Res(_Args...)>::_Task_state_base (const _Alloc &__a)
 
 std::future< _Res >::future (const future &)=delete
 
 std::future< _Res & >::future (const future &)=delete
 
 std::future< void >::future (const future &)=delete
 
 std::future< _Res >::future (future &&__uf) noexcept
 
 std::future< _Res & >::future (future &&__uf) noexcept
 
 std::future< void >::future (future &&__uf) noexcept
 
 std::future_error::future_error (future_errc __errc)
 
template<typename _Fn , typename = __not_same<_Fn>>
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (_Fn &&__fn)
 
template<typename _Fn , typename _Alloc , typename = __not_same<_Fn>>
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Alloc &__a, _Fn &&__fn)
 
template<typename _Allocator >
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Allocator &, const packaged_task &)=delete
 
template<typename _Allocator >
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Allocator &, packaged_task &&__other) noexcept
 
template<typename _Allocator >
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Allocator &__a) noexcept
 
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (const packaged_task &)=delete
 
 std::packaged_task< _Res(_ArgTypes...)>::packaged_task (packaged_task &&__other) noexcept
 
template<typename _Allocator >
 std::promise< _Res >::promise (allocator_arg_t, const _Allocator &, promise &&__rhs)
 
template<typename _Allocator >
 std::promise< _Res & >::promise (allocator_arg_t, const _Allocator &, promise &&__rhs)
 
template<typename _Allocator >
 std::promise< void >::promise (allocator_arg_t, const _Allocator &, promise &&__rhs)
 
template<typename _Allocator >
 std::promise< _Res >::promise (allocator_arg_t, const _Allocator &__a)
 
template<typename _Allocator >
 std::promise< _Res & >::promise (allocator_arg_t, const _Allocator &__a)
 
template<typename _Allocator >
 std::promise< void >::promise (allocator_arg_t, const _Allocator &__a)
 
 std::promise< _Res >::promise (const promise &)=delete
 
 std::promise< _Res & >::promise (const promise &)=delete
 
 std::promise< void >::promise (const promise &)=delete
 
 std::promise< _Res >::promise (promise &&__rhs) noexcept
 
 std::promise< _Res & >::promise (promise &&__rhs) noexcept
 
 std::promise< void >::promise (promise &&__rhs) noexcept
 
 std::shared_future< _Res & >::shared_future (const shared_future &__sf)
 
 std::shared_future< void >::shared_future (const shared_future &__sf)
 
 std::shared_future< _Res >::shared_future (const shared_future &__sf) noexcept
 
 std::shared_future< _Res & >::shared_future (future< _Res & > &&__uf) noexcept
 
 std::shared_future< _Res >::shared_future (future< _Res > &&__uf) noexcept
 
 std::shared_future< void >::shared_future (future< void > &&__uf) noexcept
 
 std::shared_future< _Res >::shared_future (shared_future &&__sf) noexcept
 
 std::shared_future< _Res & >::shared_future (shared_future &&__sf) noexcept
 
 std::shared_future< void >::shared_future (shared_future &&__sf) noexcept
 
template<typename _Signature , typename _Fn , typename _Alloc = std::allocator<int>>
static shared_ptr< __future_base::_Task_state_base< _Signature > > std::__create_task_state (_Fn &&__fn, const _Alloc &__a=_Alloc())
 
template<typename _Res >
static _Setter< _Res, __exception_ptr_tag > std::__future_base::_State_baseV2::__setter (exception_ptr &__ex, promise< _Res > *__prom)
 
template<typename _Res >
static _Setter< _Res, void > std::__future_base::_State_baseV2::__setter (promise< _Res > *__prom)
 
template<typename _Res , typename _Arg >
static _Setter< _Res, _Arg && > std::__future_base::_State_baseV2::__setter (promise< _Res > *__prom, _Arg &&__arg)
 
void std::__future_base::_State_baseV2::_M_break_promise (_Ptr_type __res)
 
virtual void std::__future_base::_Async_state_commonV2::_M_complete_async ()
 
virtual void std::__future_base::_Result_base::_M_destroy ()=0
 
_Res & std::__future_base::_Result< _Res & >::_M_get () noexcept
 
__result_type std::__basic_future< _Res >::_M_get_result () const
 
void std::__future_base::_Async_state_commonV2::_M_join ()
 
virtual shared_ptr< _Task_state_base > std::__future_base::_Task_state_base< _Res(_Args...)>::_M_reset ()=0
 
virtual void std::__future_base::_Task_state_base< _Res(_Args...)>::_M_run (_Args &&... __args)=0
 
virtual void std::__future_base::_Task_state_base< _Res(_Args...)>::_M_run_delayed (_Args &&... __args, weak_ptr< _State_base >)=0
 
void std::__future_base::_State_baseV2::_Make_ready::_M_set ()
 
void std::__future_base::_Result< _Res >::_M_set (_Res &&__res)
 
void std::__future_base::_Result< _Res & >::_M_set (_Res &__res) noexcept
 
void std::__future_base::_Result< _Res >::_M_set (const _Res &__res)
 
void std::__future_base::_State_baseV2::_M_set_delayed_result (function< _Ptr_type()> __res, weak_ptr< _State_baseV2 > __self)
 
void std::__future_base::_State_baseV2::_M_set_result (function< _Ptr_type()> __res, bool __ignore_failure=false)
 
void std::__future_base::_State_baseV2::_M_set_retrieved_flag ()
 
void std::__basic_future< _Res >::_M_swap (__basic_future &__that) noexcept
 
_Res & std::__future_base::_Result< _Res >::_M_value () noexcept
 
template<typename _Res , typename _Allocator >
static _Ptr< _Result_alloc< _Res, _Allocator > > std::__future_base::_S_allocate_result (const _Allocator &__a)
 
template<typename _Res , typename _Tp >
static _Ptr< _Result< _Res > > std::__future_base::_S_allocate_result (const std::allocator< _Tp > &__a)
 
template<typename _Tp >
static void std::__future_base::_State_baseV2::_S_check (const shared_ptr< _Tp > &__p)
 
template<typename _BoundFn >
static std::shared_ptr< _State_base > std::__future_base::_S_make_async_state (_BoundFn &&__fn)
 
template<typename _BoundFn >
static std::shared_ptr< _State_base > std::__future_base::_S_make_deferred_state (_BoundFn &&__fn)
 
static void std::__future_base::_State_baseV2::_Make_ready::_S_run (void *)
 
template<typename _Res_ptr , typename _BoundFn >
static _Task_setter< _Res_ptr, _BoundFn > std::__future_base::_S_task_setter (_Res_ptr &__ptr, _BoundFn &__call)
 
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::async (_Fn &&__fn, _Args &&... __args)
 
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::async (launch __policy, _Fn &&__fn, _Args &&... __args)
 
const error_codestd::future_error::code () const noexcept
 
const error_categorystd::future_category () noexcept
 
_Res std::future< _Res >::get ()
 
_Res & std::future< _Res & >::get ()
 
void std::future< void >::get ()
 
const _Res & std::shared_future< _Res >::get () const
 
_Res & std::shared_future< _Res & >::get () const
 
void std::shared_future< void >::get () const
 
future< _Res > std::promise< _Res >::get_future ()
 
future< _Res & > std::promise< _Res & >::get_future ()
 
future< void > std::promise< void >::get_future ()
 
future< _Res > std::packaged_task< _Res(_ArgTypes...)>::get_future ()
 
error_code std::make_error_code (future_errc __errc) noexcept
 
error_condition std::make_error_condition (future_errc __errc) noexcept
 
void std::packaged_task< _Res(_ArgTypes...)>::make_ready_at_thread_exit (_ArgTypes... __args)
 
constexpr launch std::operator& (launch __x, launch __y)
 
launchstd::operator&= (launch &__x, launch __y)
 
promise< _Res >::_Ptr_type std::__future_base::_State_baseV2::_Setter< _Res, _Arg & >::operator() () const
 
promise< _Res >::_Ptr_type std::__future_base::_State_baseV2::_Setter< _Res, _Res && >::operator() () const
 
promise< _Res >::_Ptr_type std::__future_base::_State_baseV2::_Setter< _Res, void >::operator() () const
 
promise< _Res >::_Ptr_type std::__future_base::_State_baseV2::_Setter< _Res, __exception_ptr_tag >::operator() () const
 
_Ptr_type std::__future_base::_Task_setter< _Ptr_type, _Fn, _Res >::operator() () const
 
_Ptr_type std::__future_base::_Task_setter< _Ptr_type, _Fn, void >::operator() () const
 
void std::packaged_task< _Res(_ArgTypes...)>::operator() (_ArgTypes... __args)
 
void std::__future_base::_Result_base::_Deleter::operator() (_Result_base *__fr) const
 
__basic_futurestd::__basic_future< _Res >::operator= (const __basic_future &)=delete
 
_Result_basestd::__future_base::_Result_base::operator= (const _Result_base &)=delete
 
_State_baseV2 & std::__future_base::_State_baseV2::operator= (const _State_baseV2 &)=delete
 
futurestd::future< _Res >::operator= (const future &)=delete
 
futurestd::future< _Res & >::operator= (const future &)=delete
 
futurestd::future< void >::operator= (const future &)=delete
 
packaged_task & std::packaged_task< _Res(_ArgTypes...)>::operator= (const packaged_task &)=delete
 
promisestd::promise< _Res >::operator= (const promise &)=delete
 
promisestd::promise< _Res & >::operator= (const promise &)=delete
 
promisestd::promise< void >::operator= (const promise &)=delete
 
shared_futurestd::shared_future< _Res & >::operator= (const shared_future &__sf)
 
shared_futurestd::shared_future< void >::operator= (const shared_future &__sf)
 
shared_futurestd::shared_future< _Res >::operator= (const shared_future &__sf) noexcept
 
futurestd::future< _Res >::operator= (future &&__fut) noexcept
 
futurestd::future< _Res & >::operator= (future &&__fut) noexcept
 
futurestd::future< void >::operator= (future &&__fut) noexcept
 
packaged_task & std::packaged_task< _Res(_ArgTypes...)>::operator= (packaged_task &&__other) noexcept
 
promisestd::promise< _Res >::operator= (promise &&__rhs) noexcept
 
promisestd::promise< _Res & >::operator= (promise &&__rhs) noexcept
 
promisestd::promise< void >::operator= (promise &&__rhs) noexcept
 
shared_futurestd::shared_future< _Res >::operator= (shared_future &&__sf) noexcept
 
shared_futurestd::shared_future< _Res & >::operator= (shared_future &&__sf) noexcept
 
shared_futurestd::shared_future< void >::operator= (shared_future &&__sf) noexcept
 
constexpr launch std::operator^ (launch __x, launch __y)
 
launchstd::operator^= (launch &__x, launch __y)
 
constexpr launch std::operator| (launch __x, launch __y)
 
launchstd::operator|= (launch &__x, launch __y)
 
constexpr launch std::operator~ (launch __x)
 
void std::packaged_task< _Res(_ArgTypes...)>::reset ()
 
void std::promise< _Res >::set_exception (exception_ptr __p)
 
void std::promise< _Res & >::set_exception (exception_ptr __p)
 
void std::promise< void >::set_exception (exception_ptr __p)
 
void std::promise< _Res >::set_exception_at_thread_exit (exception_ptr __p)
 
void std::promise< _Res & >::set_exception_at_thread_exit (exception_ptr __p)
 
void std::promise< void >::set_exception_at_thread_exit (exception_ptr __p)
 
void std::promise< void >::set_value ()
 
void std::promise< _Res >::set_value (_Res &&__r)
 
void std::promise< _Res & >::set_value (_Res &__r)
 
void std::promise< _Res >::set_value (const _Res &__r)
 
void std::promise< void >::set_value_at_thread_exit ()
 
void std::promise< _Res >::set_value_at_thread_exit (_Res &&__r)
 
void std::promise< _Res & >::set_value_at_thread_exit (_Res &__r)
 
void std::promise< _Res >::set_value_at_thread_exit (const _Res &__r)
 
shared_future< _Res > std::future< _Res >::share () noexcept
 
shared_future< _Res & > std::future< _Res & >::share () noexcept
 
shared_future< void > std::future< void >::share () noexcept
 
void std::packaged_task< _Res(_ArgTypes...)>::swap (packaged_task &__other) noexcept
 
template<typename _Res , typename... _ArgTypes>
void std::swap (packaged_task< _Res(_ArgTypes...)> &__x, packaged_task< _Res(_ArgTypes...)> &__y) noexcept
 
void std::promise< _Res >::swap (promise &__rhs) noexcept
 
void std::promise< _Res & >::swap (promise &__rhs) noexcept
 
void std::promise< void >::swap (promise &__rhs) noexcept
 
template<typename _Res >
void std::swap (promise< _Res > &__x, promise< _Res > &__y) noexcept
 
bool std::__basic_future< _Res >::valid () const noexcept
 
bool std::packaged_task< _Res(_ArgTypes...)>::valid () const noexcept
 
_Result_basestd::__future_base::_State_baseV2::wait ()
 
void std::__basic_future< _Res >::wait () const
 
template<typename _Rep , typename _Period >
future_status std::__future_base::_State_baseV2::wait_for (const chrono::duration< _Rep, _Period > &__rel)
 
template<typename _Rep , typename _Period >
future_status std::__basic_future< _Res >::wait_for (const chrono::duration< _Rep, _Period > &__rel) const
 
template<typename _Clock , typename _Duration >
future_status std::__future_base::_State_baseV2::wait_until (const chrono::time_point< _Clock, _Duration > &__abs)
 
template<typename _Clock , typename _Duration >
future_status std::__basic_future< _Res >::wait_until (const chrono::time_point< _Clock, _Duration > &__abs) const
 
virtual const char * std::future_error::what () const noexcept
 

Variables

_Arg * std::__future_base::_State_baseV2::_Setter< _Res, _Arg & >::_M_arg
 
_Res * std::__future_base::_State_baseV2::_Setter< _Res, _Res && >::_M_arg
 
exception_ptr std::__future_base::_Result_base::_M_error
 
exception_ptrstd::__future_base::_State_baseV2::_Setter< _Res, __exception_ptr_tag >::_M_ex
 
_Fn * std::__future_base::_Task_setter< _Ptr_type, _Fn, _Res >::_M_fn
 
_Fn * std::__future_base::_Task_setter< _Ptr_type, _Fn, void >::_M_fn
 
_Fn std::__future_base::_Task_state< _Fn, _Alloc, _Res(_Args...)>::_Impl::_M_fn
 
__basic_futurestd::__basic_future< _Res >::_Reset::_M_fut
 
once_flag std::__future_base::_Async_state_commonV2::_M_once
 
promise< _Res > * std::__future_base::_State_baseV2::_Setter< _Res, _Arg & >::_M_promise
 
promise< _Res > * std::__future_base::_State_baseV2::_Setter< _Res, _Res && >::_M_promise
 
promise< _Res > * std::__future_base::_State_baseV2::_Setter< _Res, void >::_M_promise
 
promise< _Res > * std::__future_base::_State_baseV2::_Setter< _Res, __exception_ptr_tag >::_M_promise
 
_Ptr_type * std::__future_base::_Task_setter< _Ptr_type, _Fn, _Res >::_M_result
 
_Ptr_type * std::__future_base::_Task_setter< _Ptr_type, _Fn, void >::_M_result
 
_Ptr_type std::__future_base::_Task_state_base< _Res(_Args...)>::_M_result
 
weak_ptr< _State_baseV2 > std::__future_base::_State_baseV2::_Make_ready::_M_shared_state
 
thread std::__future_base::_Async_state_commonV2::_M_thread
 

Friends

void std::future_error::__throw_future_error (int)
 
template<typename , typename >
class std::promise< _Res >::_State::_Setter
 
template<typename , typename >
class std::promise< _Res & >::_State::_Setter
 
template<typename , typename >
class std::promise< void >::_State::_Setter
 
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::future< _Res >::async (launch, _Fn &&, _Args &&...)
 
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::future< _Res & >::async (launch, _Fn &&, _Args &&...)
 
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::future< void >::async (launch, _Fn &&, _Args &&...)
 
template<typename >
class std::future< _Res >::packaged_task
 
template<typename >
class std::future< _Res & >::packaged_task
 
template<typename >
class std::future< void >::packaged_task
 
class std::future< _Res & >::promise< _Res & >
 
class std::future< _Res >::promise< _Res >
 
class std::future< void >::promise< void >
 

Detailed Description

Classes for futures support.

Typedef Documentation

◆ _Ptr

template<typename _Res >
using std::__future_base::_Ptr = unique_ptr<_Res, _Result_base::_Deleter>

A unique_ptr for result objects.

Definition at line 223 of file future.

Enumeration Type Documentation

◆ future_errc

enum std::future_errc
strong

Error code for futures.

Definition at line 66 of file future.

◆ future_status

enum std::future_status
strong

Status code for futures.

Definition at line 174 of file future.

◆ launch

enum std::launch
strong

Launch code for futures.

Definition at line 137 of file future.

Function Documentation

◆ future() [1/3]

template<typename _Res >
std::future< _Res >::future ( future< _Res > &&  __uf)
inlinenoexcept

Move constructor.

Definition at line 779 of file future.

◆ future() [2/3]

template<typename _Res >
std::future< _Res & >::future ( future< _Res & > &&  __uf)
inlinenoexcept

Move constructor.

Definition at line 822 of file future.

◆ future() [3/3]

std::future< void >::future ( future< void > &&  __uf)
inlinenoexcept

Move constructor.

Definition at line 865 of file future.

◆ shared_future() [1/9]

template<typename _Res >
std::shared_future< _Res & >::shared_future ( const shared_future< _Res & > &  __sf)
inline

Copy constructor.

Definition at line 938 of file future.

◆ shared_future() [2/9]

std::shared_future< void >::shared_future ( const shared_future< void > &  __sf)
inline

Copy constructor.

Definition at line 977 of file future.

◆ shared_future() [3/9]

template<typename _Res >
std::shared_future< _Res >::shared_future ( const shared_future< _Res > &  __sf)
inlinenoexcept

Copy constructor.

Definition at line 899 of file future.

◆ shared_future() [4/9]

template<typename _Res >
std::shared_future< _Res & >::shared_future ( future< _Res & > &&  __uf)
inlinenoexcept

Construct from a future rvalue.

Definition at line 941 of file future.

◆ shared_future() [5/9]

template<typename _Res >
std::shared_future< _Res >::shared_future ( future< _Res > &&  __uf)
inlinenoexcept

Construct from a future rvalue.

Definition at line 902 of file future.

◆ shared_future() [6/9]

std::shared_future< void >::shared_future ( future< void > &&  __uf)
inlinenoexcept

Construct from a future rvalue.

Definition at line 980 of file future.

◆ shared_future() [7/9]

template<typename _Res >
std::shared_future< _Res >::shared_future ( shared_future< _Res > &&  __sf)
inlinenoexcept

Construct from a shared_future rvalue.

Definition at line 907 of file future.

◆ shared_future() [8/9]

template<typename _Res >
std::shared_future< _Res & >::shared_future ( shared_future< _Res & > &&  __sf)
inlinenoexcept

Construct from a shared_future rvalue.

Definition at line 946 of file future.

◆ shared_future() [9/9]

std::shared_future< void >::shared_future ( shared_future< void > &&  __sf)
inlinenoexcept

Construct from a shared_future rvalue.

Definition at line 985 of file future.

◆ _M_get_result()

template<typename _Res >
__result_type std::__basic_future< _Res >::_M_get_result ( ) const
inlineprotected

Wait for the state to be ready and rethrow any stored exception.

Definition at line 714 of file future.

◆ async() [1/2]

template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::async ( _Fn &&  __fn,
_Args &&...  __args 
)
inline

async, potential overload

Definition at line 1749 of file future.

◆ async() [2/2]

template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > std::async ( launch  __policy,
_Fn &&  __fn,
_Args &&...  __args 
)

async

Definition at line 1716 of file future.

◆ future_category()

const error_category& std::future_category ( )
noexcept

Points to a statically-allocated object derived from error_category.

◆ get() [1/5]

template<typename _Res >
_Res std::future< _Res >::get ( )
inline

Retrieving the value.

Definition at line 793 of file future.

◆ get() [2/5]

template<typename _Res >
_Res& std::future< _Res & >::get ( )
inline

Retrieving the value.

Definition at line 836 of file future.

◆ get() [3/5]

void std::future< void >::get ( )
inline

Retrieving the value.

Definition at line 879 of file future.

◆ get() [4/5]

template<typename _Res >
const _Res& std::shared_future< _Res >::get ( ) const
inline

Retrieving the value.

Definition at line 925 of file future.

◆ get() [5/5]

template<typename _Res >
_Res& std::shared_future< _Res & >::get ( ) const
inline

Retrieving the value.

Definition at line 964 of file future.

◆ make_error_code()

error_code std::make_error_code ( future_errc  __errc)
inlinenoexcept

Overload for make_error_code.

Definition at line 84 of file future.

◆ make_error_condition()

error_condition std::make_error_condition ( future_errc  __errc)
inlinenoexcept

Overload for make_error_condition.

Definition at line 89 of file future.

◆ swap()

template<typename _Res , typename... _ArgTypes>
void std::swap ( packaged_task< _Res(_ArgTypes...)> &  __x,
packaged_task< _Res(_ArgTypes...)> &  __y 
)
inlinenoexcept

swap

Definition at line 1580 of file future.

◆ what()

virtual const char* std::future_error::what ( ) const
virtualnoexcept

Returns a C-style character string describing the general cause of the current error (the same string passed to the ctor).

Reimplemented from std::logic_error.