promise< _Ty > Class Template Reference

Public Member Functions
	promise ()
template<class _Alloc >
	promise (allocator_arg_t, const _Alloc &_Al)
	promise (promise &&_Other) _NOEXCEPT
promise &	operator= (promise &&_Other) _NOEXCEPT
	~promise () _NOEXCEPT
void	swap (promise &_Other) _NOEXCEPT
future< _Ty >	get_future ()
void	set_value (const _Ty &_Val)
void	set_value_at_thread_exit (const _Ty &_Val)
void	set_value (_Ty &&_Val)
void	set_value_at_thread_exit (_Ty &&_Val)
void	set_exception (_XSTD exception_ptr _Exc)
void	set_exception_at_thread_exit (_XSTD exception_ptr _Exc)
	promise (const promise &)=delete
promise &	operator= (const promise &)=delete

Private Attributes
_Promise< _Ty >	_MyPromise

Constructor & Destructor Documentation

template<class _Ty>

promise< _Ty >::promise ( )

inline

        : _MyPromise(new _Associated_state<_Ty>)
        {   // construct
        }

template<class _Ty>

template<class _Alloc >

promise< _Ty >::promise ( allocator_arg_t  , const _Alloc &  _Al  )

inline

        : _MyPromise(_Make_associated_state<_Ty>(_Al))
        {   // construct with allocator
        }

template<class _Ty>

promise< _Ty >::promise ( promise< _Ty > &&  _Other )

inline

        : _MyPromise(_STD forward<_Promise<_Ty> >(_Other._MyPromise))
        {   // construct from rvalue promise object
        }

template<class _Ty>

promise< _Ty >::~promise ( )

inline

        {   // destroy
        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready())
            {   // exception if destroyed before function object returns
            future_error _Fut(make_error_code(future_errc::broken_promise));
            _MyPromise._Get_state()
                ._Set_exception(_XSTD make_exception_ptr(_Fut), false);
            }
        }

template<class _Ty>

promise< _Ty >::promise ( const promise< _Ty > &  )

delete

Member Function Documentation

template<class _Ty>

future<_Ty> promise< _Ty >::get_future ( )

inline

        {   // return a future object that shares the associated
            // asynchronous state
        return (future<_Ty>(_MyPromise._Get_state_for_future(), _Nil_obj));
        }

template<class _Ty>

promise& promise< _Ty >::operator= ( promise< _Ty > &&  _Other )

inline

        {   // assign from rvalue promise object
        _MyPromise = _STD forward<_Promise<_Ty> >(_Other._MyPromise);
        return (*this);
        }

template<class _Ty>

promise& promise< _Ty >::operator= ( const promise< _Ty > &  )

delete

template<class _Ty>

void promise< _Ty >::set_exception ( _XSTD exception_ptr  _Exc )

inline

        {   // store result
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
        }

template<class _Ty>

void promise< _Ty >::set_exception_at_thread_exit ( _XSTD exception_ptr  _Exc )

inline

        {   // store result and block until thread exit
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
        }

template<class _Ty>

void promise< _Ty >::set_value ( const _Ty &  _Val )

inline

        {   // store result
        _MyPromise._Get_state_for_set()._Set_value(_Val, false);
        }

template<class _Ty>

void promise< _Ty >::set_value ( _Ty &&  _Val )

inline

        {   // store result
        _MyPromise._Get_state_for_set()._Set_value(_STD forward<_Ty>(_Val), false);
        }

template<class _Ty>

void promise< _Ty >::set_value_at_thread_exit ( const _Ty &  _Val )

inline

        {   // store result and block until thread exit
        _MyPromise._Get_state_for_set()._Set_value(_Val, true);
        }

template<class _Ty>

void promise< _Ty >::set_value_at_thread_exit ( _Ty &&  _Val )

inline

        {   // store result and block until thread exit
        _MyPromise._Get_state_for_set()._Set_value(_STD forward<_Ty>(_Val), true);
        }

template<class _Ty>

void promise< _Ty >::swap ( promise< _Ty > &  _Other )

inline

        {   // exchange with _Other
        _MyPromise._Swap(_Other._MyPromise);
        }

Member Data Documentation

template<class _Ty>

_Promise<_Ty> promise< _Ty >::_MyPromise

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/future