_State_manager< _Ty > Class Template Reference

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	_Set_exception (_XSTD 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

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 >::_Copy_from ( const _State_manager< _Ty > &  _Other )

inline

        {   // copy stored associated asynchronous state object from _Other
        if (this != &_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 status
        return (_Assoc_state && _Assoc_state->_Is_ready());
        }

template<class _Ty>

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

inline

        {   // move stored associated asynchronous state object from _Other
        if (this != &_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 ( _XSTD 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:

• VS2013/inc/future