di::AtomicRef< T > Class Template Reference

#include <di/sync/atomic_ref.h>

Public Member Functions
	AtomicRef (AtomicRef const &)=default
constexpr	AtomicRef (T &value)
auto	operator= (AtomicRef const &) -> AtomicRef &=delete
constexpr void	store (T value, MemoryOrder order=MemoryOrder::SequentialConsistency)
constexpr auto	load (MemoryOrder order=MemoryOrder::SequentialConsistency) const -> T
constexpr auto	exchange (T value, MemoryOrder order=MemoryOrder::SequentialConsistency) -> T
constexpr auto	compare_exchange_weak (T &expected, T desired, MemoryOrder success, MemoryOrder failure) -> bool
constexpr auto	compare_exchange_weak (T &expected, T desired, MemoryOrder order=MemoryOrder::SequentialConsistency) -> bool
constexpr auto	compare_exchange_strong (T &expected, T desired, MemoryOrder success, MemoryOrder failure) -> bool
constexpr auto	compare_exchange_strong (T &expected, T desired, MemoryOrder order=MemoryOrder::SequentialConsistency) -> bool
constexpr auto	fetch_add (DeltaType delta, MemoryOrder order=MemoryOrder::SequentialConsistency) -> T requires(concepts::Integral< T >||concepts::Pointer< T >)
constexpr auto	fetch_sub (DeltaType delta, MemoryOrder order=MemoryOrder::SequentialConsistency) -> T requires(concepts::Integral< T >||concepts::Pointer< T >)
constexpr auto	fetch_and (T value, MemoryOrder order=MemoryOrder::SequentialConsistency) -> T requires(concepts::Integral< T >)
constexpr auto	fetch_or (T value, MemoryOrder order=MemoryOrder::SequentialConsistency) -> T requires(concepts::Integral< T >)
constexpr auto	fetch_xor (T value, MemoryOrder order=MemoryOrder::SequentialConsistency) -> T requires(concepts::Integral< T >)

Constructor & Destructor Documentation

AtomicRef() [1/2]

template<typename T>

di::sync::AtomicRef< T >::AtomicRef ( AtomicRef< T > const & )

default

AtomicRef() [2/2]

template<typename T>

di::sync::AtomicRef< T >::AtomicRef ( T & value )

inlineexplicitconstexpr

Member Function Documentation

compare_exchange_strong() [1/2]

template<typename T>

auto di::sync::AtomicRef< T >::compare_exchange_strong ( T & expected, T desired, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> bool

inlineconstexpr

compare_exchange_strong() [2/2]

template<typename T>

auto di::sync::AtomicRef< T >::compare_exchange_strong ( T & expected, T desired, MemoryOrder success, MemoryOrder failure ) -> bool

inlineconstexpr

compare_exchange_weak() [1/2]

template<typename T>

auto di::sync::AtomicRef< T >::compare_exchange_weak ( T & expected, T desired, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> bool

inlineconstexpr

compare_exchange_weak() [2/2]

template<typename T>

auto di::sync::AtomicRef< T >::compare_exchange_weak ( T & expected, T desired, MemoryOrder success, MemoryOrder failure ) -> bool

inlineconstexpr

exchange()

template<typename T>

auto di::sync::AtomicRef< T >::exchange ( T value, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> T

inlineconstexpr

fetch_add()

template<typename T>

auto di::sync::AtomicRef< T >::fetch_add ( DeltaType delta, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> T requires(concepts::Integral<T> || concepts::Pointer<T>)

inlineconstexpr

fetch_and()

template<typename T>

auto di::sync::AtomicRef< T >::fetch_and ( T value, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> T requires(concepts::Integral<T>)

inlineconstexpr

fetch_or()

template<typename T>

auto di::sync::AtomicRef< T >::fetch_or ( T value, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> T requires(concepts::Integral<T>)

inlineconstexpr

fetch_sub()

template<typename T>

auto di::sync::AtomicRef< T >::fetch_sub ( DeltaType delta, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> T requires(concepts::Integral<T> || concepts::Pointer<T>)

inlineconstexpr

fetch_xor()

template<typename T>

auto di::sync::AtomicRef< T >::fetch_xor ( T value, MemoryOrder order = MemoryOrder::SequentialConsistency ) -> T requires(concepts::Integral<T>)

inlineconstexpr

load()

template<typename T>

auto di::sync::AtomicRef< T >::load ( MemoryOrder order = MemoryOrder::SequentialConsistency ) const -> T

inlineconstexpr

operator=()

template<typename T>

auto di::sync::AtomicRef< T >::operator= ( AtomicRef< T > const & ) -> AtomicRef &=delete

delete

store()

template<typename T>

void di::sync::AtomicRef< T >::store ( T value, MemoryOrder order = MemoryOrder::SequentialConsistency )

inlineconstexpr

---

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

• libs/di/include/di/sync/atomic_ref.h