STLdoc: _Atomic_base< _Ty, _Bytes > Struct Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for _Atomic_base< _Ty, _Bytes >:

Public Types
typedef _Atomic_impl< _Bytes >	_Mybase

typedef _Mybase::_My_int	_My_int

Public Types inherited from _Atomic_impl< _Bytes >
typedef _Uint1_t	_My_int

Public Member Functions
constexpr	_Atomic_base (_Ty _Val) _NOEXCEPT

	_Atomic_base () _NOEXCEPT=default

	_Atomic_base (const _Atomic_base &)=delete

_Atomic_base &	operator= (const _Atomic_base &)=delete

_Atomic_base &	operator= (const _Atomic_base &) volatile=delete

_Ty	operator= (_Ty _Right) volatile _NOEXCEPT

_Ty	operator= (_Ty _Right) _NOEXCEPT

bool	is_lock_free () const volatile _NOEXCEPT

bool	is_lock_free () const _NOEXCEPT

void	store (_Ty _Value, memory_order _Order=memory_order_seq_cst) volatile _NOEXCEPT

void	store (_Ty _Value, memory_order _Order=memory_order_seq_cst) _NOEXCEPT

_Ty	load (memory_order _Order=memory_order_seq_cst) const volatile _NOEXCEPT

_Ty	load (memory_order _Order=memory_order_seq_cst) const _NOEXCEPT

	operator _Ty () const volatile _NOEXCEPT

	operator _Ty () const _NOEXCEPT

_Ty	exchange (_Ty _Value, memory_order _Order=memory_order_seq_cst) volatile _NOEXCEPT

_Ty	exchange (_Ty _Value, memory_order _Order=memory_order_seq_cst) _NOEXCEPT

bool	compare_exchange_weak (_Ty &_Exp, _Ty _Value, memory_order _Order1, memory_order _Order2) volatile _NOEXCEPT

bool	compare_exchange_weak (_Ty &_Exp, _Ty _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT

bool	compare_exchange_weak (_Ty &_Exp, _Ty _Value, memory_order _Order=memory_order_seq_cst) volatile _NOEXCEPT

bool	compare_exchange_weak (_Ty &_Exp, _Ty _Value, memory_order _Order=memory_order_seq_cst) _NOEXCEPT

bool	compare_exchange_strong (_Ty &_Exp, _Ty _Value, memory_order _Order1, memory_order _Order2) volatile _NOEXCEPT

bool	compare_exchange_strong (_Ty &_Exp, _Ty _Value, memory_order _Order1, memory_order _Order2) _NOEXCEPT

bool	compare_exchange_strong (_Ty &_Exp, _Ty _Value, memory_order _Order=memory_order_seq_cst) volatile _NOEXCEPT

bool	compare_exchange_strong (_Ty &_Exp, _Ty _Value, memory_order _Order=memory_order_seq_cst) _NOEXCEPT

Public Member Functions inherited from _Atomic_impl< _Bytes >
constexpr	_Atomic_impl () _NOEXCEPT

bool	_Is_lock_free () const volatile

void	_Store (void _Tgt, const void _Src, memory_order _Order) volatile

void	_Load (void _Tgt, const void _Src, memory_order _Order) const volatile

void	_Exchange (void _Left, void _Right, memory_order _Order) volatile

bool	_Compare_exchange_weak (void _Tgt, void _Exp, const void *_Value, memory_order _Order1, memory_order _Order2) volatile

bool	_Compare_exchange_strong (void _Tgt, void _Exp, const void *_Value, memory_order _Order1, memory_order _Order2) volatile

Public Attributes
_Ty	_My_val

Member Typedef Documentation

template<class _Ty, unsigned _Bytes>

typedef _Mybase::_My_int _Atomic_base< _Ty, _Bytes >::_My_int

template<class _Ty, unsigned _Bytes>

typedef _Atomic_impl<_Bytes> _Atomic_base< _Ty, _Bytes >::_Mybase

Constructor & Destructor Documentation

template<class _Ty, unsigned _Bytes>

constexpr _Atomic_base< _Ty, _Bytes >::_Atomic_base ( _Ty _Val )

inline

         : _My_val(_Val)
         {   // construct from _Val, initialization is not an atomic operation
         }

template<class _Ty, unsigned _Bytes>

_Atomic_base< _Ty, _Bytes >::_Atomic_base ( )

default

template<class _Ty, unsigned _Bytes>

_Atomic_base< _Ty, _Bytes >::_Atomic_base ( const _Atomic_base< _Ty, _Bytes > & )

delete

Member Function Documentation

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_strong	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)		volatile

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (this->_Compare_exchange_strong(
             (void *)&_My_val, (void *)&_Exp, (const void *)&_Value,
                 _Order1, _Order2));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_strong	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (this->_Compare_exchange_strong(
             (void *)&_My_val, (void *)&_Exp, (void *)&_Value,
                 _Order1, _Order2));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_strong	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)		volatile

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (compare_exchange_strong(
             _Exp, _Value, _Order, _Get_memory_order(_Order)));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_strong	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (compare_exchange_strong(
             _Exp, _Value, _Order, _Get_memory_order(_Order)));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_weak	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)		volatile

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (this->_Compare_exchange_weak(
             (void *)&_My_val, (void *)&_Exp, (const void *)&_Value,
                 _Order1, _Order2));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_weak	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (this->_Compare_exchange_weak(
             (void *)&_My_val, (void *)&_Exp, (const void *)&_Value,
                 _Order1, _Order2));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_weak	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)		volatile

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (compare_exchange_weak(
             _Exp, _Value, _Order, _Get_memory_order(_Order)));
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::compare_exchange_weak	(	_Ty &	_Exp,
		_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)

inline

         {   // compare and exchange value stored in *this with *_Exp, _Value
         return (compare_exchange_weak(
             _Exp, _Value, _Order, _Get_memory_order(_Order)));
         }

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::exchange	(	_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)		volatile

inline

         {   // exchange value stored in *this with _Value
         this->_Exchange((void *)&_My_val, (void *)&_Value, _Order);
         return (_Value);
         }

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::exchange	(	_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)

inline

         {   // exchange value stored in *this with _Value
         this->_Exchange((void *)&_My_val, (void *)&_Value, _Order);
         return (_Value);
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::is_lock_free ( ) const volatile

inline

         {   // return true if operations are lock-free
         return (this->_Is_lock_free());
         }

template<class _Ty, unsigned _Bytes>

bool _Atomic_base< _Ty, _Bytes >::is_lock_free ( ) const

inline

         {   // return true if operations are lock-free
         return (this->_Is_lock_free());
         }

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::load ( memory_order _Order = memory_order_seq_cst ) const volatile

inline

         {   // return value stored in *this
         _Ty _Result;
         this->_Load((void *)&_Result, (const void *)&_My_val, _Order);
         return (_Result);
         }

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::load ( memory_order _Order = memory_order_seq_cst ) const

inline

         {   // return value stored in *this
         _Ty _Result;
         this->_Load((void *)&_Result, (const void *)&_My_val, _Order);
         return (_Result);
         }

template<class _Ty, unsigned _Bytes>

_Atomic_base< _Ty, _Bytes >::operator _Ty ( ) const volatile

inline

         {   // return value stored in *this
         return (load());
         }

template<class _Ty, unsigned _Bytes>

_Atomic_base< _Ty, _Bytes >::operator _Ty ( ) const

inline

         {   // return value stored in *this
         return (load());
         }

template<class _Ty, unsigned _Bytes>

_Atomic_base& _Atomic_base< _Ty, _Bytes >::operator= ( const _Atomic_base< _Ty, _Bytes > & )

delete

template<class _Ty, unsigned _Bytes>

_Atomic_base& _Atomic_base< _Ty, _Bytes >::operator= ( const _Atomic_base< _Ty, _Bytes > & ) volatile

delete

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::operator= ( _Ty _Right ) volatile

inline

         {   // assign from _Right
         this->_Store((void *)&_My_val, &_Right, memory_order_seq_cst);
         return (_Right);
         }

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::operator= ( _Ty _Right )

inline

         {   // assign from _Right
         this->_Store((void *)&_My_val, &_Right, memory_order_seq_cst);
         return (_Right);
         }

template<class _Ty, unsigned _Bytes>

void _Atomic_base< _Ty, _Bytes >::store	(	_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)		volatile

inline

         {   // store _Value into *this
         this->_Store((void *)&_My_val, &_Value, _Order);
         }

template<class _Ty, unsigned _Bytes>

void _Atomic_base< _Ty, _Bytes >::store	(	_Ty	_Value,
		memory_order	_Order = `memory_order_seq_cst`
	)

inline

         {   // store _Value into *this
         this->_Store((void *)&_My_val, &_Value, _Order);
         }

Member Data Documentation

template<class _Ty, unsigned _Bytes>

_Ty _Atomic_base< _Ty, _Bytes >::_My_val

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

VS2015/inc/atomic