xxatomic File Reference

Classes
struct	_ATOMIC_ITYPE
struct	atomic< _ITYPE >

Macros
#define	_ATOMIC_UINT   _CONCAT(_CONCAT(_Uint, _ISIZE), _t)
#define	_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(name)   _CONCAT(name, _ISIZE)
#define	_ATOMIC_LOCKING_PRIMITIVE_NAME(name)   _CONCAT(_CONCAT(name, _ISIZE), _locking)
#define	_ATOMIC_IS_LOCK_FREE   _CONCAT(_Atomic_is_lock_free_, _ISIZE)
#define	_ATOMIC_STORE(_Atom, _Value, _Order)
#define	_ATOMIC_LOAD(_Atom, _Order)
#define	_ATOMIC_EXCHANGE(_Atom, _Value, _Order)
#define	_ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Expected, _Desired, _Order1, _Order2)
#define	_ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Expected, _Desired, _Order1, _Order2)
#define	_ATOMIC_FETCH_ADD(_Atom, _Value, _Order)
#define	_ATOMIC_FETCH_SUB(_Atom, _Value, _Order)
#define	_ATOMIC_FETCH_AND(_Atom, _Value, _Order)
#define	_ATOMIC_FETCH_OR(_Atom, _Value, _Order)
#define	_ATOMIC_FETCH_XOR(_Atom, _Value, _Order)

Typedefs
typedef struct _ATOMIC_ITYPE	_ATOMIC_ITYPE

Functions
bool	atomic_is_lock_free (const volatile _ATOMIC_ITYPE *) _NOEXCEPT
bool	atomic_is_lock_free (const _ATOMIC_ITYPE *) _NOEXCEPT
bool	atomic_is_lock_free (const volatile atomic< _ITYPE > *) _NOEXCEPT
bool	atomic_is_lock_free (const atomic< _ITYPE > *) _NOEXCEPT
void	atomic_init (volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value) _NOEXCEPT
void	atomic_init (_ATOMIC_ITYPE *_Atom, _ITYPE _Value) _NOEXCEPT
void	atomic_init (volatile atomic< _ITYPE > *_Atom, _ITYPE _Value) _NOEXCEPT
void	atomic_init (atomic< _ITYPE > *_Atom, _ITYPE _Value) _NOEXCEPT
void	atomic_store_explicit (volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
void	atomic_store_explicit (_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
void	atomic_store (volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value) _NOEXCEPT
void	atomic_store (_ATOMIC_ITYPE *_Atom, _ITYPE _Value) _NOEXCEPT
_ITYPE	atomic_load_explicit (const volatile _ATOMIC_ITYPE *_Atom, memory_order _Order) _NOEXCEPT
_ITYPE	atomic_load_explicit (const _ATOMIC_ITYPE *_Atom, memory_order _Order) _NOEXCEPT
_ITYPE	atomic_load (const volatile _ATOMIC_ITYPE *_Atom) _NOEXCEPT
_ITYPE	atomic_load (const _ATOMIC_ITYPE *_Atom) _NOEXCEPT
_ITYPE	atomic_exchange_explicit (volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
_ITYPE	atomic_exchange_explicit (_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
_ITYPE	atomic_exchange (volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value) _NOEXCEPT
_ITYPE	atomic_exchange (_ATOMIC_ITYPE *_Atom, _ITYPE _Value) _NOEXCEPT
bool	atomic_compare_exchange_weak_explicit (volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
bool	atomic_compare_exchange_weak_explicit (_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
bool	atomic_compare_exchange_weak (volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
bool	atomic_compare_exchange_weak (_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
bool	atomic_compare_exchange_strong_explicit (volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
bool	atomic_compare_exchange_strong_explicit (_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
bool	atomic_compare_exchange_strong (volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
bool	atomic_compare_exchange_strong (_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
template<>
void	atomic_store (volatile atomic< _ITYPE > *_Atom, _ITYPE _Value) _NOEXCEPT
template<>
void	atomic_store (atomic< _ITYPE > *_Atom, _ITYPE _Value) _NOEXCEPT
template<>
void	atomic_store_explicit (volatile atomic< _ITYPE > *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
template<>
void	atomic_store_explicit (atomic< _ITYPE > *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
template<>
_ITYPE	atomic_load (const volatile atomic< _ITYPE > *_Atom) _NOEXCEPT
template<>
_ITYPE	atomic_load (const atomic< _ITYPE > *_Atom) _NOEXCEPT
template<>
_ITYPE	atomic_load_explicit (const volatile atomic< _ITYPE > *_Atom, memory_order _Order) _NOEXCEPT
template<>
_ITYPE	atomic_load_explicit (const atomic< _ITYPE > *_Atom, memory_order _Order) _NOEXCEPT
template<>
_ITYPE	atomic_exchange (volatile atomic< _ITYPE > *_Atom, _ITYPE _Value) _NOEXCEPT
template<>
_ITYPE	atomic_exchange (atomic< _ITYPE > *_Atom, _ITYPE _Value) _NOEXCEPT
template<>
_ITYPE	atomic_exchange_explicit (volatile atomic< _ITYPE > *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
template<>
_ITYPE	atomic_exchange_explicit (atomic< _ITYPE > *_Atom, _ITYPE _Value, memory_order _Order) _NOEXCEPT
template<>
bool	atomic_compare_exchange_weak (volatile atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
template<>
bool	atomic_compare_exchange_weak (atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
template<>
bool	atomic_compare_exchange_weak_explicit (volatile atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
template<>
bool	atomic_compare_exchange_weak_explicit (atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
template<>
bool	atomic_compare_exchange_strong (volatile atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
template<>
bool	atomic_compare_exchange_strong (atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value) _NOEXCEPT
template<>
bool	atomic_compare_exchange_strong_explicit (volatile atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT
template<>
bool	atomic_compare_exchange_strong_explicit (atomic< _ITYPE > *_Atom, _ITYPE *_Exp, _ITYPE _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT

Macro Definition Documentation

#define _ATOMIC_COMPARE_EXCHANGE_STRONG	(		_Atom,
			_Expected,
			_Desired,
			_Order1,
			_Order2
	)

Value:

_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_compare_exchange_strong_)  \
    ((_ATOMIC_UINT*)&_Atom->_My_val,    \
        (_ATOMIC_UINT*)_Expected, (_ATOMIC_UINT)_Value, \
        _Order1, _Order2)

#define _ATOMIC_COMPARE_EXCHANGE_WEAK	(		_Atom,
			_Expected,
			_Desired,
			_Order1,
			_Order2
	)

Value:

_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_compare_exchange_weak_)    \
    ((_ATOMIC_UINT*)&_Atom->_My_val,    \
        (_ATOMIC_UINT*)_Expected, (_ATOMIC_UINT)_Value, \
        _Order1, _Order2)

#define _ATOMIC_EXCHANGE	(		_Atom,
			_Value,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_exchange_) \
    ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_FETCH_ADD	(		_Atom,
			_Value,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_add_)    \
    ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_FETCH_AND	(		_Atom,
			_Value,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_and_)    \
    ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_FETCH_OR	(		_Atom,
			_Value,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_or_) \
    ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_FETCH_SUB	(		_Atom,
			_Value,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_sub_)    \
    ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_FETCH_XOR	(		_Atom,
			_Value,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_xor_)    \
    ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_IS_LOCK_FREE   _CONCAT(_Atomic_is_lock_free_, _ISIZE)

#define _ATOMIC_LOAD	(		_Atom,
			_Order
	)

Value:

(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_load_) \
    ((_ATOMIC_UINT*)&_Atom->_My_val, _Order)

#define _ATOMIC_LOCK_FREE_PRIMITIVE_NAME

(

name

)

_CONCAT(name, _ISIZE)

#define _ATOMIC_LOCKING_PRIMITIVE_NAME

(

name

)

_CONCAT(_CONCAT(name, _ISIZE), _locking)

#define _ATOMIC_STORE	(		_Atom,
			_Value,
			_Order
	)

Value:

_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_store_)\
        ((_ATOMIC_UINT*)&_Atom->_My_val,    \
        (_ATOMIC_UINT)_Value, _Order)

#define _ATOMIC_UINT   _CONCAT(_CONCAT(_Uint, _ISIZE), _t)

Typedef Documentation

typedef struct _ATOMIC_ITYPE _ATOMIC_ITYPE

Function Documentation

bool atomic_compare_exchange_strong ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    return atomic_compare_exchange_strong_explicit(
        _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst);
    }

bool atomic_compare_exchange_strong ( _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    return atomic_compare_exchange_strong_explicit(
        _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst);
    }

template<>

bool atomic_compare_exchange_strong ( volatile atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {
    return atomic_compare_exchange_strong(
        static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp, _Value);
    }

template<>

bool atomic_compare_exchange_strong ( atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {
    return atomic_compare_exchange_strong(
        static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value);
    }

bool atomic_compare_exchange_strong_explicit ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    assert(_Order2 != memory_order_release);
    assert(_Order2 != memory_order_acq_rel);
    assert(_Order2 <= _Order1);
    return _ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Exp, _Value,
        _Order1, _Order2);
    }

bool atomic_compare_exchange_strong_explicit ( _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    assert(_Order2 != memory_order_release);
    assert(_Order2 != memory_order_acq_rel);
    assert(_Order2 <= _Order1);
    return _ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Exp, _Value,
        _Order1, _Order2);
    }

template<>

bool atomic_compare_exchange_strong_explicit ( volatile atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return atomic_compare_exchange_strong_explicit(
        static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp,
            _Value, _Order1, _Order2);
    }

template<>

bool atomic_compare_exchange_strong_explicit ( atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return atomic_compare_exchange_strong_explicit(
        static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value, _Order1, _Order2);
    }

bool atomic_compare_exchange_weak ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    return atomic_compare_exchange_weak_explicit(
        _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst);
    }

bool atomic_compare_exchange_weak ( _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    return atomic_compare_exchange_weak_explicit(
        _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst);
    }

template<>

bool atomic_compare_exchange_weak ( volatile atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {
    return atomic_compare_exchange_weak(
        static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp, _Value);
    }

template<>

bool atomic_compare_exchange_weak ( atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value  )

inline

    {
    return atomic_compare_exchange_weak(
        static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value);
    }

bool atomic_compare_exchange_weak_explicit ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    assert(_Order2 != memory_order_release);
    assert(_Order2 != memory_order_acq_rel);
    assert(_Order2 <= _Order1);
    return _ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Exp, _Value,
        _Order1, _Order2);
    }

bool atomic_compare_exchange_weak_explicit ( _ATOMIC_ITYPE *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {   // compare and exchange value stored in *_Atom with *_Exp, _Value
    assert(_Order2 != memory_order_release);
    assert(_Order2 != memory_order_acq_rel);
    assert(_Order2 <= _Order1);
    return _ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Exp, _Value,
        _Order1, _Order2);
    }

template<>

bool atomic_compare_exchange_weak_explicit ( volatile atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return atomic_compare_exchange_weak_explicit(
        static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp,
            _Value, _Order1, _Order2);
    }

template<>

bool atomic_compare_exchange_weak_explicit ( atomic< _ITYPE > *  _Atom, _ITYPE *  _Exp, _ITYPE  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return atomic_compare_exchange_weak_explicit(
        static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value, _Order1, _Order2);
    }

_ITYPE atomic_exchange ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value  )

inline

    {   // exchange value stored in *_Atom with _Value
    return atomic_exchange_explicit(_Atom, _Value, memory_order_seq_cst);
    }

_ITYPE atomic_exchange ( _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value  )

inline

    {   // exchange value stored in *_Atom with _Value
    return atomic_exchange_explicit(_Atom, _Value, memory_order_seq_cst);
    }

template<>

_ITYPE atomic_exchange ( volatile atomic< _ITYPE > *  _Atom, _ITYPE  _Value  )

inline

    {
    return atomic_exchange(
        static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value);
    }

template<>

_ITYPE atomic_exchange ( atomic< _ITYPE > *  _Atom, _ITYPE  _Value  )

inline

    {
    return atomic_exchange(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value);
    }

_ITYPE atomic_exchange_explicit ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {   // exchange value stored in *_Atom with _Value
    return _ATOMIC_EXCHANGE(_Atom, _Value, _Order);
    }

_ITYPE atomic_exchange_explicit ( _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {   // exchange value stored in *_Atom with _Value
    return _ATOMIC_EXCHANGE(_Atom, _Value, _Order);
    }

template<>

_ITYPE atomic_exchange_explicit ( volatile atomic< _ITYPE > *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {
    return atomic_exchange_explicit(
        static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order);
    }

template<>

_ITYPE atomic_exchange_explicit ( atomic< _ITYPE > *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {
    return atomic_exchange_explicit(static_cast<_ATOMIC_ITYPE *>(_Atom),
        _Value, _Order);
    }

void atomic_init ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value  )

inline

    {   // non-atomically initialize *_Atom to _Value
    _Atom->_My_val = (_ATOMIC_UINT)_Value;

    }

void atomic_init ( _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value  )

inline

    {   // non-atomically initialize *_Atom to _Value
    _Atom->_My_val = (_ATOMIC_UINT)_Value;

    }

void atomic_init ( volatile atomic< _ITYPE > *  _Atom, _ITYPE  _Value  )

inline

    {   // non-atomically initialize *_Atom to _Value
    _Atom->_My_val = (_ATOMIC_UINT)_Value;

    }

void atomic_init ( atomic< _ITYPE > *  _Atom, _ITYPE  _Value  )

inline

    {   // non-atomically initialize *_Atom to _Value
    _Atom->_My_val = (_ATOMIC_UINT)_Value;

    }

bool atomic_is_lock_free ( const volatile _ATOMIC_ITYPE *  )

inline

    {   // return true if operations on _ATOMIC_ITYPE are lock-free
    return _ATOMIC_IS_LOCK_FREE();
    }

bool atomic_is_lock_free ( const _ATOMIC_ITYPE *  )

inline

    {   // return true if operations on _ATOMIC_ITYPE are lock-free
    return _ATOMIC_IS_LOCK_FREE();
    }

bool atomic_is_lock_free ( const volatile atomic< _ITYPE > *  _Atom )

inline

    {   // return true if operations on _ATOMIC_ITYPE are lock-free
    return _ATOMIC_IS_LOCK_FREE();
    }

bool atomic_is_lock_free ( const atomic< _ITYPE > *  _Atom )

inline

    {   // return true if operations on _ATOMIC_ITYPE are lock-free
    return _ATOMIC_IS_LOCK_FREE();
    }

_ITYPE atomic_load ( const volatile _ATOMIC_ITYPE *  _Atom )

inline

    {   // return value stored in *_Atom
    return atomic_load_explicit(_Atom, memory_order_seq_cst);
    }

_ITYPE atomic_load ( const _ATOMIC_ITYPE *  _Atom )

inline

    {   // return value stored in *_Atom
    return atomic_load_explicit(_Atom, memory_order_seq_cst);
    }

template<>

_ITYPE atomic_load ( const volatile atomic< _ITYPE > *  _Atom )

inline

    {
    return atomic_load(static_cast<const volatile _ATOMIC_ITYPE *>(_Atom));
    }

template<>

_ITYPE atomic_load ( const atomic< _ITYPE > *  _Atom )

inline

    {
    return atomic_load(static_cast<const volatile _ATOMIC_ITYPE *>(_Atom));
    }

_ITYPE atomic_load_explicit ( const volatile _ATOMIC_ITYPE *  _Atom, memory_order  _Order  )

inline

    {   // return value held in *_Atom
    return _ATOMIC_LOAD(_Atom, _Order);
    }

_ITYPE atomic_load_explicit ( const _ATOMIC_ITYPE *  _Atom, memory_order  _Order  )

inline

    {   // return value held in *_Atom
    return _ATOMIC_LOAD(_Atom, _Order);
    }

template<>

_ITYPE atomic_load_explicit ( const volatile atomic< _ITYPE > *  _Atom, memory_order  _Order  )

inline

    {
    return atomic_load_explicit(
        static_cast<const volatile _ATOMIC_ITYPE *>(_Atom), _Order);
    }

template<>

_ITYPE atomic_load_explicit ( const atomic< _ITYPE > *  _Atom, memory_order  _Order  )

inline

    {
    return atomic_load_explicit(
        static_cast<const _ATOMIC_ITYPE *>(_Atom), _Order);
    }

void atomic_store ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value  )

inline

    {   // store _Value into *_Atom
    atomic_store_explicit(_Atom, _Value, memory_order_seq_cst);
    }

void atomic_store ( _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value  )

inline

    {   // store _Value into *_Atom
    atomic_store_explicit(_Atom, _Value, memory_order_seq_cst);
    }

template<>

void atomic_store ( volatile atomic< _ITYPE > *  _Atom, _ITYPE  _Value  )

inline

    {
    atomic_store(static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value);
    }

template<>

void atomic_store ( atomic< _ITYPE > *  _Atom, _ITYPE  _Value  )

inline

    {
    atomic_store(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value);
    }

void atomic_store_explicit ( volatile _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {   // store _Value into *_Atom
    assert(_ISIZE == sizeof (_ITYPE));
    _ATOMIC_STORE(_Atom, _Value, _Order);
    }

void atomic_store_explicit ( _ATOMIC_ITYPE *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {   // store _Value into *_Atom
    assert(_ISIZE == sizeof (_ITYPE));
    _ATOMIC_STORE(_Atom, _Value, _Order);
    }

template<>

void atomic_store_explicit ( volatile atomic< _ITYPE > *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {
    atomic_store_explicit(static_cast<volatile _ATOMIC_ITYPE *>(_Atom),
        _Value, _Order);
    }

template<>

void atomic_store_explicit ( atomic< _ITYPE > *  _Atom, _ITYPE  _Value, memory_order  _Order  )

inline

    {
    atomic_store_explicit(static_cast<_ATOMIC_ITYPE *>(_Atom),
        _Value, _Order);
    }