_Atomic< _Ty, _Bytes > Struct Template Reference

Inheritance diagram for _Atomic< _Ty, _Bytes >:

Public Member Functions
	_Atomic (_Ty _Val)
	_Atomic () _NOEXCEPT
	_Atomic (const _Atomic &)=delete
_Atomic &	operator= (const _Atomic &)=delete
_Atomic &	operator= (const _Atomic &) 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 >
	_Atomic_impl ()
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

Constructor & Destructor Documentation

template<class _Ty, unsigned _Bytes>

_Atomic< _Ty, _Bytes >::_Atomic ( _Ty  _Val )

inline

        : _My_val(_Val)
        {   // construct from _Val
        }

template<class _Ty, unsigned _Bytes>

_Atomic< _Ty, _Bytes >::_Atomic ( )

inline

        : _My_val()
        {   /* default constructor */
        }

template<class _Ty, unsigned _Bytes>

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

delete

Member Function Documentation

template<class _Ty, unsigned _Bytes>

bool _Atomic< _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< _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< _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< _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< _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< _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< _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< _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< _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< _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< _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< _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< _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< _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< _Ty, _Bytes >::operator _Ty ( ) const volatile

inline

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

template<class _Ty, unsigned _Bytes>

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

inline

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

template<class _Ty, unsigned _Bytes>

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

delete

template<class _Ty, unsigned _Bytes>

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

delete

template<class _Ty, unsigned _Bytes>

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

inline

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

template<class _Ty, unsigned _Bytes>

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

inline

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

template<class _Ty, unsigned _Bytes>

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

inline

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

template<class _Ty, unsigned _Bytes>

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

inline

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

Member Data Documentation

template<class _Ty, unsigned _Bytes>

_Ty _Atomic< _Ty, _Bytes >::_My_val

---

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

• VS2013/inc/atomic