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
class	_Associated_state< _Ty >
struct	_Deleter_base< _Ty >
struct	_State_deleter< _Ty, _Derived, _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...)>
class	_Fake_no_copy_callable_adapter< _Types >
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 }
enum	future_status { future_status::ready, future_status::timeout, future_status::deferred }

Functions
constexpr launch	operator& (launch _Left, launch _Right)
constexpr launch	operator| (launch _Left, launch _Right)
constexpr launch	operator^ (launch _Left, launch _Right)
constexpr launch	operator~ (launch _Left)
launch &	operator&= (launch &_Left, launch _Right)
launch &	operator|= (launch &_Left, launch _Right)
launch &	operator^= (launch &_Left, launch _Right)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Throw_future_error (const error_code &_Code)
_CRTIMP2_PURE void __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
const char *	_Future_error_map (int _Errcode) _NOEXCEPT
template<class _Ty , class _Alloc >
_Associated_state< _Ty > *	_Make_associated_state (const _Alloc &_Al)
template<class _Pack_state , class _Fty2 , class _Alloc >
_Pack_state *	_Make_packaged_state (_Fty2 &&_Fnarg, 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< result_of_t< decay_t< _Fty >decay_t< _ArgTypes >...)> >	async (launch _Policy, _Fty &&_Fnarg, _ArgTypes &&..._Args)
template<class _Fty , class... _ArgTypes>
future< result_of_t< decay_t< _Fty >decay_t< _ArgTypes >...)> >	async (_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

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

Function Documentation

const char* _Future_error_map ( int  _Errcode )

inline

    {   // convert to name of future error
    switch (static_cast<_Future_errc>(_Errcode))
        {   // switch on error code value
    case future_errc::broken_promise:
        return ("broken promise");

    case future_errc::future_already_retrieved:
        return ("future already retrieved");

    case future_errc::promise_already_satisfied:
        return ("promise already satisfied");

    case future_errc::no_state:
        return ("no state");

    default:
        return (0);
        }
    }

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 _Alloc >

_Associated_state<_Ty>* _Make_associated_state ( const _Alloc &  _Al )

inline

    {   // construct an _Associated_state object with an allocator
    typedef _State_deleter<_Ty, _Associated_state<_Ty>, _Alloc> _Delty;
    typedef _Wrap_alloc<_Alloc> _Alty0;

    typedef typename _Alty0::template rebind<_Delty>
        ::other _Deleter_allocator;
    typedef typename _Alty0::template rebind<_Associated_state<_Ty> >
        ::other _State_allocator;

    _Deleter_allocator _Del_alloc(_Al);
    _State_allocator _St_alloc(_Al);

    _Delty *_Del = 0;
    _Associated_state<_Ty> *_Res = 0;

    _Del = _Del_alloc.allocate(1);

    bool _Del_constructed = false;

    _TRY_BEGIN
        _Del_alloc.construct(_Del, _Al);
        _Del_constructed = true;

        _Res = _St_alloc.allocate(1);

        _St_alloc.construct(_Res, _Del);
    _CATCH_ALL
        if (_Res)
            _St_alloc.deallocate(_Res, 1);

        if (_Del_constructed)
            _Del_alloc.destroy(_Del);

        _Del_alloc.deallocate(_Del, 1);
    _RERAISE;
    _CATCH_END

    return (_Res);
    }

template<class _Pack_state , class _Fty2 , class _Alloc >

_Pack_state* _Make_packaged_state ( _Fty2 &&  _Fnarg, const _Alloc &  _Al  )

inline

    {   // construct a _Packaged_state object with an allocator from
        // an rvalue function object
    typedef _State_deleter<typename _Pack_state::_Mybase::_State_type,
        _Pack_state, _Alloc> _Delty;
    typedef _Wrap_alloc<_Alloc> _Alty0;

    typedef typename _Alty0::template rebind<_Delty>
        ::other _Deleter_allocator;
    typedef typename _Alty0::template rebind<_Pack_state>
        ::other _State_allocator;

    _Deleter_allocator _Del_alloc(_Al);
    _State_allocator _St_alloc(_Al);

    _Delty *_Del = 0;
    _Pack_state *_Res = 0;

    _Del = _Del_alloc.allocate(1);

    bool _Del_constructed = false;

    _TRY_BEGIN
        _Del_alloc.construct(_Del, _Al);
        _Del_constructed = true;

        _Res = _St_alloc.allocate(1);

        _St_alloc.construct(_Res, _STD forward<_Fty2>(_Fnarg), _Al, _Del);
    _CATCH_ALL
        if (_Res)
            _St_alloc.deallocate(_Res, 1);

        if (_Del_constructed)
            _Del_alloc.destroy(_Del);

        _Del_alloc.deallocate(_Del, 1);
    _RERAISE;
    _CATCH_END

    return (_Res);
    }

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Rethrow_future_exception

(

_XSTD exception_ptr

_Ptr

)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Throw_future_error

(

const error_code &

_Code

)

template<class _Fty , class... _ArgTypes>

future<result_of_t<decay_t<_Fty>decay_t<_ArgTypes>...)> > async ( launch  _Policy, _Fty &&  _Fnarg, _ArgTypes &&...  _Args  )

inline

    {   // return a future object whose associated asynchronous state
        // manages a callable object launched with supplied policy
    typedef result_of_t<decay_t<_Fty>(decay_t<_ArgTypes>...)> _Ret;
    typedef typename _P_arg_type<_Ret>::type _Ptype;
    _Promise<_Ptype> _Pr(_Get_associated_state<_Ret>(_Policy,
        _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(
            _STD forward<_Fty>(_Fnarg),
            _STD forward<_ArgTypes>(_Args)...
        )));

    return (future<_Ret>(_Pr._Get_state_for_future(), _Nil()));
    }

template<class _Fty , class... _ArgTypes>

future<result_of_t<decay_t<_Fty>decay_t<_ArgTypes>...)> > async ( _Fty &&  _Fnarg, _ArgTypes &&...  _Args  )

inline

    {   // return a future object whose associated asynchronous state
        // manages a callable object launched with default policy
    return (_STD async(launch::async | launch::deferred,
        _STD forward<_Fty>(_Fnarg),
        _STD forward<_ArgTypes>(_Args)...
        ));
    }

const error_category & future_category ( )

inline

    {   // return error_category object for future
    return (_Immortalize<_Future_error_category>());
    }

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()));
    }

constexpr 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);
    }

constexpr 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);
    }

constexpr 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);
    }

constexpr 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);
    }