stdext::threads::condition Class Reference

Public Member Functions
	condition ()
	~condition () _NOEXCEPT
void	notify_one ()
void	notify_all ()
template<class _Scopedlock >
void	wait (_Scopedlock &_Lock)
template<class _Scopedlock , class _Predicate >
void	wait (_Scopedlock &_Lock, _Predicate _Pred)
template<class _Scopedlock >
bool	timed_wait (_Scopedlock &_Lock, const xtime &_Xt)
template<class _Scopedlock , class _Predicate >
bool	timed_wait (_Scopedlock &_Lock, const xtime &_Xt, _Predicate _Pred)
template<class _Scopedlock >
void	_Register (_Scopedlock &_Lck)

Private Member Functions
	condition (const condition &)
condition &	operator= (const condition &)

Private Attributes
_Cnd_t	_Cond

Constructor & Destructor Documentation

stdext::threads::condition::condition ( )

inline

        {   // construct
        _Validate(_Cnd_init(&_Cond));
        }

stdext::threads::condition::~condition ( )

inline

        {   // destroy
        _Cnd_destroy(&_Cond);
        }

stdext::threads::condition::condition ( const condition &  )

private

Member Function Documentation

template<class _Scopedlock >

void stdext::threads::condition::_Register ( _Scopedlock &  _Lck )

inline

        {   // register *this for notify_all at thread exit
        _Cnd_register_at_thread_exit(&_Cond, &_Lck._My_lock._Mtx._Mtx, 0);
        }

void stdext::threads::condition::notify_all ( )

inline

        {   // release all blocked threads
        _Validate(_Cnd_broadcast(&_Cond));
        }

void stdext::threads::condition::notify_one ( )

inline

        {   // release up to one blocked thread
        _Validate(_Cnd_signal(&_Cond));
        }

condition& stdext::threads::condition::operator= ( const condition &  )

private

template<class _Scopedlock >

bool stdext::threads::condition::timed_wait ( _Scopedlock &  _Lock, const xtime &  _Xt  )

inline

        {   // block until signalled, or until time _Xt
        if (!_Lock)
            _Throw_lock_error();
        return (_Validate(_Cnd_timedwait(&_Cond,
            &_Lock._My_lock._Mtx._Mtx, &_Xt)) == thrd_success);
        }

template<class _Scopedlock , class _Predicate >

bool stdext::threads::condition::timed_wait ( _Scopedlock &  _Lock, const xtime &  _Xt, _Predicate  _Pred  )

inline

        {   // block until signalled and _Pred is true, or until time _Xt
        if (!_Lock)
            _Throw_lock_error();
        int _Res = thrd_success;
        while (!_Pred() && _Res == thrd_success)
            _Res = _Validate(_Cnd_timedwait(&_Cond,
                &_Lock._My_lock._Mtx._Mtx, &_Xt));
        return (_Res == thrd_success);
        }

template<class _Scopedlock >

void stdext::threads::condition::wait ( _Scopedlock &  _Lock )

inline

        {   // block until signalled
        if (!_Lock)
            _Throw_lock_error();
        _Validate(_Cnd_wait(&_Cond, &_Lock._My_lock._Mtx._Mtx));
        }

template<class _Scopedlock , class _Predicate >

void stdext::threads::condition::wait ( _Scopedlock &  _Lock, _Predicate  _Pred  )

inline

        {   // block until signalled and _Pred is true
        if (!_Lock)
            _Throw_lock_error();
        while (!_Pred())
            _Validate(_Cnd_wait(&_Cond, &_Lock._My_lock._Mtx._Mtx));
        }

Member Data Documentation

_Cnd_t stdext::threads::condition::_Cond

private

---

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

• VS2013/inc/thr/condition