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)
template<class _Predicate >
bool	_Wait_until1 (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 Member Functions
_Cnd_t	_Mycnd () _NOEXCEPT

Private Attributes
aligned_storage< _Cnd_internal_imp_size, _Cnd_internal_imp_alignment >::type	_Cnd_storage

Member Typedef Documentation

typedef _Cnd_t condition_variable::native_handle_type

Constructor & Destructor Documentation

condition_variable::condition_variable ( )

inline

        {   // construct
        _Cnd_init_in_situ(_Mycnd());
        }

condition_variable::~condition_variable ( )

inline

        {   // destroy
        _Cnd_destroy_in_situ(_Mycnd());
        }

condition_variable::condition_variable ( const condition_variable &  )

delete

Member Function Documentation

_Cnd_t condition_variable::_Mycnd ( )

inlineprivate

        {   // get pointer to _Cnd_internal_imp_t inside _Cnd_storage
        return (reinterpret_cast<_Cnd_t>(&_Cnd_storage));
        }

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

inline

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

void condition_variable::_Unregister ( mutex &  _Mtx )

inline

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

template<class _Predicate >

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

inline

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

native_handle_type condition_variable::native_handle ( )

inline

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

void condition_variable::notify_all ( )

inline

        {   // wake up all waiters
        _Cnd_broadcastX(_Mycnd());
        }

void condition_variable::notify_one ( )

inline

        {   // wake up one waiter
        _Cnd_signalX(_Mycnd());
        }

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

delete

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

inline

        {   // wait for signal
        // Nothing to do to comply with LWG 2135 because std::mutex lock/unlock are nothrow
        _Cnd_waitX(_Mycnd(), _Lck.mutex()->_Mymtx());
        }

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_until1(_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();
        _STDEXT threads::xtime _Tgt = _To_xtime(_Rel_time);
        return (_Wait_until1(_Lck, &_Tgt, _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()->_Mymtx()))
            _Throw_Cpp_error(_OPERATION_NOT_PERMITTED);

        // Nothing to do to comply with LWG 2135 because std::mutex lock/unlock are nothrow
        int _Res = _Cnd_timedwaitX(_Mycnd(),
            _Lck.mutex()->_Mymtx(), _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
        return (_Wait_until1(_Lck, _Abs_time, _Pred));
        }

Member Data Documentation

aligned_storage<_Cnd_internal_imp_size, _Cnd_internal_imp_alignment>::type condition_variable::_Cnd_storage

private

---

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

• VS2017/inc/mutex