shared_lock< _Mutex > Class Template Reference

Public Types
typedef _Mutex	mutex_type

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

Private Member Functions
void	_Validate () const

Private Attributes
_Mutex *	_Pmtx
bool	_Owns

Member Typedef Documentation

template<class _Mutex>

typedef _Mutex shared_lock< _Mutex >::mutex_type

Constructor & Destructor Documentation

template<class _Mutex>

shared_lock< _Mutex >::shared_lock ( )

inline

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

template<class _Mutex>

shared_lock< _Mutex >::shared_lock ( mutex_type &  _Mtx )

inlineexplicit

        : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
        {   // construct with mutex and lock shared
        _Mtx.lock_shared();
        }

template<class _Mutex>

shared_lock< _Mutex >::shared_lock ( mutex_type &  _Mtx, defer_lock_t    )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(false)
        {   // construct with unlocked mutex
        }

template<class _Mutex>

shared_lock< _Mutex >::shared_lock ( mutex_type &  _Mtx, try_to_lock_t    )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared())
        {   // construct with mutex and try to lock shared
        }

template<class _Mutex>

shared_lock< _Mutex >::shared_lock ( mutex_type &  _Mtx, adopt_lock_t    )

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
        {   // construct with mutex and adopt ownership
        }

template<class _Mutex>

template<class _Rep , class _Period >

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

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_for(_Rel_time))
        {   // construct with mutex and try to lock for relative time
        }

template<class _Mutex>

template<class _Clock , class _Duration >

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

inline

        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_until(_Abs_time))
        {   // construct with mutex and try to lock until absolute time
        }

template<class _Mutex>

shared_lock< _Mutex >::~shared_lock ( )

inline

        {   // destroy the lock
        if (_Owns)
            _Pmtx->unlock_shared();
        }

template<class _Mutex>

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

inline

        : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns)
        {   // construct by moving _Other
        _Other._Pmtx = 0;
        _Other._Owns = false;
        }

template<class _Mutex>

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

delete

Member Function Documentation

template<class _Mutex>

void shared_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 shared_lock< _Mutex >::lock ( )

inline

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

template<class _Mutex>

mutex_type* shared_lock< _Mutex >::mutex ( ) const

inline

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

template<class _Mutex>

shared_lock< _Mutex >::operator bool ( ) const

inlineexplicit

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

template<class _Mutex>

shared_lock& shared_lock< _Mutex >::operator= ( shared_lock< _Mutex > &&  _Right )

inline

        {   // copy by moving _Right
        if (_Owns)
            _Pmtx->unlock_shared();
        _Pmtx = _Right._Pmtx;
        _Owns = _Right._Owns;
        _Right._Pmtx = 0;
        _Right._Owns = false;
        return (*this);
        }

template<class _Mutex>

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

delete

template<class _Mutex>

bool shared_lock< _Mutex >::owns_lock ( ) const

inline

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

template<class _Mutex>

mutex_type* shared_lock< _Mutex >::release ( )

inline

        {   // release the mutex
        _Mutex *_Res = _Pmtx;
        _Pmtx = 0;
        _Owns = false;
        return (_Res);
        }

template<class _Mutex>

void shared_lock< _Mutex >::swap ( shared_lock< _Mutex > &  _Right )

inline

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

template<class _Mutex>

bool shared_lock< _Mutex >::try_lock ( )

inline

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

template<class _Mutex>

template<class _Rep , class _Period >

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

inline

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

template<class _Mutex>

template<class _Clock , class _Duration >

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

inline

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

template<class _Mutex>

void shared_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_shared();
        _Owns = false;
        }

Member Data Documentation

template<class _Mutex>

bool shared_lock< _Mutex >::_Owns

private

template<class _Mutex>

_Mutex* shared_lock< _Mutex >::_Pmtx

private

---

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

• VS2017/inc/shared_mutex