promise< void > 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< void >	get_future ()
void	set_value ()
void	set_value_at_thread_exit ()
void	set_exception (exception_ptr _Exc)
void	set_exception_at_thread_exit (exception_ptr _Exc)
	promise (const promise &)=delete
promise &	operator= (const promise &)=delete

Private Attributes
_Promise< int >	_MyPromise

Constructor & Destructor Documentation

promise< void >::promise ( )

inline

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

template<class _Alloc >

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

inline

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

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

inline

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

promise< void >::~promise ( )

inline

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

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

delete

Member Function Documentation

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

inline

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

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

inline

        {   // assign from rvalue promise object
        promise(_STD move(_Other)).swap(*this);
        return (*this);
        }

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

delete

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

inline

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

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

inline

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

void promise< void >::set_value ( )

inline

        {   // store a (void) result
        _MyPromise._Get_state_for_set()._Set_value(1, false);
        }

void promise< void >::set_value_at_thread_exit ( )

inline

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

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

inline

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

Member Data Documentation

_Promise<int> promise< void >::_MyPromise

private

---

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

• VS2017/inc/future