dart::RelaxedAtomic< T > Class Template Reference

#include <atomic.h>

Public Member Functions
constexpr	RelaxedAtomic ()
constexpr	RelaxedAtomic (T arg)
	RelaxedAtomic (const RelaxedAtomic &arg)
T	load (std::memory_order order=std::memory_order_relaxed) const
T	load (std::memory_order order=std::memory_order_relaxed) const volatile
void	store (T arg, std::memory_order order=std::memory_order_relaxed)
void	store (T arg, std::memory_order order=std::memory_order_relaxed) volatile
T	fetch_add (T arg, std::memory_order order=std::memory_order_relaxed)
T	fetch_sub (T arg, std::memory_order order=std::memory_order_relaxed)
T	fetch_or (T arg, std::memory_order order=std::memory_order_relaxed)
T	fetch_and (T arg, std::memory_order order=std::memory_order_relaxed)
T	exchange (T arg, std::memory_order order=std::memory_order_relaxed)
bool	compare_exchange_weak (T &expected, T desired, std::memory_order order=std::memory_order_relaxed)
bool	compare_exchange_weak (T &expected, T desired, std::memory_order order=std::memory_order_relaxed) volatile
bool	compare_exchange_strong (T &expected, T desired, std::memory_order order=std::memory_order_relaxed)
	operator T () const
T	operator= (T arg)
T	operator= (const RelaxedAtomic &arg)
T	operator+= (T arg)
T	operator-= (T arg)
T &	operator++ ()
T &	operator-- ()
T	operator++ (int)
T	operator-- (int)

Detailed Description

template<typename T>
class dart::RelaxedAtomic< T >

Definition at line 15 of file atomic.h.

Constructor & Destructor Documentation

RelaxedAtomic() [1/3]

template<typename T >

constexpr dart::RelaxedAtomic< T >::RelaxedAtomic ( )

inlineconstexpr

Definition at line 17 of file atomic.h.

: value_() {}

RelaxedAtomic() [2/3]

template<typename T >

constexpr dart::RelaxedAtomic< T >::RelaxedAtomic ( T  arg )

inlineconstexpr

Definition at line 18 of file atomic.h.

: value_(arg) {}           // NOLINT

RelaxedAtomic() [3/3]

template<typename T >

dart::RelaxedAtomic< T >::RelaxedAtomic ( const RelaxedAtomic< T > &  arg )

inline

Definition at line 19 of file atomic.h.

: value_(arg) {}  // NOLINT

Member Function Documentation

compare_exchange_strong()

template<typename T >

bool dart::RelaxedAtomic< T >::compare_exchange_strong ( T &  expected, T  desired, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 64 of file atomic.h.

                                                       {
    return value_.compare_exchange_strong(expected, desired, order, order);
  }

compare_exchange_weak() [1/2]

template<typename T >

bool dart::RelaxedAtomic< T >::compare_exchange_weak ( T &  expected, T  desired, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 52 of file atomic.h.

                                                       {
    return value_.compare_exchange_weak(expected, desired, order, order);
  }

compare_exchange_weak() [2/2]

template<typename T >

bool dart::RelaxedAtomic< T >::compare_exchange_weak ( T &  expected, T  desired, std::memory_order  order = std::memory_order_relaxed  ) volatile

inline

Definition at line 58 of file atomic.h.

                                                                {
    return value_.compare_exchange_weak(expected, desired, order, order);
  }

exchange()

template<typename T >

T dart::RelaxedAtomic< T >::exchange ( T  arg, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 48 of file atomic.h.

                                                                     {
    return value_.exchange(arg, order);
  }

fetch_add()

template<typename T >

T dart::RelaxedAtomic< T >::fetch_add ( T  arg, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 35 of file atomic.h.

                                                                      {
    return value_.fetch_add(arg, order);
  }

fetch_and()

template<typename T >

T dart::RelaxedAtomic< T >::fetch_and ( T  arg, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 44 of file atomic.h.

                                                                      {
    return value_.fetch_and(arg, order);
  }

fetch_or()

template<typename T >

T dart::RelaxedAtomic< T >::fetch_or ( T  arg, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 41 of file atomic.h.

                                                                     {
    return value_.fetch_or(arg, order);
  }

fetch_sub()

template<typename T >

T dart::RelaxedAtomic< T >::fetch_sub ( T  arg, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 38 of file atomic.h.

                                                                      {
    return value_.fetch_sub(arg, order);
  }

load() [1/2]

template<typename T >

T dart::RelaxedAtomic< T >::load ( std::memory_order  order = std::memory_order_relaxed ) const

inline

Definition at line 21 of file atomic.h.

                                                                {
    return value_.load(order);
  }

load() [2/2]

template<typename T >

T dart::RelaxedAtomic< T >::load ( std::memory_order  order = std::memory_order_relaxed ) const volatile

inline

Definition at line 24 of file atomic.h.

                                                                         {
    return value_.load(order);
  }

operator T()

template<typename T >

dart::RelaxedAtomic< T >::operator T ( ) const

inline

Definition at line 71 of file atomic.h.

{ return load(); }

operator++() [1/2]

template<typename T >

T & dart::RelaxedAtomic< T >::operator++ ( )

inline

Definition at line 83 of file atomic.h.

{ return fetch_add(1) + 1; }

operator++() [2/2]

template<typename T >

T dart::RelaxedAtomic< T >::operator++ ( int  )

inline

Definition at line 85 of file atomic.h.

{ return fetch_add(1); }

operator+=()

template<typename T >

T dart::RelaxedAtomic< T >::operator+= ( T  arg )

inline

Definition at line 81 of file atomic.h.

{ return fetch_add(arg) + arg; }

operator--() [1/2]

template<typename T >

T & dart::RelaxedAtomic< T >::operator-- ( )

inline

Definition at line 84 of file atomic.h.

{ return fetch_sub(1) - 1; }

operator--() [2/2]

template<typename T >

T dart::RelaxedAtomic< T >::operator-- ( int  )

inline

Definition at line 86 of file atomic.h.

{ return fetch_sub(1); }

operator-=()

template<typename T >

T dart::RelaxedAtomic< T >::operator-= ( T  arg )

inline

Definition at line 82 of file atomic.h.

{ return fetch_sub(arg) - arg; }

operator=() [1/2]

template<typename T >

T dart::RelaxedAtomic< T >::operator= ( const RelaxedAtomic< T > &  arg )

inline

Definition at line 76 of file atomic.h.

                                        {
    T loaded_once = arg;
    store(loaded_once);
    return loaded_once;
  }

operator=() [2/2]

template<typename T >

T dart::RelaxedAtomic< T >::operator= ( T  arg )

inline

Definition at line 72 of file atomic.h.

                     {
    store(arg);
    return arg;
  }

store() [1/2]

template<typename T >

void dart::RelaxedAtomic< T >::store ( T  arg, std::memory_order  order = std::memory_order_relaxed  )

inline

Definition at line 27 of file atomic.h.

                                                                     {
    value_.store(arg, order);
  }

store() [2/2]

template<typename T >

void dart::RelaxedAtomic< T >::store ( T  arg, std::memory_order  order = std::memory_order_relaxed  ) volatile

inline

Definition at line 30 of file atomic.h.

                                                                       {
    value_.store(arg, order);
  }

---

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

• third_party/dart-lang/sdk/runtime/platform/atomic.h