timed_mutex Class Reference

Public Member Functions
	timed_mutex () _NOEXCEPT
	timed_mutex (const timed_mutex &)=delete
timed_mutex &	operator= (const timed_mutex &)=delete
void	lock ()
bool	try_lock () _NOEXCEPT
void	unlock ()
template<class _Rep , class _Period >
bool	try_lock_for (const chrono::duration< _Rep, _Period > &_Rel_time)
template<class _Time >
bool	_Try_lock_until (_Time _Abs_time)
template<class _Clock , class _Duration >
bool	try_lock_until (const chrono::time_point< _Clock, _Duration > &_Abs_time)
bool	try_lock_until (const xtime *_Abs_time)

Private Attributes
mutex	_My_mutex
condition_variable	_My_cond
unsigned int	_My_locked

Constructor & Destructor Documentation

timed_mutex::timed_mutex ( )

inline

        : _My_locked(0)
        {   // default construct
        }

timed_mutex::timed_mutex ( const timed_mutex &  )

delete

Member Function Documentation

template<class _Time >

bool timed_mutex::_Try_lock_until ( _Time  _Abs_time )

inline

        {   // try to lock the mutex with timeout
        unique_lock<mutex> _Lock(_My_mutex);
        if (!_My_cond.wait_until(_Lock, _Abs_time,
            [this] { return (_My_locked == 0); }))
                return (false);
        _My_locked = UINT_MAX;
        return (true);
        }

void timed_mutex::lock ( )

inline

        {   // lock the mutex
        unique_lock<mutex> _Lock(_My_mutex);
        while (_My_locked != 0)
            _My_cond.wait(_Lock);
        _My_locked = UINT_MAX;
        }

timed_mutex& timed_mutex::operator= ( const timed_mutex &  )

delete

bool timed_mutex::try_lock ( )

inline

        {   // try to lock the mutex
        lock_guard<mutex> _Lock(_My_mutex);
        if (_My_locked != 0)
            return (false);
        else
            {
            _My_locked = UINT_MAX;
            return (true);
            }
        }

template<class _Rep , class _Period >

bool timed_mutex::try_lock_for ( const chrono::duration< _Rep, _Period > &  _Rel_time )

inline

        {   // try to lock for duration
        return (try_lock_until(chrono::steady_clock::now() + _Rel_time));
        }

template<class _Clock , class _Duration >

bool timed_mutex::try_lock_until ( const chrono::time_point< _Clock, _Duration > &  _Abs_time )

inline

        {   // try to lock the mutex with timeout
        return (_Try_lock_until(_Abs_time));
        }

bool timed_mutex::try_lock_until ( const xtime *  _Abs_time )

inline

        {   // try to lock the mutex with timeout
        return (_Try_lock_until(_Abs_time));
        }

void timed_mutex::unlock ( )

inline

        {   // unlock the mutex
            {
            // The lock here is necessary
            lock_guard<mutex> _Lock(_My_mutex);
            _My_locked = 0;
            }
        _My_cond.notify_one();
        }

Member Data Documentation

condition_variable timed_mutex::_My_cond

private

unsigned int timed_mutex::_My_locked

private

mutex timed_mutex::_My_mutex

private

---

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

• VS2017/inc/mutex