BDE 4.14.0 Production release
Loading...
Searching...
No Matches
Public Types | Static Public Member Functions | List of all members
bsls::AtomicOperations Struct Reference

#include <bsls_atomicoperations.h>

Public Types

typedef AtomicOperations_Imp Imp
 
typedef Atomic_TypeTraits< Imp > AtomicTypes
 

Static Public Member Functions

static int getInt (AtomicTypes::Int const *atomicInt)
 
static int getIntAcquire (AtomicTypes::Int const *atomicInt)
 
static int getIntRelaxed (AtomicTypes::Int const *atomicInt)
 
static void initInt (AtomicTypes::Int *atomicInt, int initialValue=0)
 
static void setInt (AtomicTypes::Int *atomicInt, int value)
 
static void setIntRelaxed (AtomicTypes::Int *atomicInt, int value)
 
static void setIntRelease (AtomicTypes::Int *atomicInt, int value)
 
static int swapInt (AtomicTypes::Int *atomicInt, int swapValue)
 
static int swapIntAcqRel (AtomicTypes::Int *atomicInt, int swapValue)
 
static int testAndSwapInt (AtomicTypes::Int *atomicInt, int compareValue, int swapValue)
 
static int testAndSwapIntAcqRel (AtomicTypes::Int *atomicInt, int compareValue, int swapValue)
 
static void addInt (AtomicTypes::Int *atomicInt, int value)
 
static void addIntAcqRel (AtomicTypes::Int *atomicInt, int value)
 
static void addIntRelaxed (AtomicTypes::Int *atomicInt, int value)
 
static int addIntNv (AtomicTypes::Int *atomicInt, int value)
 
static int addIntNvAcqRel (AtomicTypes::Int *atomicInt, int value)
 
static int addIntNvRelaxed (AtomicTypes::Int *atomicInt, int value)
 
static void decrementInt (AtomicTypes::Int *atomicInt)
 
static void decrementIntAcqRel (AtomicTypes::Int *atomicInt)
 
static int decrementIntNv (AtomicTypes::Int *atomicInt)
 
static int decrementIntNvAcqRel (AtomicTypes::Int *atomicInt)
 
static void incrementInt (AtomicTypes::Int *atomicInt)
 
static void incrementIntAcqRel (AtomicTypes::Int *atomicInt)
 
static int incrementIntNv (AtomicTypes::Int *atomicInt)
 
static int incrementIntNvAcqRel (AtomicTypes::Int *atomicInt)
 
static int subtractIntNv (AtomicTypes::Int *atomicInt, int value)
 
static int subtractIntNvAcqRel (AtomicTypes::Int *atomicInt, int value)
 
static int subtractIntNvRelaxed (AtomicTypes::Int *atomicInt, int value)
 
static Types::Int64 getInt64 (AtomicTypes::Int64 const *atomicInt)
 
static Types::Int64 getInt64Acquire (AtomicTypes::Int64 const *atomicInt)
 
static Types::Int64 getInt64Relaxed (AtomicTypes::Int64 const *atomicInt)
 
static void initInt64 (AtomicTypes::Int64 *atomicInt, Types::Int64 initialValue=0)
 
static void setInt64 (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static void setInt64Relaxed (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static void setInt64Release (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static Types::Int64 swapInt64 (AtomicTypes::Int64 *atomicInt, Types::Int64 swapValue)
 
static Types::Int64 swapInt64AcqRel (AtomicTypes::Int64 *atomicInt, Types::Int64 swapValue)
 
static Types::Int64 testAndSwapInt64 (AtomicTypes::Int64 *atomicInt, Types::Int64 compareValue, Types::Int64 swapValue)
 
static Types::Int64 testAndSwapInt64AcqRel (AtomicTypes::Int64 *atomicInt, Types::Int64 compareValue, Types::Int64 swapValue)
 
static void addInt64 (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static void addInt64AcqRel (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static void addInt64Relaxed (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static Types::Int64 addInt64Nv (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static Types::Int64 addInt64NvAcqRel (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static Types::Int64 addInt64NvRelaxed (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static void decrementInt64 (AtomicTypes::Int64 *atomicInt)
 
static void decrementInt64AcqRel (AtomicTypes::Int64 *atomicInt)
 
static Types::Int64 decrementInt64Nv (AtomicTypes::Int64 *atomicInt)
 
static Types::Int64 decrementInt64NvAcqRel (AtomicTypes::Int64 *atomicInt)
 
static void incrementInt64 (AtomicTypes::Int64 *atomicInt)
 
static void incrementInt64AcqRel (AtomicTypes::Int64 *atomicInt)
 
static Types::Int64 incrementInt64Nv (AtomicTypes::Int64 *atomicInt)
 
static Types::Int64 incrementInt64NvAcqRel (AtomicTypes::Int64 *atomicInt)
 
static Types::Int64 subtractInt64Nv (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static Types::Int64 subtractInt64NvAcqRel (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static Types::Int64 subtractInt64NvRelaxed (AtomicTypes::Int64 *atomicInt, Types::Int64 value)
 
static unsigned int getUint (AtomicTypes::Uint const *atomicUint)
 
static unsigned int getUintAcquire (AtomicTypes::Uint const *atomicUint)
 
static unsigned int getUintRelaxed (AtomicTypes::Uint const *atomicUint)
 
static void initUint (AtomicTypes::Uint *atomicUint, unsigned int initialValue=0)
 
static void setUint (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static void setUintRelaxed (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static void setUintRelease (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static unsigned int swapUint (AtomicTypes::Uint *atomicUint, unsigned int swapValue)
 
static unsigned int swapUintAcqRel (AtomicTypes::Uint *atomicUint, unsigned int swapValue)
 
static unsigned int testAndSwapUint (AtomicTypes::Uint *atomicUint, unsigned int compareValue, unsigned int swapValue)
 
static unsigned int testAndSwapUintAcqRel (AtomicTypes::Uint *atomicUint, unsigned int compareValue, unsigned int swapValue)
 
static void addUint (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static void addUintAcqRel (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static void addUintRelaxed (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static unsigned int addUintNv (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static unsigned int addUintNvAcqRel (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static unsigned int addUintNvRelaxed (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static void decrementUint (AtomicTypes::Uint *atomicUint)
 
static void decrementUintAcqRel (AtomicTypes::Uint *atomicUint)
 
static unsigned int decrementUintNv (AtomicTypes::Uint *atomicUint)
 
static unsigned int decrementUintNvAcqRel (AtomicTypes::Uint *atomicUint)
 
static void incrementUint (AtomicTypes::Uint *atomicUint)
 
static void incrementUintAcqRel (AtomicTypes::Uint *atomicUint)
 
static unsigned int incrementUintNv (AtomicTypes::Uint *atomicUint)
 
static unsigned int incrementUintNvAcqRel (AtomicTypes::Uint *atomicUint)
 
static unsigned int subtractUintNv (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static unsigned int subtractUintNvAcqRel (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static unsigned int subtractUintNvRelaxed (AtomicTypes::Uint *atomicUint, unsigned int value)
 
static Types::Uint64 getUint64 (AtomicTypes::Uint64 const *atomicUint)
 
static Types::Uint64 getUint64Acquire (AtomicTypes::Uint64 const *atomicUint)
 
static Types::Uint64 getUint64Relaxed (AtomicTypes::Uint64 const *atomicUint)
 
static void initUint64 (AtomicTypes::Uint64 *atomicUint, Types::Uint64 initialValue=0)
 
static void setUint64 (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static void setUint64Relaxed (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static void setUint64Release (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static Types::Uint64 swapUint64 (AtomicTypes::Uint64 *atomicUint, Types::Uint64 swapValue)
 
static Types::Uint64 swapUint64AcqRel (AtomicTypes::Uint64 *atomicUint, Types::Uint64 swapValue)
 
static Types::Uint64 testAndSwapUint64 (AtomicTypes::Uint64 *atomicUint, Types::Uint64 compareValue, Types::Uint64 swapValue)
 
static Types::Uint64 testAndSwapUint64AcqRel (AtomicTypes::Uint64 *atomicUint, Types::Uint64 compareValue, Types::Uint64 swapValue)
 
static void addUint64 (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static void addUint64AcqRel (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static void addUint64Relaxed (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static Types::Uint64 addUint64Nv (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static Types::Uint64 addUint64NvAcqRel (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static Types::Uint64 addUint64NvRelaxed (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static void decrementUint64 (AtomicTypes::Uint64 *atomicUint)
 
static void decrementUint64AcqRel (AtomicTypes::Uint64 *atomicUint)
 
static Types::Uint64 decrementUint64Nv (AtomicTypes::Uint64 *atomicUint)
 
static Types::Uint64 decrementUint64NvAcqRel (AtomicTypes::Uint64 *atomicUint)
 
static void incrementUint64 (AtomicTypes::Uint64 *atomicUint)
 
static void incrementUint64AcqRel (AtomicTypes::Uint64 *atomicUint)
 
static Types::Uint64 incrementUint64Nv (AtomicTypes::Uint64 *atomicUint)
 
static Types::Uint64 incrementUint64NvAcqRel (AtomicTypes::Uint64 *atomicUint)
 
static Types::Uint64 subtractUint64Nv (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static Types::Uint64 subtractUint64NvAcqRel (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static Types::Uint64 subtractUint64NvRelaxed (AtomicTypes::Uint64 *atomicUint, Types::Uint64 value)
 
static void * getPtr (AtomicTypes::Pointer const *atomicPtr)
 
static void * getPtrAcquire (AtomicTypes::Pointer const *atomicPtr)
 
static void * getPtrRelaxed (AtomicTypes::Pointer const *atomicPtr)
 
static void initPointer (AtomicTypes::Pointer *atomicPtr, void *initialValue=0)
 
static void setPtr (AtomicTypes::Pointer *atomicPtr, void *value)
 
static void setPtrRelaxed (AtomicTypes::Pointer *atomicPtr, void *value)
 
static void setPtrRelease (AtomicTypes::Pointer *atomicPtr, void *value)
 
static void * swapPtr (AtomicTypes::Pointer *atomicPtr, void *swapValue)
 
static void * swapPtrAcqRel (AtomicTypes::Pointer *atomicPtr, void *swapValue)
 
static void * testAndSwapPtr (AtomicTypes::Pointer *atomicPtr, void *compareValue, void *swapValue)
 
static void * testAndSwapPtrAcqRel (AtomicTypes::Pointer *atomicPtr, void *compareValue, void *swapValue)
 

Detailed Description

AtomicOperations provides a namespace for a suite of atomic operations on the following types as defined by the AtomicTypes typedef: integer - AtomicTypes::Int, 64bit integer - AtomicTypes::Int64, pointer - AtomicTypes::Pointer.

Member Typedef Documentation

◆ AtomicTypes

typedef Atomic_TypeTraits<Imp> bsls::AtomicOperations::AtomicTypes

◆ Imp

typedef AtomicOperations_Imp bsls::AtomicOperations::Imp

Member Function Documentation

◆ addInt()

void bsls::AtomicOperations::addInt ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value, providing the sequential consistency memory ordering guarantee.

◆ addInt64()

void bsls::AtomicOperations::addInt64 ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value, providing the sequential consistency memory ordering guarantee.

◆ addInt64AcqRel()

void bsls::AtomicOperations::addInt64AcqRel ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value, providing the acquire/release memory ordering guarantee.

◆ addInt64Nv()

Types::Int64 bsls::AtomicOperations::addInt64Nv ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ addInt64NvAcqRel()

Types::Int64 bsls::AtomicOperations::addInt64NvAcqRel ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ addInt64NvRelaxed()

Types::Int64 bsls::AtomicOperations::addInt64NvRelaxed ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ addInt64Relaxed()

void bsls::AtomicOperations::addInt64Relaxed ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value, without providing any memory ordering guarantees.

◆ addIntAcqRel()

void bsls::AtomicOperations::addIntAcqRel ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value, providing the acquire/release memory ordering guarantee.

◆ addIntNv()

int bsls::AtomicOperations::addIntNv ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ addIntNvAcqRel()

int bsls::AtomicOperations::addIntNvAcqRel ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ addIntNvRelaxed()

int bsls::AtomicOperations::addIntNvRelaxed ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ addIntRelaxed()

void bsls::AtomicOperations::addIntRelaxed ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically add to the specified atomicInt the specified value, without providing any memory ordering guarantees.

◆ addUint()

void bsls::AtomicOperations::addUint ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value, providing the sequential consistency memory ordering guarantee.

◆ addUint64()

void bsls::AtomicOperations::addUint64 ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value, providing the sequential consistency memory ordering guarantee.

◆ addUint64AcqRel()

void bsls::AtomicOperations::addUint64AcqRel ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value, providing the acquire/release memory ordering guarantee.

◆ addUint64Nv()

Types::Uint64 bsls::AtomicOperations::addUint64Nv ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ addUint64NvAcqRel()

Types::Uint64 bsls::AtomicOperations::addUint64NvAcqRel ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ addUint64NvRelaxed()

Types::Uint64 bsls::AtomicOperations::addUint64NvRelaxed ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ addUint64Relaxed()

void bsls::AtomicOperations::addUint64Relaxed ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value, without providing any memory ordering guarantees.

◆ addUintAcqRel()

void bsls::AtomicOperations::addUintAcqRel ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value, providing the acquire/release memory ordering guarantee.

◆ addUintNv()

unsigned int bsls::AtomicOperations::addUintNv ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ addUintNvAcqRel()

unsigned int bsls::AtomicOperations::addUintNvAcqRel ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ addUintNvRelaxed()

unsigned int bsls::AtomicOperations::addUintNvRelaxed ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ addUintRelaxed()

void bsls::AtomicOperations::addUintRelaxed ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically add to the specified atomicUint the specified value, without providing any memory ordering guarantees.

◆ decrementInt()

void bsls::AtomicOperations::decrementInt ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically decrement the value of the specified atomicInt by 1, providing the sequential consistency memory ordering guarantee.

◆ decrementInt64()

void bsls::AtomicOperations::decrementInt64 ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically decrement the specified atomicInt by 1, providing the sequential consistency memory ordering guarantee.

◆ decrementInt64AcqRel()

void bsls::AtomicOperations::decrementInt64AcqRel ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically decrement the specified atomicInt by 1, providing the acquire/release memory ordering guarantee.

◆ decrementInt64Nv()

Types::Int64 bsls::AtomicOperations::decrementInt64Nv ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically decrement the specified atomicInt by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ decrementInt64NvAcqRel()

Types::Int64 bsls::AtomicOperations::decrementInt64NvAcqRel ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically decrement the specified atomicInt by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ decrementIntAcqRel()

void bsls::AtomicOperations::decrementIntAcqRel ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically decrement the value of the specified atomicInt by 1, providing the acquire/release memory ordering guarantee.

◆ decrementIntNv()

int bsls::AtomicOperations::decrementIntNv ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically decrement the specified atomicInt by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ decrementIntNvAcqRel()

int bsls::AtomicOperations::decrementIntNvAcqRel ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically decrement the specified atomicInt by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ decrementUint()

void bsls::AtomicOperations::decrementUint ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically decrement the value of the specified atomicUint by 1, providing the sequential consistency memory ordering guarantee.

◆ decrementUint64()

void bsls::AtomicOperations::decrementUint64 ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically decrement the specified atomicUint by 1, providing the sequential consistency memory ordering guarantee.

◆ decrementUint64AcqRel()

void bsls::AtomicOperations::decrementUint64AcqRel ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically decrement the specified atomicUint by 1, providing the acquire/release memory ordering guarantee.

◆ decrementUint64Nv()

Types::Uint64 bsls::AtomicOperations::decrementUint64Nv ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically decrement the specified atomicUint by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ decrementUint64NvAcqRel()

Types::Uint64 bsls::AtomicOperations::decrementUint64NvAcqRel ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically decrement the specified atomicUint by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ decrementUintAcqRel()

void bsls::AtomicOperations::decrementUintAcqRel ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically decrement the value of the specified atomicUint by 1, providing the acquire/release memory ordering guarantee.

◆ decrementUintNv()

unsigned int bsls::AtomicOperations::decrementUintNv ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically decrement the specified atomicUint by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ decrementUintNvAcqRel()

unsigned int bsls::AtomicOperations::decrementUintNvAcqRel ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically decrement the specified atomicUint by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ getInt()

int bsls::AtomicOperations::getInt ( AtomicTypes::Int const *  atomicInt)
inlinestatic

Atomically retrieve the value of the specified atomicInt, providing the sequential consistency memory ordering guarantee.

◆ getInt64()

Types::Int64 bsls::AtomicOperations::getInt64 ( AtomicTypes::Int64 const *  atomicInt)
inlinestatic

Atomically retrieve the value of the specified atomicInt, providing the sequential consistency memory ordering guarantee.

◆ getInt64Acquire()

Types::Int64 bsls::AtomicOperations::getInt64Acquire ( AtomicTypes::Int64 const *  atomicInt)
inlinestatic

Atomically retrieve the value of the specified atomicInt, providing the acquire memory ordering guarantee.

◆ getInt64Relaxed()

Types::Int64 bsls::AtomicOperations::getInt64Relaxed ( AtomicTypes::Int64 const *  atomicInt)
inlinestatic

Atomically retrieve the value of the specified atomicInt, without providing any memory ordering guarantees.

◆ getIntAcquire()

int bsls::AtomicOperations::getIntAcquire ( AtomicTypes::Int const *  atomicInt)
inlinestatic

Atomically retrieve the value of the specified atomicInt, providing the acquire memory ordering guarantee.

◆ getIntRelaxed()

int bsls::AtomicOperations::getIntRelaxed ( AtomicTypes::Int const *  atomicInt)
inlinestatic

Atomically retrieve the value of the specified atomicInt, without providing any memory ordering guarantees.

◆ getPtr()

void * bsls::AtomicOperations::getPtr ( AtomicTypes::Pointer const *  atomicPtr)
inlinestatic

Atomically retrieve the value of the specified atomicPtr, providing the sequential consistency memory ordering guarantee.

◆ getPtrAcquire()

void * bsls::AtomicOperations::getPtrAcquire ( AtomicTypes::Pointer const *  atomicPtr)
inlinestatic

Atomically retrieve the value of the specified atomicPtr, providing the acquire memory ordering guarantee.

◆ getPtrRelaxed()

void * bsls::AtomicOperations::getPtrRelaxed ( AtomicTypes::Pointer const *  atomicPtr)
inlinestatic

Atomically retrieve the value of the specified atomicPtr, without providing any memory ordering guarantees.

◆ getUint()

unsigned int bsls::AtomicOperations::getUint ( AtomicTypes::Uint const *  atomicUint)
inlinestatic

Atomically retrieve the value of the specified atomicUint, providing the sequential consistency memory ordering guarantee.

◆ getUint64()

Types::Uint64 bsls::AtomicOperations::getUint64 ( AtomicTypes::Uint64 const *  atomicUint)
inlinestatic

Atomically retrieve the value of the specified atomicUint, providing the sequential consistency memory ordering guarantee.

◆ getUint64Acquire()

Types::Uint64 bsls::AtomicOperations::getUint64Acquire ( AtomicTypes::Uint64 const *  atomicUint)
inlinestatic

Atomically retrieve the value of the specified atomicUint, providing the acquire memory ordering guarantee.

◆ getUint64Relaxed()

Types::Uint64 bsls::AtomicOperations::getUint64Relaxed ( AtomicTypes::Uint64 const *  atomicUint)
inlinestatic

Atomically retrieve the value of the specified atomicUint, without providing any memory ordering guarantees.

◆ getUintAcquire()

unsigned int bsls::AtomicOperations::getUintAcquire ( AtomicTypes::Uint const *  atomicUint)
inlinestatic

Atomically retrieve the value of the specified atomicUint, providing the acquire memory ordering guarantee.

◆ getUintRelaxed()

unsigned int bsls::AtomicOperations::getUintRelaxed ( AtomicTypes::Uint const *  atomicUint)
inlinestatic

Atomically retrieve the value of the specified atomicUint, without providing any memory ordering guarantees.

◆ incrementInt()

void bsls::AtomicOperations::incrementInt ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically increment the value of the specified atomicInt by 1, providing the sequential consistency memory ordering guarantee.

◆ incrementInt64()

void bsls::AtomicOperations::incrementInt64 ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically increment the value of the specified atomicInt by 1, providing the sequential consistency memory ordering guarantee.

◆ incrementInt64AcqRel()

void bsls::AtomicOperations::incrementInt64AcqRel ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically increment the value of the specified atomicInt by 1, providing the acquire/release memory ordering guarantee.

◆ incrementInt64Nv()

Types::Int64 bsls::AtomicOperations::incrementInt64Nv ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically increment the specified atomicInt by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ incrementInt64NvAcqRel()

Types::Int64 bsls::AtomicOperations::incrementInt64NvAcqRel ( AtomicTypes::Int64 *  atomicInt)
inlinestatic

Atomically increment the specified atomicInt by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ incrementIntAcqRel()

void bsls::AtomicOperations::incrementIntAcqRel ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically increment the value of the specified atomicInt by 1, providing the acquire/release memory ordering guarantee.

◆ incrementIntNv()

int bsls::AtomicOperations::incrementIntNv ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically increment the specified atomicInt by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ incrementIntNvAcqRel()

int bsls::AtomicOperations::incrementIntNvAcqRel ( AtomicTypes::Int *  atomicInt)
inlinestatic

Atomically increment the specified atomicInt by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ incrementUint()

void bsls::AtomicOperations::incrementUint ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically increment the value of the specified atomicUint by 1, providing the sequential consistency memory ordering guarantee.

◆ incrementUint64()

void bsls::AtomicOperations::incrementUint64 ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically increment the value of the specified atomicUint by 1, providing the sequential consistency memory ordering guarantee.

◆ incrementUint64AcqRel()

void bsls::AtomicOperations::incrementUint64AcqRel ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically increment the value of the specified atomicUint by 1, providing the acquire/release memory ordering guarantee.

◆ incrementUint64Nv()

Types::Uint64 bsls::AtomicOperations::incrementUint64Nv ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically increment the specified atomicUint by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ incrementUint64NvAcqRel()

Types::Uint64 bsls::AtomicOperations::incrementUint64NvAcqRel ( AtomicTypes::Uint64 *  atomicUint)
inlinestatic

Atomically increment the specified atomicUint by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ incrementUintAcqRel()

void bsls::AtomicOperations::incrementUintAcqRel ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically increment the value of the specified atomicUint by 1, providing the acquire/release memory ordering guarantee.

◆ incrementUintNv()

unsigned int bsls::AtomicOperations::incrementUintNv ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically increment the specified atomicUint by 1 and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ incrementUintNvAcqRel()

unsigned int bsls::AtomicOperations::incrementUintNvAcqRel ( AtomicTypes::Uint *  atomicUint)
inlinestatic

Atomically increment the specified atomicUint by 1 and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ initInt()

void bsls::AtomicOperations::initInt ( AtomicTypes::Int *  atomicInt,
int  initialValue = 0 
)
inlinestatic

Initialize the specified atomicInt and set its value to the optionally specified initialValue.

◆ initInt64()

void bsls::AtomicOperations::initInt64 ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  initialValue = 0 
)
inlinestatic

Initialize the specified atomicInt and set its value to the optionally specified initialValue.

◆ initPointer()

void bsls::AtomicOperations::initPointer ( AtomicTypes::Pointer *  atomicPtr,
void *  initialValue = 0 
)
inlinestatic

Initialize the specified atomicPtr and set its value to the optionally specified initialValue.

◆ initUint()

void bsls::AtomicOperations::initUint ( AtomicTypes::Uint *  atomicUint,
unsigned int  initialValue = 0 
)
inlinestatic

Initialize the specified atomicUint and set its value to the optionally specified initialValue.

◆ initUint64()

void bsls::AtomicOperations::initUint64 ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  initialValue = 0 
)
inlinestatic

Initialize the specified atomicUint and set its value to the optionally specified initialValue.

◆ setInt()

void bsls::AtomicOperations::setInt ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified value, providing the sequential consistency memory ordering guarantee.

◆ setInt64()

void bsls::AtomicOperations::setInt64 ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified value, providing the sequential consistency memory ordering guarantee.

◆ setInt64Relaxed()

void bsls::AtomicOperations::setInt64Relaxed ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified value, without providing any memory ordering guarantees.

◆ setInt64Release()

void bsls::AtomicOperations::setInt64Release ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified value, providing the release memory ordering guarantee.

◆ setIntRelaxed()

void bsls::AtomicOperations::setIntRelaxed ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified value, without providing any memory ordering guarantees.

◆ setIntRelease()

void bsls::AtomicOperations::setIntRelease ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified value, providing the release memory ordering guarantee.

◆ setPtr()

void bsls::AtomicOperations::setPtr ( AtomicTypes::Pointer *  atomicPtr,
void *  value 
)
inlinestatic

Atomically set the value of the specified atomicPtr to the specified value, providing the sequential consistency memory ordering guarantee.

◆ setPtrRelaxed()

void bsls::AtomicOperations::setPtrRelaxed ( AtomicTypes::Pointer *  atomicPtr,
void *  value 
)
inlinestatic

Atomically set the value of the specified atomicPtr to the specified value, without providing any memory ordering guarantees.

◆ setPtrRelease()

void bsls::AtomicOperations::setPtrRelease ( AtomicTypes::Pointer *  atomicPtr,
void *  value 
)
inlinestatic

Atomically set the value of the specified atomicPtr to the specified value, providing the release memory ordering guarantee.

◆ setUint()

void bsls::AtomicOperations::setUint ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified value, providing the sequential consistency memory ordering guarantee.

◆ setUint64()

void bsls::AtomicOperations::setUint64 ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified value, providing the sequential consistency memory ordering guarantee.

◆ setUint64Relaxed()

void bsls::AtomicOperations::setUint64Relaxed ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified value, without providing any memory ordering guarantees.

◆ setUint64Release()

void bsls::AtomicOperations::setUint64Release ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified value, providing the release memory ordering guarantee.

◆ setUintRelaxed()

void bsls::AtomicOperations::setUintRelaxed ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified value, without providing any memory ordering guarantees.

◆ setUintRelease()

void bsls::AtomicOperations::setUintRelease ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified value, providing the release memory ordering guarantee.

◆ subtractInt64Nv()

Types::Int64 bsls::AtomicOperations::subtractInt64Nv ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically subtract from the specified atomicInt the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ subtractInt64NvAcqRel()

Types::Int64 bsls::AtomicOperations::subtractInt64NvAcqRel ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically subtract from the specified atomicInt the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ subtractInt64NvRelaxed()

Types::Int64 bsls::AtomicOperations::subtractInt64NvRelaxed ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  value 
)
inlinestatic

Atomically subtract from the specified atomicInt the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ subtractIntNv()

int bsls::AtomicOperations::subtractIntNv ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically subtract from the specified atomicInt the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ subtractIntNvAcqRel()

int bsls::AtomicOperations::subtractIntNvAcqRel ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically subtract from the specified atomicInt the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ subtractIntNvRelaxed()

int bsls::AtomicOperations::subtractIntNvRelaxed ( AtomicTypes::Int *  atomicInt,
int  value 
)
inlinestatic

Atomically subtract from the specified atomicInt the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ subtractUint64Nv()

Types::Uint64 bsls::AtomicOperations::subtractUint64Nv ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically subtract from the specified atomicUint the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ subtractUint64NvAcqRel()

Types::Uint64 bsls::AtomicOperations::subtractUint64NvAcqRel ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically subtract from the specified atomicUint the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ subtractUint64NvRelaxed()

Types::Uint64 bsls::AtomicOperations::subtractUint64NvRelaxed ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  value 
)
inlinestatic

Atomically subtract from the specified atomicUint the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ subtractUintNv()

unsigned int bsls::AtomicOperations::subtractUintNv ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically subtract from the specified atomicUint the specified value and return the resulting value, providing the sequential consistency memory ordering guarantee.

◆ subtractUintNvAcqRel()

unsigned int bsls::AtomicOperations::subtractUintNvAcqRel ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically subtract from the specified atomicUint the specified value and return the resulting value, providing the acquire/release memory ordering guarantee.

◆ subtractUintNvRelaxed()

unsigned int bsls::AtomicOperations::subtractUintNvRelaxed ( AtomicTypes::Uint *  atomicUint,
unsigned int  value 
)
inlinestatic

Atomically subtract from the specified atomicUint the specified value and return the resulting value, without providing any memory ordering guarantees.

◆ swapInt()

int bsls::AtomicOperations::swapInt ( AtomicTypes::Int *  atomicInt,
int  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified swapValue, and return its previous value, providing the sequential consistency memory ordering guarantee.

◆ swapInt64()

Types::Int64 bsls::AtomicOperations::swapInt64 ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified swapValue and return its previous value, providing the sequential consistency memory ordering guarantee.

◆ swapInt64AcqRel()

Types::Int64 bsls::AtomicOperations::swapInt64AcqRel ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified swapValue and return its previous value, providing the acquire/release memory ordering guarantee.

◆ swapIntAcqRel()

int bsls::AtomicOperations::swapIntAcqRel ( AtomicTypes::Int *  atomicInt,
int  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicInt to the specified swapValue, and return its previous value, providing the acquire/release memory ordering guarantee.

◆ swapPtr()

void * bsls::AtomicOperations::swapPtr ( AtomicTypes::Pointer *  atomicPtr,
void *  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicPtr to the specified swapValue, and return its previous value, providing the sequential consistency memory ordering guarantee.

◆ swapPtrAcqRel()

void * bsls::AtomicOperations::swapPtrAcqRel ( AtomicTypes::Pointer *  atomicPtr,
void *  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicPtr to the specified swapValue, and return its previous value, providing the acquire/release memory ordering guarantee.

◆ swapUint()

unsigned int bsls::AtomicOperations::swapUint ( AtomicTypes::Uint *  atomicUint,
unsigned int  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified swapValue, and return its previous value, providing the sequential consistency memory ordering guarantee.

◆ swapUint64()

Types::Uint64 bsls::AtomicOperations::swapUint64 ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified swapValue and return its previous value, providing the sequential consistency memory ordering guarantee.

◆ swapUint64AcqRel()

Types::Uint64 bsls::AtomicOperations::swapUint64AcqRel ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified swapValue and return its previous value, providing the acquire/release memory ordering guarantee.

◆ swapUintAcqRel()

unsigned int bsls::AtomicOperations::swapUintAcqRel ( AtomicTypes::Uint *  atomicUint,
unsigned int  swapValue 
)
inlinestatic

Atomically set the value of the specified atomicUint to the specified swapValue, and return its previous value, providing the acquire/release memory ordering guarantee.

◆ testAndSwapInt()

int bsls::AtomicOperations::testAndSwapInt ( AtomicTypes::Int *  atomicInt,
int  compareValue,
int  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicInt to the specified swapValue if and only if the value of atomicInt equals the value of the specified compareValue, and return the initial value of atomicInt, providing the sequential consistency memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapInt64()

Types::Int64 bsls::AtomicOperations::testAndSwapInt64 ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  compareValue,
Types::Int64  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicInt to the specified swapValue if and only if the value of atomicInt equals the value of the specified compareValue, and return the initial value of atomicInt, providing the sequential consistency memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapInt64AcqRel()

Types::Int64 bsls::AtomicOperations::testAndSwapInt64AcqRel ( AtomicTypes::Int64 *  atomicInt,
Types::Int64  compareValue,
Types::Int64  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicInt to the specified swapValue if and only if the value of atomicInt equals the value of the specified compareValue, and return the initial value of atomicInt, providing the acquire/release memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapIntAcqRel()

int bsls::AtomicOperations::testAndSwapIntAcqRel ( AtomicTypes::Int *  atomicInt,
int  compareValue,
int  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicInt to the specified swapValue if and only if the value of atomicInt equals the value of the specified compareValue, and return the initial value of atomicInt, providing the acquire/release memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapPtr()

void * bsls::AtomicOperations::testAndSwapPtr ( AtomicTypes::Pointer *  atomicPtr,
void *  compareValue,
void *  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicPtr to the specified swapValue if and only if the value of atomicPtr equals the value of the specified compareValue, and return the initial value of atomicPtr, providing the sequential consistency memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapPtrAcqRel()

void * bsls::AtomicOperations::testAndSwapPtrAcqRel ( AtomicTypes::Pointer *  atomicPtr,
void *  compareValue,
void *  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicPtr to the specified swapValue if and only if the value of atomicPtr equals the value of the specified compareValue, and return the initial value of atomicPtr, providing the acquire/release memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapUint()

unsigned int bsls::AtomicOperations::testAndSwapUint ( AtomicTypes::Uint *  atomicUint,
unsigned int  compareValue,
unsigned int  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicUint to the specified swapValue if and only if the value of atomicUint equals the value of the specified compareValue, and return the initial value of atomicUint, providing the sequential consistency memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapUint64()

Types::Uint64 bsls::AtomicOperations::testAndSwapUint64 ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  compareValue,
Types::Uint64  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicUint to the specified swapValue if and only if the value of atomicUint equals the value of the specified compareValue, and return the initial value of atomicUint, providing the sequential consistency memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapUint64AcqRel()

Types::Uint64 bsls::AtomicOperations::testAndSwapUint64AcqRel ( AtomicTypes::Uint64 *  atomicUint,
Types::Uint64  compareValue,
Types::Uint64  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicUint to the specified swapValue if and only if the value of atomicUint equals the value of the specified compareValue, and return the initial value of atomicUint, providing the acquire/release memory ordering guarantee. The whole operation is performed atomically.

◆ testAndSwapUintAcqRel()

unsigned int bsls::AtomicOperations::testAndSwapUintAcqRel ( AtomicTypes::Uint *  atomicUint,
unsigned int  compareValue,
unsigned int  swapValue 
)
inlinestatic

Conditionally set the value of the specified atomicUint to the specified swapValue if and only if the value of atomicInt equals the value of the specified compareValue, and return the initial value of atomicUint, providing the acquire/release memory ordering guarantee. The whole operation is performed atomically.

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