mutex File Reference

#include <chrono>
#include <functional>
#include <system_error>
#include <thread>
#include <tuple>
#include <utility>

Classes
class	_Mutex_base
class	mutex
class	recursive_mutex
struct	adopt_lock_t
struct	defer_lock_t
struct	try_to_lock_t
class	lock_guard< _Mutexes >
class	lock_guard< _Mutex >
class	lock_guard<>
class	unique_lock< _Mutex >
struct	once_flag
class	condition_variable
class	timed_mutex
class	recursive_timed_mutex

Macros
#define	_MUTEX_

Typedefs
typedef int(__stdcall *	_Lambda_fp_t) (void *, void *, void **)
typedef cv_status	_Cv_status

Enumerations
enum	cv_status { cv_status::no_timeout, cv_status::timeout }

Functions
template<class _Lock0 , class... _LockN>
int	try_lock (_Lock0 &, _LockN &...)
template<class _Lock0 >
int	_Try_lock (_Lock0 &_Lk0)
template<class _Lock0 , class _Lock1 , class... _LockN>
int	_Try_lock (_Lock0 &_Lk0, _Lock1 &_Lk1, _LockN &..._LkN)
template<class _Lock0 , class... _LockN>
int	try_lock (_Lock0 &_Lk0, _LockN &..._LkN)
template<class _Lock0 , class _Lock1 , class... _LockN>
void	lock (_Lock0 &_Lk0, _Lock1 &_Lk1, _LockN &..._LkN)
template<class _Mutex >
void	swap (unique_lock< _Mutex > &_Left, unique_lock< _Mutex > &_Right) _NOEXCEPT
template<class... _Types, size_t... _Indices>
auto	_Invoke_stored_explicit (tuple< _Types...> &&_Tuple, index_sequence< _Indices...>) -> decltype(_STD invoke(_STD get< _Indices >(_STD move(_Tuple))...))
template<class... _Types>
auto	_Invoke_stored (tuple< _Types...> &&_Tuple) -> decltype(_Invoke_stored_explicit(_STD move(_Tuple), index_sequence_for< _Types...>()))
_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL	_Execute_once (once_flag &_Flag, _Lambda_fp_t _Lambda_fp, void *_Pv) _NOEXCEPT
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_XGetLastError ()
template<class _Tuple , class _Seq , size_t _Idx>
int __stdcall	_Callback_once (void *, void *_Pv, void **)
template<class _Fn , class... _Args>
void()	call_once (once_flag &_Flag, _Fn &&_Fx, _Args &&..._Ax)

Variables
constexpr adopt_lock_t	adopt_lock {}
constexpr defer_lock_t	defer_lock {}
constexpr try_to_lock_t	try_to_lock {}

Macro Definition Documentation

#define _MUTEX_

Typedef Documentation

typedef cv_status _Cv_status

typedef int(__stdcall * _Lambda_fp_t) (void *, void *, void **)

Enumeration Type Documentation

enum cv_status

strong

Enumerator
no_timeout
timeout

                     {  // names for wait returns
    no_timeout,
    timeout
    };

Function Documentation

template<class _Tuple , class _Seq , size_t _Idx>

int __stdcall _Callback_once ( void *  , void *  _Pv, void **    )

inline

    {   // adapt call_once() to callback API
    _Tuple *_Ptup = static_cast<_Tuple *>(_Pv);

    _TRY_BEGIN
        // Note explicit _Seq() selects every element from *_Ptup except the last, which contains call_once's exception_ptr.
        _Invoke_stored_explicit(_STD move(*_Ptup), _Seq());
    _CATCH_ALL
        auto& _Ref = _STD get<_Idx>(*_Ptup);
        _Ref = _STD current_exception();
        return (0);
    _CATCH_END

    return (1);
    }

_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Execute_once	(	once_flag &	_Flag,
		_Lambda_fp_t	_Lambda_fp,
		void *	_Pv
	)

template<class... _Types>

auto _Invoke_stored ( tuple< _Types...> &&  _Tuple ) -> decltype(_Invoke_stored_explicit(_STD move(_Tuple), index_sequence_for<_Types...>()))

inline

    {   // invoke() a tuple
    return (_Invoke_stored_explicit(_STD move(_Tuple), index_sequence_for<_Types...>()));
    }

template<class... _Types, size_t... _Indices>

auto _Invoke_stored_explicit ( tuple< _Types...> &&  _Tuple, index_sequence< _Indices...>    ) -> decltype(_STD invoke(_STD get<_Indices>(_STD move(_Tuple))...))

inline

    {   // invoke() a tuple with explicit parameter ordering
    return (_STD invoke(_STD get<_Indices>(_STD move(_Tuple))...));
    }

template<class _Lock0 >

int _Try_lock ( _Lock0 &  _Lk0 )

inline

    {   // try to lock one mutex
    if (!_Lk0.try_lock())
        return (0);
    else
        return (-1);
    }

template<class _Lock0 , class _Lock1 , class... _LockN>

int _Try_lock ( _Lock0 &  _Lk0, _Lock1 &  _Lk1, _LockN &...  _LkN  )

inline

    {   // try to lock n-1 mutexes
    int _Res;
    if (!_Lk0.try_lock())
        return (0);
    _TRY_BEGIN
        // handle exceptions from tail lock
        if ((_Res = _STD try_lock(_Lk1, _LkN...)) != -1)
            {   // tail lock failed
            _Lk0.unlock();
            ++_Res;
            }
    _CATCH_ALL
        // tail lock threw exception
        _Lk0.unlock();
        throw;
    _CATCH_END
    return (_Res);
    }

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _XGetLastError

(

)

template<class _Fn , class... _Args>

void() call_once ( once_flag &  _Flag, _Fn &&  _Fx, _Args &&...  _Ax  )

inline

    {   // call _Fx(_Ax...) once
    typedef tuple<_Fn&&, _Args&&..., exception_ptr&> _Tuple;
    typedef make_index_sequence<1 + sizeof...(_Args)> _Seq;

    exception_ptr _Exc;
    _Tuple _Tup(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)..., _Exc);

    _Lambda_fp_t _Fp = &_Callback_once<_Tuple, _Seq, 1 + sizeof...(_Args)>;

    if (_Execute_once(_Flag, _Fp, _STD addressof(_Tup)) != 0)
        return;

    if (_Exc)
        _STD rethrow_exception(_Exc);

    _XGetLastError();
    }

template<class _Lock0 , class _Lock1 , class... _LockN>

void lock ( _Lock0 &  _Lk0, _Lock1 &  _Lk1, _LockN &...  _LkN  )

inline

    {   // lock N mutexes
    int _Res = 0;
    while (_Res != -1)
        _Res = _Try_lock(_Lk0, _Lk1, _LkN...);
    }

template<class _Mutex >

void swap	(	unique_lock< _Mutex > &	_Left,
		unique_lock< _Mutex > &	_Right
	)

    {   // swap _Left and _Right
    _Left.swap(_Right);
    }

template<class _Lock0 , class... _LockN>

int try_lock ( _Lock0 &  , _LockN &  ...  )

inline

template<class _Lock0 , class... _LockN>

int try_lock ( _Lock0 &  _Lk0, _LockN &...  _LkN  )

inline

    {   // try to lock n-1 mutexes
    return (_Try_lock(_Lk0, _LkN...));
    }

Variable Documentation

constexpr adopt_lock_t adopt_lock {}

constexpr defer_lock_t defer_lock {}

constexpr try_to_lock_t try_to_lock {}