Inheritance diagram for _State_manager< _Ty >:

Public Member Functions
	_State_manager ()

	_State_manager (_Associated_state< _Ty > *_New_state, bool _Get_once)

	_State_manager (const _State_manager &_Other, bool _Get_once=false)

	_State_manager (_State_manager &&_Other, bool _Get_once=false)

	~_State_manager () _NOEXCEPT

_State_manager &	operator= (const _State_manager &_Other)

_State_manager &	operator= (_State_manager &&_Other)

bool	valid () const _NOEXCEPT

void	wait () const

template<class _Rep , class _Per >
_Future_status	wait_for (const chrono::duration< _Rep, _Per > &_Rel_time) const

template<class _Clock , class _Dur >
_Future_status	wait_until (const chrono::time_point< _Clock, _Dur > &_Abs_time) const

_Ty &	_Get_value () const

void	_Set_value (const _Ty &_Val, bool _Defer)

void	_Set_value (_Ty &&_Val, bool _Defer)

void	_Abandon ()

void	_Set_exception (exception_ptr _Exc, bool _Defer)

void	_Swap (_State_manager &_Other)

_Associated_state< _Ty > *	_Ptr () const

void	_Copy_from (const _State_manager &_Other)

void	_Move_from (_State_manager &_Other)

bool	_Is_ready () const

bool	_Is_ready_at_thread_exit () const

Private Attributes
_Associated_state< _Ty > *	_Assoc_state

bool	_Get_only_once

Constructor & Destructor Documentation

template<class _Ty>

_State_manager< _Ty >::_State_manager ( )

inline

         : _Assoc_state(0)
         {   // construct with no associated asynchronous state object
         _Get_only_once = false;
         }

template<class _Ty>

_State_manager< _Ty >::_State_manager	(	_Associated_state< _Ty > *	_New_state,
		bool	_Get_once
	)

inline

         : _Assoc_state(_New_state)
         {   // construct with _New_state
         _Get_only_once = _Get_once;
         }

template<class _Ty>

_State_manager< _Ty >::_State_manager	(	const _State_manager< _Ty > &	_Other,
		bool	_Get_once = `false`
	)

inline

         : _Assoc_state(0)
         {   // construct from _Other
         _Copy_from(_Other);
         _Get_only_once = _Get_once;
         }

template<class _Ty>

_State_manager< _Ty >::_State_manager	(	_State_manager< _Ty > &&	_Other,
		bool	_Get_once = `false`
	)

inline

         : _Assoc_state(0)
         {   // construct from rvalue _Other
         _Move_from(_Other);
         _Get_only_once = _Get_once;
         }

template<class _Ty>

_State_manager< _Ty >::~_State_manager ( )

inline

         {   // destroy
         if (_Assoc_state != 0)
             _Assoc_state->_Release();
         }

Member Function Documentation

template<class _Ty>

void _State_manager< _Ty >::_Abandon ( )

inline

         {   // abandon shared state
         if (_Assoc_state)
             _Assoc_state->_Abandon();
         }

template<class _Ty>

void _State_manager< _Ty >::_Copy_from ( const _State_manager< _Ty > & _Other )

inline

         {   // copy stored associated asynchronous state object from _Other
         if (this != _STD addressof(_Other))
             {   // different, copy
             if (_Assoc_state)
                 _Assoc_state->_Release();
             if (_Other._Assoc_state == 0)
                 _Assoc_state = 0;
             else
                 {   // do the copy
                 _Other._Assoc_state->_Retain();
                 _Assoc_state = _Other._Assoc_state;
                 _Get_only_once = _Other._Get_only_once;
                 }
             }
         }

template<class _Ty>

_Ty& _State_manager< _Ty >::_Get_value ( ) const

inline

         {   // return the stored result or throw stored exception
         if (!valid())
             _Throw_future_error(
                 make_error_code(future_errc::no_state));
         return (_Assoc_state->_Get_value(_Get_only_once));
         }

template<class _Ty>

bool _State_manager< _Ty >::_Is_ready ( ) const

inline

         {   // return ready status
         return (_Assoc_state && _Assoc_state->_Is_ready());
         }

template<class _Ty>

bool _State_manager< _Ty >::_Is_ready_at_thread_exit ( ) const

inline

         {   // return ready at thread exit status
         return (_Assoc_state && _Assoc_state->_Is_ready_at_thread_exit());
         }

template<class _Ty>

void _State_manager< _Ty >::_Move_from ( _State_manager< _Ty > & _Other )

inline

         {   // move stored associated asynchronous state object from _Other
         if (this != _STD addressof(_Other))
             {   // different, move
             if (_Assoc_state)
                 _Assoc_state->_Release();
             _Assoc_state = _Other._Assoc_state;
             _Other._Assoc_state = 0;
             _Get_only_once = _Other._Get_only_once;
             }
         }

template<class _Ty>

_Associated_state<_Ty>* _State_manager< _Ty >::_Ptr ( ) const

inline

         {   // return pointer to stored associated asynchronous state object
         return (_Assoc_state);
         }

template<class _Ty>

void _State_manager< _Ty >::_Set_exception	(	exception_ptr	_Exc,
		bool	_Defer
	)

inline

         {   // store a result
         if (!valid())
             _Throw_future_error(
                 make_error_code(future_errc::no_state));
         _Assoc_state->_Set_exception(_Exc, _Defer);
         }

template<class _Ty>

void _State_manager< _Ty >::_Set_value	(	const _Ty &	_Val,
		bool	_Defer
	)

inline

         {   // store a result
         if (!valid())
             _Throw_future_error(
                 make_error_code(future_errc::no_state));
         _Assoc_state->_Set_value(_Val, _Defer);
         }

template<class _Ty>

void _State_manager< _Ty >::_Set_value	(	_Ty &&	_Val,
		bool	_Defer
	)

inline

         {   // store a result
         if (!valid())
             _Throw_future_error(
                 make_error_code(future_errc::no_state));
         _Assoc_state->_Set_value(_STD forward<_Ty>(_Val), _Defer);
         }

template<class _Ty>

void _State_manager< _Ty >::_Swap ( _State_manager< _Ty > & _Other )

inline

         {   // exchange with _Other
         _STD swap(_Assoc_state, _Other._Assoc_state);
         }

template<class _Ty>

_State_manager& _State_manager< _Ty >::operator= ( const _State_manager< _Ty > & _Other )

inline

         {   // assign from _Other
         _Copy_from(_Other);
         return (*this);
         }

template<class _Ty>

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

inline

         {   // assign from rvalue _Other
         _Move_from(_Other);
         return (*this);
         }

template<class _Ty>

bool _State_manager< _Ty >::valid ( ) const

inline

         {   // return status
         return (_Assoc_state != 0
             && !(_Get_only_once && _Assoc_state->_Already_retrieved()));
         }

template<class _Ty>

void _State_manager< _Ty >::wait ( ) const

inline

         {   // wait for signal
         if (!valid())
             _Throw_future_error(make_error_code(future_errc::no_state));
         _Assoc_state->_Wait();
         }

template<class _Ty>

template<class _Rep , class _Per >

_Future_status _State_manager< _Ty >::wait_for ( const chrono::duration< _Rep, _Per > & _Rel_time ) const

inline

         {   // wait for duration
         if (!valid())
             _Throw_future_error(make_error_code(future_errc::no_state));
         return (_Assoc_state->_Wait_for(_Rel_time));
         }

template<class _Ty>

template<class _Clock , class _Dur >

_Future_status _State_manager< _Ty >::wait_until ( const chrono::time_point< _Clock, _Dur > & _Abs_time ) const

inline

         {   // wait until time point
         if (!valid())
             _Throw_future_error(make_error_code(future_errc::no_state));
         return (_Assoc_state->_Wait_until(_Abs_time));
         }

Member Data Documentation

template<class _Ty>

_Associated_state<_Ty>* _State_manager< _Ty >::_Assoc_state

private

template<class _Ty>

bool _State_manager< _Ty >::_Get_only_once

private

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

VS2017/inc/future

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation