condition_variable Class Reference

Public Types
typedef _Cnd_t	native_handle_type

Public Member Functions
	condition_variable ()
	~condition_variable () _NOEXCEPT
	condition_variable (const condition_variable &)=delete
condition_variable &	operator= (const condition_variable &)=delete
void	notify_one () _NOEXCEPT
void	notify_all () _NOEXCEPT
void	wait (unique_lock< mutex > &_Lck)
template<class _Predicate >
void	wait (unique_lock< mutex > &_Lck, _Predicate _Pred)
template<class _Rep , class _Period >
_Cv_status	wait_for (unique_lock< mutex > &_Lck, const chrono::duration< _Rep, _Period > &_Rel_time)
template<class _Rep , class _Period , class _Predicate >
bool	wait_for (unique_lock< mutex > &_Lck, const chrono::duration< _Rep, _Period > &_Rel_time, _Predicate _Pred)
template<class _Clock , class _Duration >
_Cv_status	wait_until (unique_lock< mutex > &_Lck, const chrono::time_point< _Clock, _Duration > &_Abs_time)
template<class _Clock , class _Duration , class _Predicate >
bool	wait_until (unique_lock< mutex > &_Lck, const chrono::time_point< _Clock, _Duration > &_Abs_time, _Predicate _Pred)
_Cv_status	wait_until (unique_lock< mutex > &_Lck, const xtime *_Abs_time)
template<class _Predicate >
bool	wait_until (unique_lock< mutex > &_Lck, const xtime *_Abs_time, _Predicate _Pred)
native_handle_type	native_handle ()
void	_Register (unique_lock< mutex > &_Lck, int *_Ready)
void	_Unregister (mutex &_Mtx)

Private Attributes
_Cnd_t	_Cnd

Member Typedef Documentation

typedef _Cnd_t condition_variable::native_handle_type

Constructor & Destructor Documentation

condition_variable::condition_variable ( )

inline

        {   // construct
        _Cnd_initX(&_Cnd);
        }

condition_variable::~condition_variable ( )

inline

        {   // destroy
        _Cnd_destroy(&_Cnd);
        }

condition_variable::condition_variable ( const condition_variable &  )

delete

Member Function Documentation

void condition_variable::_Register ( unique_lock< mutex > &  _Lck, int *  _Ready  )

inline

        {   // register this object for release at thread exit
        _Cnd_register_at_thread_exit(&_Cnd, &_Lck.release()->_Mtx, _Ready);
        }

void condition_variable::_Unregister ( mutex &  _Mtx )

inline

        {   // unregister this object for release at thread exit
        _Cnd_unregister_at_thread_exit(&_Mtx._Mtx);
        }

native_handle_type condition_variable::native_handle ( )

inline

        {   // return condition variable handle
        return (_Cnd);
        }

void condition_variable::notify_all ( )

inline

        {   // wake up all waiters
        _Cnd_broadcastX(&_Cnd);
        }

void condition_variable::notify_one ( )

inline

        {   // wake up one waiter
        _Cnd_signalX(&_Cnd);
        }

condition_variable& condition_variable::operator= ( const condition_variable &  )

delete

void condition_variable::wait ( unique_lock< mutex > &  _Lck )

inline

        {   // wait for signal
        _Cnd_waitX(&_Cnd, &_Lck.mutex()->_Mtx);
        }

template<class _Predicate >

void condition_variable::wait ( unique_lock< mutex > &  _Lck, _Predicate  _Pred  )

inline

        {   // wait for signal and test predicate
        while (!_Pred())
            wait(_Lck);
        }

template<class _Rep , class _Period >

_Cv_status condition_variable::wait_for ( unique_lock< mutex > &  _Lck, const chrono::duration< _Rep, _Period > &  _Rel_time  )

inline

        {   // wait for duration
        stdext::threads::xtime _Tgt = _To_xtime(_Rel_time);
        return (wait_until(_Lck, &_Tgt));
        }

template<class _Rep , class _Period , class _Predicate >

bool condition_variable::wait_for ( unique_lock< mutex > &  _Lck, const chrono::duration< _Rep, _Period > &  _Rel_time, _Predicate  _Pred  )

inline

        {   // wait for signal with timeout and check predicate
        stdext::threads::xtime _Tgt = _To_xtime(_Rel_time);
        return (wait_until(_Lck, &_Tgt, _Pred));
        }

template<class _Clock , class _Duration >

_Cv_status condition_variable::wait_until ( unique_lock< mutex > &  _Lck, const chrono::time_point< _Clock, _Duration > &  _Abs_time  )

inline

        {   // wait until time point
        typename chrono::time_point<_Clock, _Duration>::duration
            _Rel_time = _Abs_time - _Clock::now();
        return (wait_for(_Lck, _Rel_time));
        }

template<class _Clock , class _Duration , class _Predicate >

bool condition_variable::wait_until ( unique_lock< mutex > &  _Lck, const chrono::time_point< _Clock, _Duration > &  _Abs_time, _Predicate  _Pred  )

inline

        {   // wait for signal with timeout and check predicate
        typename chrono::time_point<_Clock, _Duration>::duration
            _Rel_time = _Abs_time - _Clock::now();
        return (wait_for(_Lck, _Rel_time, _Pred));
        }

_Cv_status condition_variable::wait_until ( unique_lock< mutex > &  _Lck, const xtime *  _Abs_time  )

inline

        {   // wait for signal with timeout
        if (!_Mtx_current_owns(&_Lck.mutex()->_Mtx))
            _Throw_Cpp_error(_OPERATION_NOT_PERMITTED);
        int _Res = _Cnd_timedwaitX(&_Cnd, &_Lck.mutex()->_Mtx, _Abs_time);
        return (_Res == _Thrd_timedout
            ? cv_status::timeout : cv_status::no_timeout);
        }

template<class _Predicate >

bool condition_variable::wait_until ( unique_lock< mutex > &  _Lck, const xtime *  _Abs_time, _Predicate  _Pred  )

inline

        {   // wait for signal with timeout and check predicate
        bool _Res = true;
        while (_Res && !_Pred())
            _Res = wait_until(_Lck, _Abs_time)
                != cv_status::timeout;
        return (_Pred());
        }

Member Data Documentation

_Cnd_t condition_variable::_Cnd

private

---

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

• VS2013/inc/condition_variable