condition_variable_any Class Reference

Public Member Functions
	condition_variable_any ()
	~condition_variable_any () _NOEXCEPT
	condition_variable_any (const condition_variable_any &)=delete
condition_variable_any &	operator= (const condition_variable_any &)=delete
void	notify_one () _NOEXCEPT
void	notify_all () _NOEXCEPT
template<class _Mutex >
void	wait (_Mutex &_Xtrnl)
template<class _Mutex , class _Predicate >
void	wait (_Mutex &_Xtrnl, _Predicate _Pred)
template<class _Lock , class _Rep , class _Period >
_Cv_status	wait_for (_Lock &_Lck, const chrono::duration< _Rep, _Period > &_Rel_time)
template<class _Lock , class _Rep , class _Period , class _Predicate >
bool	wait_for (_Lock &_Lck, const chrono::duration< _Rep, _Period > &_Rel_time, _Predicate _Pred)
template<class _Lock , class _Clock , class _Duration >
_Cv_status	wait_until (_Lock &_Lck, const chrono::time_point< _Clock, _Duration > &_Abs_time)
template<class _Lock , class _Clock , class _Duration , class _Predicate >
bool	wait_until (_Lock &_Lck, const chrono::time_point< _Clock, _Duration > &_Abs_time, _Predicate _Pred)
template<class _Mutex >
_Cv_status	wait_until (_Mutex &_Xtrnl, const xtime *_Abs_time)
template<class _Mutex , class _Predicate >
bool	wait_until (_Mutex &_Xtrnl, const xtime *_Abs_time, _Predicate _Pred)

Private Member Functions
_Cnd_t	_Mycnd () _NOEXCEPT

Private Attributes
shared_ptr< mutex >	_Myptr
aligned_storage< _Cnd_internal_imp_size, _Cnd_internal_imp_alignment >::type	_Cnd_storage

Constructor & Destructor Documentation

condition_variable_any::condition_variable_any ( )

inline

        {   // construct
        _Myptr = _STD make_shared<mutex>();
        _Cnd_init_in_situ(_Mycnd());
        }

condition_variable_any::~condition_variable_any ( )

inline

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

condition_variable_any::condition_variable_any ( const condition_variable_any &  )

delete

Member Function Documentation

_Cnd_t condition_variable_any::_Mycnd ( )

inlineprivate

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

void condition_variable_any::notify_all ( )

inline

        {   // wake up all waiters
        _Myptr->lock();
        _Cnd_broadcastX(_Mycnd());
        _Myptr->unlock();
        }

void condition_variable_any::notify_one ( )

inline

        {   // wake up one waiter
        _Myptr->lock();
        _Cnd_signalX(_Mycnd());
        _Myptr->unlock();
        }

condition_variable_any& condition_variable_any::operator= ( const condition_variable_any &  )

delete

template<class _Mutex >

void condition_variable_any::wait ( _Mutex &  _Xtrnl )

inline

        {   // wait for signal
        shared_ptr<mutex> _Ptr = _Myptr;    // immune to *this destruction
        _Ptr->lock();
        _Xtrnl.unlock();
        _Cnd_waitX(_Mycnd(), _Ptr->_Mymtx());
        _Ptr->unlock();
        _Xtrnl.lock();
        }

template<class _Mutex , class _Predicate >

void condition_variable_any::wait ( _Mutex &  _Xtrnl, _Predicate  _Pred  )

inline

        {   // wait for signal and check predicate
        while (!_Pred())
            wait(_Xtrnl);
        }

template<class _Lock , class _Rep , class _Period >

_Cv_status condition_variable_any::wait_for ( _Lock &  _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 _Lock , class _Rep , class _Period , class _Predicate >

bool condition_variable_any::wait_for ( _Lock &  _Lck, const chrono::duration< _Rep, _Period > &  _Rel_time, _Predicate  _Pred  )

inline

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

template<class _Lock , class _Clock , class _Duration >

_Cv_status condition_variable_any::wait_until ( _Lock &  _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 _Lock , class _Clock , class _Duration , class _Predicate >

bool condition_variable_any::wait_until ( _Lock &  _Lck, const chrono::time_point< _Clock, _Duration > &  _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);
        }

template<class _Mutex >

_Cv_status condition_variable_any::wait_until ( _Mutex &  _Xtrnl, const xtime *  _Abs_time  )

inline

        {   // wait for signal with timeout
        shared_ptr<mutex> _Ptr = _Myptr;    // immune to *this destruction
        _Ptr->lock();
        _Xtrnl.unlock();
        int _Res = _Cnd_timedwaitX(_Mycnd(),
            _Ptr->_Mymtx(), _Abs_time);
        _Ptr->unlock();
        _Xtrnl.lock();
        return (_Res == _Thrd_timedout
            ? cv_status::timeout : cv_status::no_timeout);
        }

template<class _Mutex , class _Predicate >

bool condition_variable_any::wait_until ( _Mutex &  _Xtrnl, const xtime *  _Abs_time, _Predicate  _Pred  )

inline

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

Member Data Documentation

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

private

shared_ptr<mutex> condition_variable_any::_Myptr

private

---

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

• VS2015/inc/condition_variable