_Associated_state< _Ty > Class Template Reference

Classes
struct	_Test_ready

Public Types
typedef _Ty	_State_type
typedef _Deleter_base< _Ty >	_Mydel

Public Member Functions
	_Associated_state (_Mydel *_Dp=0)
virtual	~_Associated_state () _NOEXCEPT
void	_Retain ()
void	_Release ()
virtual void	_Wait ()
template<class _Rep , class _Per >
_Future_status	_Wait_for (const chrono::duration< _Rep, _Per > &_Rel_time)
template<class _Clock , class _Dur >
_Future_status	_Wait_until (const chrono::time_point< _Clock, _Dur > &_Abs_time)
virtual _Ty &	_Get_value (bool _Get_only_once)
void	_Set_value (const _Ty &_Val, bool _At_thread_exit)
void	_Set_value_raw (const _Ty &_Val, unique_lock< mutex > *_Lock, bool _At_thread_exit)
void	_Set_value (_Ty &&_Val, bool _At_thread_exit)
void	_Set_value_raw (_Ty &&_Val, unique_lock< mutex > *_Lock, bool _At_thread_exit)
void	_Set_value (bool _At_thread_exit)
void	_Set_value_raw (unique_lock< mutex > *_Lock, bool _At_thread_exit)
void	_Set_exception (exception_ptr _Exc, bool _At_thread_exit)
void	_Set_exception_raw (exception_ptr _Exc, unique_lock< mutex > *_Lock, bool _At_thread_exit)
bool	_Is_ready () const
bool	_Is_ready_at_thread_exit () const
bool	_Already_has_stored_result () const
bool	_Already_retrieved () const
void	_Abandon ()
	_Associated_state (const _Associated_state &)=delete
_Associated_state &	operator= (const _Associated_state &)=delete

Public Attributes
_Ty	_Result
exception_ptr	_Exception
mutex	_Mtx
condition_variable	_Cond
bool	_Retrieved
int	_Ready
bool	_Ready_at_thread_exit
bool	_Has_stored_result
bool	_Running

Protected Member Functions
void	_Make_ready_at_thread_exit ()
void	_Maybe_run_deferred_function (unique_lock< mutex > &_Lock)

Private Member Functions
virtual bool	_Has_deferred_function () const _NOEXCEPT
virtual void	_Run_deferred_function (unique_lock< mutex > &)
virtual void	_Do_notify (unique_lock< mutex > *_Lock, bool _At_thread_exit)
void	_Delete_this ()

Private Attributes
_Atomic_counter_t	_Refs
_Mydel *	_Deleter

Member Typedef Documentation

template<class _Ty>

typedef _Deleter_base<_Ty> _Associated_state< _Ty >::_Mydel

template<class _Ty>

typedef _Ty _Associated_state< _Ty >::_State_type

Constructor & Destructor Documentation

template<class _Ty>

_Associated_state< _Ty >::_Associated_state ( _Mydel *  _Dp = 0 )

inline

        : _Refs(1), // non-atomic initialization
        _Exception(),
        _Retrieved(false),
        _Running(false),
        _Ready(false),
        _Ready_at_thread_exit(false),
        _Has_stored_result(false),
        _Deleter(_Dp)
        {   // construct
        // TODO: _Associated_state ctor assumes _Ty is default constructible
        }

template<class _Ty>

virtual _Associated_state< _Ty >::~_Associated_state ( )

inlinevirtual

        {   // destroy
        if (_Has_stored_result && !_Ready)
            {   // registered for release at thread exit
            _Cond._Unregister(_Mtx);
            }
        }

template<class _Ty>

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

delete

Member Function Documentation

template<class _Ty>

void _Associated_state< _Ty >::_Abandon ( )

inline

        {   // abandon shared state
        unique_lock<mutex> _Lock(_Mtx);
        if (!_Has_stored_result)
            {   // queue exception
            future_error _Fut(make_error_code(future_errc::broken_promise));
            _Set_exception_raw(_STD make_exception_ptr(_Fut), &_Lock, false);
            }
        }

template<class _Ty>

bool _Associated_state< _Ty >::_Already_has_stored_result ( ) const

inline

        {   // return presence of stored result
        return (_Has_stored_result);
        }

template<class _Ty>

bool _Associated_state< _Ty >::_Already_retrieved ( ) const

inline

        {   // return retrieved status
        return (_Retrieved);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Delete_this ( )

inlineprivate

        {   // delete this object
        if (_Deleter)
            _Deleter->_Delete(this);
        else
            delete this;
        }

template<class _Ty>

virtual void _Associated_state< _Ty >::_Do_notify ( unique_lock< mutex > *  _Lock, bool  _At_thread_exit  )

inlineprivatevirtual

        {   // notify waiting threads
        _Has_stored_result = true;
        if (_At_thread_exit)
            {   // notify at thread exit
            _Cond._Register(*_Lock, &_Ready);
            }
        else
            {   // notify immediately
            _Ready = true;
            _Cond.notify_all();
            }
        }

template<class _Ty>

virtual _Ty& _Associated_state< _Ty >::_Get_value ( bool  _Get_only_once )

inlinevirtual

        {   // return the stored result or throw stored exception
        unique_lock<mutex> _Lock(_Mtx);
        if (_Get_only_once && _Retrieved)
            _Throw_future_error(
                make_error_code(future_errc::future_already_retrieved));
        if (_Exception)
            _Rethrow_future_exception(_Exception);
        _Retrieved = true;
        _Maybe_run_deferred_function(_Lock);
        while (!_Ready)
            _Cond.wait(_Lock);
        if (_Exception)
            _Rethrow_future_exception(_Exception);
        return (_Result);
        }

template<class _Ty>

virtual bool _Associated_state< _Ty >::_Has_deferred_function ( ) const

inlineprivatevirtual

        {   // overridden by _Deferred_async_state
        return (false);
        }

template<class _Ty>

bool _Associated_state< _Ty >::_Is_ready ( ) const

inline

        {   // return ready status
        return (_Ready != 0);
        }

template<class _Ty>

bool _Associated_state< _Ty >::_Is_ready_at_thread_exit ( ) const

inline

        {   // return ready at thread exit status
        return (_Ready_at_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Make_ready_at_thread_exit ( )

inlineprotected

        {   // set ready status at thread exit
        if (_Ready_at_thread_exit)
            _Ready = true;
        }

template<class _Ty>

void _Associated_state< _Ty >::_Maybe_run_deferred_function ( unique_lock< mutex > &  _Lock )

inlineprotected

        {   // run a deferred function if not already done
        if (!_Running)
            {   // run the function
            _Running = true;
            _Run_deferred_function(_Lock);
            }
        }

template<class _Ty>

void _Associated_state< _Ty >::_Release ( )

inline

        {   // decrement reference count and destroy when zero
        if (_MT_DECR(_Refs) == 0)
            _Delete_this();
        }

template<class _Ty>

void _Associated_state< _Ty >::_Retain ( )

inline

        {   // increment reference count
        _MT_INCR(_Refs);
        }

template<class _Ty>

virtual void _Associated_state< _Ty >::_Run_deferred_function ( unique_lock< mutex > &  )

inlineprivatevirtual

        {   // do nothing
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_exception ( exception_ptr  _Exc, bool  _At_thread_exit  )

inline

        {   // store a result
        unique_lock<mutex> _Lock(_Mtx);
        _Set_exception_raw(_Exc, &_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_exception_raw ( exception_ptr  _Exc, unique_lock< mutex > *  _Lock, bool  _At_thread_exit  )

inline

        {   // store a result while inside a locked block
        if (_Has_stored_result)
            _Throw_future_error(
                make_error_code(future_errc::promise_already_satisfied));
        _Exception = _Exc;
        _Do_notify(_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_value ( const _Ty &  _Val, bool  _At_thread_exit  )

inline

        {   // store a result
        unique_lock<mutex> _Lock(_Mtx);
        _Set_value_raw(_Val, &_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_value ( _Ty &&  _Val, bool  _At_thread_exit  )

inline

        {   // store a result
        unique_lock<mutex> _Lock(_Mtx);
        _Set_value_raw(_STD forward<_Ty>(_Val), &_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_value ( bool  _At_thread_exit )

inline

        {   // store a (void) result
        unique_lock<mutex> _Lock(_Mtx);
        _Set_value_raw(&_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_value_raw ( const _Ty &  _Val, unique_lock< mutex > *  _Lock, bool  _At_thread_exit  )

inline

        {   // store a result while inside a locked block
        if (_Has_stored_result)
            _Throw_future_error(
                make_error_code(future_errc::promise_already_satisfied));
        _Result = _Val;
        _Do_notify(_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_value_raw ( _Ty &&  _Val, unique_lock< mutex > *  _Lock, bool  _At_thread_exit  )

inline

        {   // store a result while inside a locked block
        if (_Has_stored_result)
            _Throw_future_error(
                make_error_code(future_errc::promise_already_satisfied));
        _Result = _STD forward<_Ty>(_Val);
        _Do_notify(_Lock, _At_thread_exit);
        }

template<class _Ty>

void _Associated_state< _Ty >::_Set_value_raw ( unique_lock< mutex > *  _Lock, bool  _At_thread_exit  )

inline

        {   // store a (void) result while inside a locked block
        if (_Has_stored_result)
            _Throw_future_error(
                make_error_code(future_errc::promise_already_satisfied));
        _Do_notify(_Lock, _At_thread_exit);
        }

template<class _Ty>

virtual void _Associated_state< _Ty >::_Wait ( )

inlinevirtual

        {   // wait for signal
        unique_lock<mutex> _Lock(_Mtx);
        _Maybe_run_deferred_function(_Lock);
        while (!_Ready)
            _Cond.wait(_Lock);
        }

template<class _Ty>

template<class _Rep , class _Per >

_Future_status _Associated_state< _Ty >::_Wait_for ( const chrono::duration< _Rep, _Per > &  _Rel_time )

inline

        {   // wait for duration
        unique_lock<mutex> _Lock(_Mtx);
        if (_Has_deferred_function())
            return (_Future_status::deferred);
        if (_Cond.wait_for(_Lock, _Rel_time, _Test_ready(this)))
            return (_Future_status::ready);
        return (_Future_status::timeout);
        }

template<class _Ty>

template<class _Clock , class _Dur >

_Future_status _Associated_state< _Ty >::_Wait_until ( const chrono::time_point< _Clock, _Dur > &  _Abs_time )

inline

        {   // wait until time point
        unique_lock<mutex> _Lock(_Mtx);
        if (_Has_deferred_function())
            return (_Future_status::deferred);
        if (_Cond.wait_until(_Lock, _Abs_time, _Test_ready(this)))
            return (_Future_status::ready);
        return (_Future_status::timeout);
        }

template<class _Ty>

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

delete

Member Data Documentation

template<class _Ty>

condition_variable _Associated_state< _Ty >::_Cond

template<class _Ty>

_Mydel* _Associated_state< _Ty >::_Deleter

private

template<class _Ty>

exception_ptr _Associated_state< _Ty >::_Exception

template<class _Ty>

bool _Associated_state< _Ty >::_Has_stored_result

template<class _Ty>

mutex _Associated_state< _Ty >::_Mtx

template<class _Ty>

int _Associated_state< _Ty >::_Ready

template<class _Ty>

bool _Associated_state< _Ty >::_Ready_at_thread_exit

template<class _Ty>

_Atomic_counter_t _Associated_state< _Ty >::_Refs

private

template<class _Ty>

_Ty _Associated_state< _Ty >::_Result

template<class _Ty>

bool _Associated_state< _Ty >::_Retrieved

template<class _Ty>

bool _Associated_state< _Ty >::_Running

---

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

• VS2017/inc/future