_Atomic_base< _Ty, _Bytes > Struct Template Reference

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 *)_STD addressof(_My_val), (void *)_STD addressof(_Exp), (const void *)_STD addressof(_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 *)_STD addressof(_My_val), (void *)_STD addressof(_Exp), (void *)_STD addressof(_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 *)_STD addressof(_My_val), (void *)_STD addressof(_Exp), (const void *)_STD addressof(_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 *)_STD addressof(_My_val), (void *)_STD addressof(_Exp), (const void *)_STD addressof(_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 *)_STD addressof(_My_val), (void *)_STD addressof(_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 *)_STD addressof(_My_val), (void *)_STD addressof(_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 *)_STD addressof(_Result), (const void *)_STD addressof(_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 *)_STD addressof(_Result), (const void *)_STD addressof(_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 *)_STD addressof(_My_val), _STD addressof(_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 *)_STD addressof(_My_val), _STD addressof(_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 *)_STD addressof(_My_val), _STD addressof(_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 *)_STD addressof(_My_val), _STD addressof(_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:

• VS2017/inc/atomic