di::Atomic< T > Class Template Reference

#include <di/sync/atomic.h>

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

Constructor & Destructor Documentation

Atomic() [1/3]

template<typename T>

di::sync::Atomic< T >::Atomic ( )

default

Atomic() [2/3]

template<typename T>

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

delete

Atomic() [3/3]

template<typename T>

di::sync::Atomic< T >::Atomic ( T value )

inlineexplicitconstexpr

Member Function Documentation

compare_exchange_strong() [1/4]

template<typename T>

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

inlineconstexpr

compare_exchange_strong() [2/4]

template<typename T>

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

inlineconstexpr

compare_exchange_strong() [3/4]

template<typename T>

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

inlineconstexpr

compare_exchange_strong() [4/4]

template<typename T>

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

inlineconstexpr

compare_exchange_weak() [1/4]

template<typename T>

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

inlineconstexpr

compare_exchange_weak() [2/4]

template<typename T>

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

inlineconstexpr

compare_exchange_weak() [3/4]

template<typename T>

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

inlineconstexpr

compare_exchange_weak() [4/4]

template<typename T>

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

inlineconstexpr

exchange() [1/2]

template<typename T>

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

inlineconstexpr

exchange() [2/2]

template<typename T>

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

inlineconstexpr

fetch_add() [1/2]

template<typename T>

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

inlineconstexpr

fetch_add() [2/2]

template<typename T>

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

inlineconstexpr

fetch_and() [1/2]

template<typename T>

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

inlineconstexpr

fetch_and() [2/2]

template<typename T>

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

inlineconstexpr

fetch_or() [1/2]

template<typename T>

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

inlineconstexpr

fetch_or() [2/2]

template<typename T>

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

inlineconstexpr

fetch_sub() [1/2]

template<typename T>

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

inlineconstexpr

fetch_sub() [2/2]

template<typename T>

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

inlineconstexpr

fetch_xor() [1/2]

template<typename T>

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

inlineconstexpr

fetch_xor() [2/2]

template<typename T>

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

inlineconstexpr

load() [1/2]

template<typename T>

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

inlineconstexpr

load() [2/2]

template<typename T>

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

inlineconstexpr

operator=() [1/2]

template<typename T>

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

delete

operator=() [2/2]

template<typename T>

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

delete

store() [1/2]

template<typename T>

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

inlineconstexpr

store() [2/2]

template<typename T>

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

inlineconstexpr

---

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

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