future File Reference

#include <functional>
#include <system_error>
#include <utility>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <ppltasks.h>
#include <thread>

Classes
struct	is_error_code_enum< _Future_errc >
class	future_error
class	_Future_error_category
struct	_Future_error_object< _Cat >
class	_Associated_state< _Ty >
struct	_State_deleter< _Ty, _Alloc >
struct	_Deleter_base< _Ty >
struct	_State_deleter< _Ty, _Alloc >
class	_Associated_state< _Ty >
struct	_Associated_state< _Ty >::_Test_ready
struct	_Associated_state< _Ty >::_Anon
class	_Packaged_state< class >
class	_Packaged_state< _Ret(_ArgTypes...)>
class	_Packaged_state< _Ret &(_ArgTypes...)>
class	_Packaged_state< void(_ArgTypes...)>
class	_Deferred_async_state< _Rx >
class	_Task_async_state< _Rx, _Inline >
class	_State_manager< _Ty >
class	shared_future< _Ty >
class	future< _Ty >
class	future< _Ty & >
class	future< void >
class	shared_future< _Ty >
class	shared_future< _Ty & >
class	shared_future< void >
class	_Promise< _Ty >
class	promise< _Ty >
class	promise< _Ty & >
class	promise< void >
struct	_P_arg_type< _Fret >
struct	_P_arg_type< _Fret & >
struct	_P_arg_type< void >
class	packaged_task< class >
class	packaged_task< _Ret(_ArgTypes...)>
struct	_Is_launch_type< _Fty >
struct	_Is_launch_type< _Launch_type >
struct	std::uses_allocator< promise< _Ty >, _Alloc >
struct	std::uses_allocator< packaged_task< _Ty >, _Alloc >

Macros
#define	_FUTURE_

Typedefs
typedef future_errc	_Future_errc
typedef launch	_Launch_type
typedef future_status	_Future_status

Enumerations
enum	future_errc { future_errc::broken_promise = 1, future_errc::future_already_retrieved, future_errc::promise_already_satisfied, future_errc::no_state }
enum	launch { launch::async = 0x1, launch::deferred = 0x2, launch::any = async | deferred, launch::sync = deferred }
enum	future_status { future_status::ready, future_status::timeout, future_status::deferred }

Functions
launch	operator& (launch _Left, launch _Right)
launch	operator| (launch _Left, launch _Right)
launch	operator^ (launch _Left, launch _Right)
launch	operator~ (launch _Left)
launch &	operator&= (launch &_Left, launch _Right)
launch &	operator|= (launch &_Left, launch _Right)
launch &	operator^= (launch &_Left, launch _Right)
_CRTIMP2_PURE	_NO_RETURN (__CLRCALL_PURE_OR_CDECL _Throw_future_error(const error_code &_Code))
_CRTIMP2_PURE	_NO_RETURN (__CLRCALL_PURE_OR_CDECL _Rethrow_future_exception(_XSTD exception_ptr _Ptr))
const error_category &	future_category () _NOEXCEPT
error_code	make_error_code (_Future_errc _Errno) _NOEXCEPT
error_condition	make_error_condition (_Future_errc _Errno) _NOEXCEPT
_CRTIMP2_PURE const char *__CLRCALL_PURE_OR_CDECL	_Future_error_map (int) _NOEXCEPT
template<class _Alloc , class _Ty >
void	_Delete_state (_Alloc _Al, _Associated_state< _Ty > *_State, _State_deleter< _Ty, _Alloc > *)
template<class _Ty , class _Allocx >
_Associated_state< _Ty > *	_Make_associated_state (_Allocx _Al)
template<class _Fty , class _Allocx , class _Ty >
_Associated_state< _Ty > *	_Make_packaged_state (const _Fty &_Fn, const _Allocx &_Al)
template<class _Fty , class _Alloc , class _Ty >
_Associated_state< _Ty > *	_Make_packaged_state (_Fty &&_Fn, const _Alloc &_Al)
template<class _Ty >
void	swap (promise< _Ty > &_Left, promise< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
void	swap (packaged_task< _Ty > &_Left, packaged_task< _Ty > &_Right) _NOEXCEPT
template<class _Ret , class _Fty >
_Associated_state< typename _P_arg_type< _Ret >::type > *	_Get_associated_state (_Launch_type _Psync, _Fty &&_Fnarg)
template<class _Fty , class... _ArgTypes>
future< typename result_of< _Fty(_ArgTypes...)>::type >	_Async (_Launch_type _Policy, _Fty &&_Fnarg, _ArgTypes &&..._Args)
template<class _Fty , class... _ArgTypes>
future< typename result_of< typename enable_if<!_Is_launch_type< typename decay< _Fty >::type >::value, _Fty >::type(_ArgTypes...)>::type >	async (_Fty &&_Fnarg, _ArgTypes &&..._Args)
template<class _Policy_type , class _Fty , class... _ArgTypes>
future< typename result_of< typename enable_if< _Is_launch_type< _Policy_type >::value, _Fty >::type(_ArgTypes...)>::type >	async (_Policy_type _Policy, _Fty &&_Fnarg, _ArgTypes &&..._Args)

Macro Definition Documentation

#define _FUTURE_

Typedef Documentation

typedef future_errc _Future_errc

typedef future_status _Future_status

typedef launch _Launch_type

Enumeration Type Documentation

enum future_errc

strong

Enumerator
broken_promise
future_already_retrieved
promise_already_satisfied
no_state

                       {    // names for futures errors
    broken_promise = 1,
    future_already_retrieved,
    promise_already_satisfied,
    no_state
    };

enum future_status

strong

Enumerator
ready
timeout
deferred

                         {  // names for timed wait function returns
    ready,
    timeout,
    deferred
    };

enum launch

strong

Enumerator
async
deferred
any
sync

                  { // names for launch options passed to async
    async = 0x1,
    deferred = 0x2,
    any = async | deferred, // retained
    sync = deferred
    };

Function Documentation

template<class _Fty , class... _ArgTypes>

future<typename result_of<_Fty(_ArgTypes...)>::type> _Async ( _Launch_type  _Policy, _Fty &&  _Fnarg, _ArgTypes &&...  _Args  )

inline

    {   // return a future object whose associated asynchronous state
        // manages a function object
    typedef typename result_of<_Fty(_ArgTypes...)>::type _Ret;
    typedef typename _P_arg_type<_Ret>::type _Ptype;
    _Promise<_Ptype> _Pr(_Get_associated_state<_Ret>(_Policy,
        _STD bind(_STD forward<_Fty>(_Fnarg),
            _STD forward<_ArgTypes>(_Args)...)));
    return (future<_Ret>(_Pr._Get_state_for_future(), _Nil_obj));
    }

template<class _Alloc , class _Ty >

void _Delete_state ( _Alloc  _Al, _Associated_state< _Ty > *  _State, _State_deleter< _Ty, _Alloc > *  _Deleter  )

inline

    {   // delete _State and _Deleter using allocator _Al
    typedef typename _Alloc::template rebind<_Associated_state<_Ty> >
        ::other _State_allocator;
    _State_allocator _St_alloc(_Al);
    _St_alloc.destroy(_State);
    _St_alloc.deallocate(_State, 1);

    typedef typename _Alloc::template rebind<_State_deleter<_Ty, _Alloc> >
        ::other _Deleter_allocator;
    _Deleter_allocator _Del_alloc(_Al);
    _Del_alloc.destroy(_Deleter);
    _Del_alloc.deallocate(_Deleter, 1);
    }

_CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Future_error_map

(

int

)

template<class _Ret , class _Fty >

_Associated_state<typename _P_arg_type<_Ret>::type>* _Get_associated_state ( _Launch_type  _Psync, _Fty &&  _Fnarg  )

inline

    {   // construct associated asynchronous state object for the launch type
    switch (_Psync)
        {   // select launch type
    case launch::async:
        return (new _Task_async_state<_Ret, false>(
            _STD forward<_Fty >(_Fnarg)));

    case launch::deferred:
        return (new _Deferred_async_state<_Ret>(
            _STD forward<_Fty >(_Fnarg)));
    default:
        return (new _Task_async_state<_Ret, true>(
            _STD forward<_Fty >(_Fnarg)));
        }
    }

template<class _Ty , class _Allocx >

_Associated_state<_Ty>* _Make_associated_state ( _Allocx  _Al )

inline

    {   // construct an _Associated_state object with an allocator
    typedef _Wrap_alloc<_Allocx> _Alloc;
    typedef typename _Alloc::template rebind<_Associated_state<_Ty> >
        ::other _State_allocator;
    _State_allocator _St_alloc(_Al);

    typedef typename _Alloc::template rebind<_State_deleter<_Ty, _Alloc> >
        ::other _Deleter_allocator;
    _Deleter_allocator _Del_alloc(_Al);
    _State_deleter<_Ty, _Alloc> *_Del = _Del_alloc.allocate(1);
    _Del_alloc.construct(_Del, _St_alloc);

    _Associated_state<_Ty> *_Res = _St_alloc.allocate(1);
    _St_alloc.construct(_Res, _Del);
    return (_Res);
    }

template<class _Fty , class _Allocx , class _Ty >

_Associated_state<_Ty>* _Make_packaged_state ( const _Fty &  _Fn, const _Allocx &  _Al  )

inline

    {   // construct a _Packaged_state object with an allocator
    typedef _Wrap_alloc<_Allocx> _Alloc;
    typedef typename _Alloc::template rebind<_Packaged_state<_Fty> >
        ::other _State_allocator;
    _State_allocator _St_alloc(_Al);

    typedef typename _Alloc::template rebind<_State_deleter<_Fty, _Alloc> >
        ::other _Deleter_allocator;
    _Deleter_allocator _Del_alloc(_Al);
    _State_deleter<_Fty, _Alloc> *_Del = _Del_alloc.allocate(1);
    _Del_alloc.construct(_Del, _St_alloc);

    _Packaged_state<_Fty> *_Res = _St_alloc.allocate(1);
    _St_alloc.construct(_Res, _Fn, _Del);
    return (_Res);
    }

template<class _Fty , class _Alloc , class _Ty >

_Associated_state<_Ty>* _Make_packaged_state ( _Fty &&  _Fn, const _Alloc &  _Al  )

inline

    {   // construct a _Packaged_state object with an allocator from
        // an rvalue function object
    typedef typename _Alloc::template rebind<_Packaged_state<_Fty> >
        ::other _State_allocator;
    _State_allocator _St_alloc(_Al);

    typedef typename _Alloc::template rebind<_State_deleter<_Fty, _Alloc> >
        ::other _Deleter_allocator;
    _Deleter_allocator _Del_alloc(_Al);
    _State_deleter<_Fty, _Alloc> *_Del = _Del_alloc.allocate(1);
    _Del_alloc.construct(_Del, _St_alloc);

    _Packaged_state<_Fty> *_Res = _St_alloc.allocate(1);
    _St_alloc.construct(_Res, _STD forward<_Fty>(_Fn), _Del);
    return (_Res);
    }

_CRTIMP2_PURE _NO_RETURN

(

__CLRCALL_PURE_OR_CDECL

_Throw_future_errorconst error_code &_Code

)

_CRTIMP2_PURE _NO_RETURN

(

__CLRCALL_PURE_OR_CDECL

_Rethrow_future_exception_XSTD exception_ptr _Ptr

)

template<class _Fty , class... _ArgTypes>

future<typename result_of< typename enable_if<!_Is_launch_type< typename decay<_Fty>::type>::value, _Fty>::type(_ArgTypes...)>::type> async ( _Fty &&  _Fnarg, _ArgTypes &&...  _Args  )

inline

    {   // return a future object whose associated asynchronous state
        // manages a function object
    return (_Async(launch::any, _Decay_copy(_STD forward<_Fty>(_Fnarg)),
        _Decay_copy(_STD forward<_ArgTypes>(_Args))...));
    }

template<class _Policy_type , class _Fty , class... _ArgTypes>

future<typename result_of< typename enable_if<_Is_launch_type< _Policy_type>::value, _Fty>::type(_ArgTypes...)>::type> async ( _Policy_type  _Policy, _Fty &&  _Fnarg, _ArgTypes &&...  _Args  )

inline

    {   // return a future object whose associated asynchronous state
        // manages a function object
    return (_Async(_Policy, _Decay_copy(_STD forward<_Fty>(_Fnarg)),
        _Decay_copy(_STD forward<_ArgTypes>(_Args))...));
    }

const error_category & future_category ( )

inline

    {   // return error_category object for future
    return (_Future_error_object<int>::_Future_object);
    }

error_code make_error_code ( _Future_errc  _Errno )

inline

    {   // make an error_code object
    return (error_code(static_cast<int>(_Errno), future_category()));
    }

error_condition make_error_condition ( _Future_errc  _Errno )

inline

    {   // make an error_condition object
    return (error_condition(static_cast<int>(_Errno), future_category()));
    }

launch operator& ( launch  _Left, launch  _Right  )

inline

    {   /* return _Left&_Right */
    return (static_cast<launch>(static_cast<unsigned int>(_Left)
        & static_cast<unsigned int>(_Right)));
    }

launch& operator&= ( launch &  _Left, launch  _Right  )

inline

    {   /* return _Left&=_Right */
    _Left = _Left & _Right;
    return (_Left);
    }

launch operator^ ( launch  _Left, launch  _Right  )

inline

    {   /* return _Left^_Right */
    return (static_cast<launch>(static_cast<unsigned int>(_Left)
        ^ static_cast<unsigned int>(_Right)));
    }

launch& operator^= ( launch &  _Left, launch  _Right  )

inline

    {   /* return _Left^=_Right */
    _Left = _Left ^ _Right;
    return (_Left);
    }

launch operator| ( launch  _Left, launch  _Right  )

inline

    {   /* return _Left|_Right */
    return (static_cast<launch>(static_cast<unsigned int>(_Left)
        | static_cast<unsigned int>(_Right)));
    }

launch& operator|= ( launch &  _Left, launch  _Right  )

inline

    {   /* return _Left|=_Right */
    _Left = _Left | _Right;
    return (_Left);
    }

launch operator~ ( launch  _Left )

inline

    {   /* return ~_Left */
    return (static_cast<launch>(~static_cast<unsigned int>(_Left)));
    }

template<class _Ty >

void swap ( promise< _Ty > &  _Left, promise< _Ty > &  _Right  )

inline

    {   // exchange _Left and _Right
    _Left.swap(_Right);
    }

template<class _Ty >

void swap ( packaged_task< _Ty > &  _Left, packaged_task< _Ty > &  _Right  )

inline

    {   // exchange _Left and _Right
    _Left.swap(_Right);
    }