Atomic< T > Class Template Reference

#include <atomic.h>

Inheritance diagram for Atomic< T >:

Public Member Functions
	Atomic ()
	Atomic (const Atomic &other)
	Atomic (T value)
T	compareExchange (T expected, T desired, MemoryOrder memoryOrder)
bool	compareExchangeStrong (T &expected, T desired, MemoryOrder memoryOrder)
bool	compareExchangeWeak (T &expected, T desired, MemoryOrder success, MemoryOrder failure)
T	exchange (T desired, MemoryOrder memoryOrder)
T	fetchAdd (T operand, MemoryOrder memoryOrder)
T	fetchAnd (T operand, MemoryOrder memoryOrder)
T	fetchOr (T operand, MemoryOrder memoryOrder)
T	fetchSub (T operand, MemoryOrder memoryOrder)
T	load (MemoryOrder memoryOrder) const
T	loadNonatomic () const
void	store (T value, MemoryOrder memoryOrder)
void	storeNonatomic (T value)

Private Member Functions
T	operator= (T value)

Detailed Description

template<typename T>
class Atomic< T >

Definition at line 66 of file atomic.h.

Constructor & Destructor Documentation

Atomic() [1/3]

template<typename T >

Atomic< T >::Atomic ( )

inline

Definition at line 72 of file atomic.h.

    {
    }

Atomic() [2/3]

template<typename T >

Atomic< T >::Atomic ( T value )

inline

Definition at line 76 of file atomic.h.

                    : std::atomic<T>(value)
    {
    }

Atomic() [3/3]

template<typename T >

Atomic< T >::Atomic ( const Atomic< T > & other )

inline

Definition at line 80 of file atomic.h.

                                : std::atomic<T>(other.loadNonatomic())
    {
    }

Member Function Documentation

compareExchange()

template<typename T >

T Atomic< T >::compareExchange ( T expected, T desired, MemoryOrder memoryOrder )

inline

Definition at line 104 of file atomic.h.

    {
        std::atomic<T>::compare_exchange_strong(expected, desired, (std::memory_order) memoryOrder);
        return expected; // modified by reference by compare_exchange_strong
    }

compareExchangeStrong()

template<typename T >

bool Atomic< T >::compareExchangeStrong ( T & expected, T desired, MemoryOrder memoryOrder )

inline

Definition at line 110 of file atomic.h.

    {
        return std::atomic<T>::compare_exchange_strong(expected, desired, (std::memory_order) memoryOrder);
    }

compareExchangeWeak()

template<typename T >

bool Atomic< T >::compareExchangeWeak ( T & expected, T desired, MemoryOrder success, MemoryOrder failure )

inline

Definition at line 115 of file atomic.h.

    {
        return std::atomic<T>::compare_exchange_weak(expected, desired, (std::memory_order) success, (std::memory_order) failure);
    }

exchange()

template<typename T >

T Atomic< T >::exchange ( T desired, MemoryOrder memoryOrder )

inline

Definition at line 120 of file atomic.h.

    {
        return std::atomic<T>::exchange(desired, (std::memory_order) memoryOrder);
    }

fetchAdd()

template<typename T >

T Atomic< T >::fetchAdd ( T operand, MemoryOrder memoryOrder )

inline

Definition at line 125 of file atomic.h.

    {
        return std::atomic<T>::fetch_add(operand, (std::memory_order) memoryOrder);
    }

fetchAnd()

template<typename T >

T Atomic< T >::fetchAnd ( T operand, MemoryOrder memoryOrder )

inline

Definition at line 135 of file atomic.h.

    {
        return std::atomic<T>::fetch_and(operand, (std::memory_order) memoryOrder);
    }

fetchOr()

template<typename T >

T Atomic< T >::fetchOr ( T operand, MemoryOrder memoryOrder )

inline

Definition at line 140 of file atomic.h.

    {
        return std::atomic<T>::fetch_or(operand, (std::memory_order) memoryOrder);
    }

fetchSub()

template<typename T >

T Atomic< T >::fetchSub ( T operand, MemoryOrder memoryOrder )

inline

Definition at line 130 of file atomic.h.

    {
        return std::atomic<T>::fetch_sub(operand, (std::memory_order) memoryOrder);
    }

load()

template<typename T >

T Atomic< T >::load ( MemoryOrder memoryOrder ) const

inline

Definition at line 89 of file atomic.h.

    {
        return std::atomic<T>::load((std::memory_order) memoryOrder);
    }

loadNonatomic()

template<typename T >

T Atomic< T >::loadNonatomic ( ) const

inline

Definition at line 84 of file atomic.h.

    {
        return std::atomic<T>::load(std::memory_order_relaxed);
    }

operator=()

template<typename T >

T Atomic< T >::operator= ( T value )

private

store()

template<typename T >

void Atomic< T >::store ( T value, MemoryOrder memoryOrder )

inline

Definition at line 99 of file atomic.h.

    {
        return std::atomic<T>::store(value, (std::memory_order) memoryOrder);
    }

References value().

storeNonatomic()

template<typename T >

void Atomic< T >::storeNonatomic ( T value )

inline

Definition at line 94 of file atomic.h.

    {
        return std::atomic<T>::store(value, std::memory_order_relaxed);
    }

References value().

---

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

• libs/image/3rdparty/lock_free_map/atomic.h