unique_lock< _Mutex > Class Template Reference

Public Types
typedef unique_lock< _Mutex >	_Myt
typedef _Mutex	mutex_type

Public Member Functions
	unique_lock () _NOEXCEPT
	unique_lock (_Mutex &_Mtx)
	unique_lock (_Mutex &_Mtx, adopt_lock_t)
	unique_lock (_Mutex &_Mtx, defer_lock_t) _NOEXCEPT
	unique_lock (_Mutex &_Mtx, try_to_lock_t)
template<class _Rep , class _Period >
	unique_lock (_Mutex &_Mtx, const chrono::duration< _Rep, _Period > &_Rel_time)
template<class _Clock , class _Duration >
	unique_lock (_Mutex &_Mtx, const chrono::time_point< _Clock, _Duration > &_Abs_time)
	unique_lock (_Mutex &_Mtx, const xtime *_Abs_time)
	unique_lock (unique_lock &&_Other) _NOEXCEPT
unique_lock &	operator= (unique_lock &&_Other)
	~unique_lock () _NOEXCEPT
	unique_lock (const unique_lock &)=delete
unique_lock &	operator= (const unique_lock &)=delete
void	lock ()
bool	try_lock ()
template<class _Rep , class _Period >
bool	try_lock_for (const chrono::duration< _Rep, _Period > &_Rel_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)
void	unlock ()
void	swap (unique_lock &_Other) _NOEXCEPT
_Mutex *	release () _NOEXCEPT
bool	owns_lock () const _NOEXCEPT
	operator bool () const _NOEXCEPT
_Mutex *	mutex () const _NOEXCEPT

Private Member Functions
void	_Validate () const

Private Attributes
_Mutex *	_Pmtx
bool	_Owns

Member Typedef Documentation

template<class _Mutex>

typedef unique_lock<_Mutex> unique_lock< _Mutex >::_Myt

template<class _Mutex>

typedef _Mutex unique_lock< _Mutex >::mutex_type

Constructor & Destructor Documentation

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( )

inline

        : _Pmtx(0), _Owns(false)
        {   // default construct
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx )

inlineexplicit

        : _Pmtx(_STD addressof(_Mtx)), _Owns(false)
        {   // construct and lock
        _Pmtx->lock();
        _Owns = true;
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx, adopt_lock_t    )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
        {   // construct and assume already locked
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx, defer_lock_t    )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(false)
        {   // construct but don't lock
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx, try_to_lock_t    )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock())
        {   // construct and try to lock
        }

template<class _Mutex>

template<class _Rep , class _Period >

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx, const chrono::duration< _Rep, _Period > &  _Rel_time  )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock_for(_Rel_time))
        {   // construct and lock with timeout
        }

template<class _Mutex>

template<class _Clock , class _Duration >

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx, const chrono::time_point< _Clock, _Duration > &  _Abs_time  )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock_until(_Abs_time))
        {   // construct and lock with timeout
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( _Mutex &  _Mtx, const xtime *  _Abs_time  )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(false)
        {   // try to lock until _Abs_time
        _Owns = _Pmtx->try_lock_until(_Abs_time);
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( unique_lock< _Mutex > &&  _Other )

inline

        : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns)
        {   // destructive copy
        _Other._Pmtx = 0;
        _Other._Owns = false;
        }

template<class _Mutex>

unique_lock< _Mutex >::~unique_lock ( )

inline

        {   // clean up
        if (_Owns)
            _Pmtx->unlock();
        }

template<class _Mutex>

unique_lock< _Mutex >::unique_lock ( const unique_lock< _Mutex > &  )

delete

Member Function Documentation

template<class _Mutex>

void unique_lock< _Mutex >::_Validate ( ) const

inlineprivate

        {   // check if the mutex can be locked
        if (!_Pmtx)
            _THROW_NCEE(system_error,
                _STD make_error_code(errc::operation_not_permitted));

        if (_Owns)
            _THROW_NCEE(system_error,
                _STD make_error_code(errc::resource_deadlock_would_occur));
        }

template<class _Mutex>

void unique_lock< _Mutex >::lock ( )

inline

        {   // lock the mutex
        _Validate();
        _Pmtx->lock();
        _Owns = true;
        }

template<class _Mutex>

_Mutex* unique_lock< _Mutex >::mutex ( ) const

inline

        {   // return pointer to managed mutex
        return (_Pmtx);
        }

template<class _Mutex>

unique_lock< _Mutex >::operator bool ( ) const

inlineexplicit

        {   // return true if this object owns the lock
        return (_Owns);
        }

template<class _Mutex>

unique_lock& unique_lock< _Mutex >::operator= ( unique_lock< _Mutex > &&  _Other )

inline

        {   // destructive copy
        if (this != _STD addressof(_Other))
            {   // different, move contents
            if (_Owns)
                _Pmtx->unlock();
            _Pmtx = _Other._Pmtx;
            _Owns = _Other._Owns;
            _Other._Pmtx = 0;
            _Other._Owns = false;
            }
        return (*this);
        }

template<class _Mutex>

unique_lock& unique_lock< _Mutex >::operator= ( const unique_lock< _Mutex > &  )

delete

template<class _Mutex>

bool unique_lock< _Mutex >::owns_lock ( ) const

inline

        {   // return true if this object owns the lock
        return (_Owns);
        }

template<class _Mutex>

_Mutex* unique_lock< _Mutex >::release ( )

inline

        {   // disconnect
        _Mutex *_Res = _Pmtx;
        _Pmtx = 0;
        _Owns = false;
        return (_Res);
        }

template<class _Mutex>

void unique_lock< _Mutex >::swap ( unique_lock< _Mutex > &  _Other )

inline

        {   // swap with _Other
        _STD swap(_Pmtx, _Other._Pmtx);
        _STD swap(_Owns, _Other._Owns);
        }

template<class _Mutex>

bool unique_lock< _Mutex >::try_lock ( )

inline

        {   // try to lock the mutex
        _Validate();
        _Owns = _Pmtx->try_lock();
        return (_Owns);
        }

template<class _Mutex>

template<class _Rep , class _Period >

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

inline

        {   // try to lock mutex for _Rel_time
        _Validate();
        _Owns = _Pmtx->try_lock_for(_Rel_time);
        return (_Owns);
        }

template<class _Mutex>

template<class _Clock , class _Duration >

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

inline

        {   // try to lock mutex until _Abs_time
        _Validate();
        _Owns = _Pmtx->try_lock_until(_Abs_time);
        return (_Owns);
        }

template<class _Mutex>

bool unique_lock< _Mutex >::try_lock_until ( const xtime *  _Abs_time )

inline

        {   // try to lock the mutex until _Abs_time
        _Validate();
        _Owns = _Pmtx->try_lock_until(_Abs_time);
        return (_Owns);
        }

template<class _Mutex>

void unique_lock< _Mutex >::unlock ( )

inline

        {   // try to unlock the mutex
        if (!_Pmtx || !_Owns)
            _THROW_NCEE(system_error,
                _STD make_error_code(errc::operation_not_permitted));

        _Pmtx->unlock();
        _Owns = false;
        }

Member Data Documentation

template<class _Mutex>

bool unique_lock< _Mutex >::_Owns

private

template<class _Mutex>

_Mutex* unique_lock< _Mutex >::_Pmtx

private

---

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

• VS2017/inc/mutex