MySharedType &MySharedType::operator=(const MySharedType &other)
{
    (void) other.data->atomicInt.ref();
    if (!data->atomicInt.deref()) {
        // The last reference has been released
        delete d;
    }
    d = other.d;
    return *this;
}

if (currentValue == expectedValue) {
    currentValue = newValue;
    return true;
}
return false;

int originalValue = currentValue;
currentValue = newValue;
return originalValue;

int originalValue = currentValue;
currentValue += valueToAdd;
return originalValue;

Member Function Documentation

QAtomicInteger::QAtomicInteger(T value = 0)

Default constructs an instance of QAtomicInteger.

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

Constructs a copy of other.

bool QAtomicInteger::deref()

Atomically decrements the value of this QAtomicInteger. Returns true if the new value is non-zero, false otherwise.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

See also ref() and operator--().

T QAtomicInteger::fetchAndAddAcquire(T valueToAdd)

Atomic fetch-and-add.

Reads the current value of this QAtomicInteger and then adds valueToAdd to the current value, returning the original value.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

See also operator+=() and fetchAndSubAcquire().

T QAtomicInteger::fetchAndAddOrdered(T valueToAdd)

Atomic fetch-and-add.

Reads the current value of this QAtomicInteger and then adds valueToAdd to the current value, returning the original value.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

See also operator+=() and fetchAndSubOrdered().

T QAtomicInteger::fetchAndAddRelaxed(T valueToAdd)

Atomic fetch-and-add.

Reads the current value of this QAtomicInteger and then adds valueToAdd to the current value, returning the original value.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

See also operator+=() and fetchAndSubRelaxed().

T QAtomicInteger::fetchAndAddRelease(T valueToAdd)

Atomic fetch-and-add.

Reads the current value of this QAtomicInteger and then adds valueToAdd to the current value, returning the original value.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

See also operator+=() and fetchAndSubRelease().

T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)

Atomic fetch-and-and.

Reads the current value of this QAtomicInteger and then bitwise-ANDs valueToAnd to the current value, returning the original value.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

This function was introduced in Qt 5.3.

See also operator&=().

T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)

Atomic fetch-and-and.

Reads the current value of this QAtomicInteger and then bitwise-ANDs valueToAnd to the current value, returning the original value.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

This function was introduced in Qt 5.3.

See also operator&=().

T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)

Atomic fetch-and-and.

Reads the current value of this QAtomicInteger and then bitwise-ANDs valueToAnd to the current value, returning the original value.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

This function was introduced in Qt 5.3.

See also operator&=().

T QAtomicInteger::fetchAndAndRelease(T valueToAnd)

Atomic fetch-and-and.

Reads the current value of this QAtomicInteger and then bitwise-ANDs valueToAnd to the current value, returning the original value.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

This function was introduced in Qt 5.3.

See also operator&=().

T QAtomicInteger::fetchAndOrAcquire(T valueToOr)

Atomic fetch-and-or.

Reads the current value of this QAtomicInteger and then bitwise-ORs valueToOr to the current value, returning the original value.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

This function was introduced in Qt 5.3.

See also operator|=().

T QAtomicInteger::fetchAndOrOrdered(T valueToOr)

Atomic fetch-and-or.

Reads the current value of this QAtomicInteger and then bitwise-ORs valueToOr to the current value, returning the original value.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

This function was introduced in Qt 5.3.

See also operator|=().

T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)

Atomic fetch-and-or.

Reads the current value of this QAtomicInteger and then bitwise-ORs valueToOr to the current value, returning the original value.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

This function was introduced in Qt 5.3.

See also operator|=().

T QAtomicInteger::fetchAndOrRelease(T valueToOr)

Atomic fetch-and-or.

Reads the current value of this QAtomicInteger and then bitwise-ORs valueToOr to the current value, returning the original value.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

This function was introduced in Qt 5.3.

See also operator|=().

T QAtomicInteger::fetchAndStoreAcquire(T newValue)

Atomic fetch-and-store.

Reads the current value of this QAtomicInteger and then assigns it the newValue, returning the original value.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

T QAtomicInteger::fetchAndStoreOrdered(T newValue)

Atomic fetch-and-store.

Reads the current value of this QAtomicInteger and then assigns it the newValue, returning the original value.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

T QAtomicInteger::fetchAndStoreRelaxed(T newValue)

Atomic fetch-and-store.

Reads the current value of this QAtomicInteger and then assigns it the newValue, returning the original value.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

T QAtomicInteger::fetchAndStoreRelease(T newValue)

Atomic fetch-and-store.

Reads the current value of this QAtomicInteger and then assigns it the newValue, returning the original value.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

T QAtomicInteger::fetchAndSubAcquire(T valueToSub)

Atomic fetch-and-sub.

Reads the current value of this QAtomicInteger and then subtracts valueToSub to the current value, returning the original value.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

This function was introduced in Qt 5.3.

See also operator-=() and fetchAndAddAcquire().

T QAtomicInteger::fetchAndSubOrdered(T valueToSub)

Atomic fetch-and-sub.

Reads the current value of this QAtomicInteger and then subtracts valueToSub to the current value, returning the original value.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

This function was introduced in Qt 5.3.

See also operator-=() and fetchAndAddOrdered().

T QAtomicInteger::fetchAndSubRelaxed(T valueToSub)

Atomic fetch-and-sub.

Reads the current value of this QAtomicInteger and then subtracts valueToSub to the current value, returning the original value.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

This function was introduced in Qt 5.3.

See also operator-=() and fetchAndAddRelaxed().

T QAtomicInteger::fetchAndSubRelease(T valueToSub)

Atomic fetch-and-sub.

Reads the current value of this QAtomicInteger and then subtracts valueToSub to the current value, returning the original value.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

This function was introduced in Qt 5.3.

See also operator-=() and fetchAndAddRelease().

T QAtomicInteger::fetchAndXorAcquire(T valueToXor)

Atomic fetch-and-xor.

Reads the current value of this QAtomicInteger and then bitwise-XORs valueToXor to the current value, returning the original value.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

This function was introduced in Qt 5.3.

See also operator^=().

T QAtomicInteger::fetchAndXorOrdered(T valueToXor)

Atomic fetch-and-xor.

Reads the current value of this QAtomicInteger and then bitwise-XORs valueToXor to the current value, returning the original value.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

This function was introduced in Qt 5.3.

See also operator^=().

T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)

Atomic fetch-and-xor.

Reads the current value of this QAtomicInteger and then bitwise-XORs valueToXor to the current value, returning the original value.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

This function was introduced in Qt 5.3.

See also operator^=().

T QAtomicInteger::fetchAndXorRelease(T valueToXor)

Atomic fetch-and-xor.

Reads the current value of this QAtomicInteger and then bitwise-XORs valueToXor to the current value, returning the original value.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

This function was introduced in Qt 5.3.

See also operator^=().

[static] bool QAtomicInteger::isFetchAndAddNative()

Returns true if fetch-and-add is implemented using atomic processor instructions, false otherwise.

[static] bool QAtomicInteger::isFetchAndAddWaitFree()

Returns true if atomic fetch-and-add is wait-free, false otherwise.

[static] bool QAtomicInteger::isFetchAndStoreNative()

Returns true if fetch-and-store is implemented using atomic processor instructions, false otherwise.

[static] bool QAtomicInteger::isFetchAndStoreWaitFree()

Returns true if atomic fetch-and-store is wait-free, false otherwise.

[static] bool QAtomicInteger::isReferenceCountingNative()

Returns true if reference counting is implemented using atomic processor instructions, false otherwise.

[static] bool QAtomicInteger::isReferenceCountingWaitFree()

Returns true if atomic reference counting is wait-free, false otherwise.

[static] bool QAtomicInteger::isTestAndSetNative()

Returns true if test-and-set is implemented using atomic processor instructions, false otherwise.

[static] bool QAtomicInteger::isTestAndSetWaitFree()

Returns true if atomic test-and-set is wait-free, false otherwise.

T QAtomicInteger::load() const

Atomically loads the value of this QAtomicInteger using relaxed memory ordering. The value is not modified in any way, but note that there's no guarantee that it remains so.

See also store() and loadAcquire().

T QAtomicInteger::loadAcquire() const

Atomically loads the value of this QAtomicInteger using the "Acquire" memory ordering. The value is not modified in any way, but note that there's no guarantee that it remains so.

See also store() and load().

bool QAtomicInteger::ref()

Atomically increments the value of this QAtomicInteger. Returns true if the new value is non-zero, false otherwise.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

See also deref() and operator++().

void QAtomicInteger::store(T newValue)

Atomically stores the newValue value into this atomic type, using relaxed memory ordering.

See also storeRelease() and load().

void QAtomicInteger::storeRelease(T newValue)

Atomically stores the newValue value into this atomic type, using the "Release" memory ordering.

See also store() and load().

bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue)

Atomic test-and-set.

If the current value of this QAtomicInteger is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInteger and return true. If the values are not the same, this function does nothing and returns false.

This function uses acquire memory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.

bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue)

Atomic test-and-set.

If the current value of this QAtomicInteger is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInteger and return true. If the values are not the same, this function does nothing and returns false.

This function uses ordered memory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.

bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue)

Atomic test-and-set.

If the current value of this QAtomicInteger is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInteger and return true. If the values are not the same, this function does nothing and returns false.

This function uses relaxed memory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.

bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue)

Atomic test-and-set.

If the current value of this QAtomicInteger is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInteger and return true. If the values are not the same, this function does nothing and returns false.

This function uses release memory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.

T QAtomicInteger::operator T() const

Atomically loads the value of this QAtomicInteger using a sequentially consistent memory ordering if possible; or "Acquire" ordering if not. The value is not modified in any way, but note that there's no guarantee that it remains so.

This function was introduced in Qt 5.3.

See also load() and loadAcquire().

T QAtomicInteger::operator&=(T value)

Atomic add-and-fetch.

Reads the current value of this QAtomicInteger and then bitwise-ANDs value to the current value, returning the new value.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also fetchAndAndOrdered().

T QAtomicInteger::operator++()

Atomically pre-increments the value of this QAtomicInteger. Returns the new value of this atomic.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also ref(), operator++(int), and operator--().

T QAtomicInteger::operator++(int)

Atomically post-increments the value of this QAtomicInteger. Returns the old value of this atomic.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also ref(), operator++(), and operator--(int).

T QAtomicInteger::operator+=(T value)

Atomic add-and-fetch.

Reads the current value of this QAtomicInteger and then adds value to the current value, returning the new value.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also fetchAndAddOrdered() and operator-=().

T QAtomicInteger::operator--()

Atomically pre-decrements the value of this QAtomicInteger. Returns the new value of this atomic.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also deref(), operator--(int), and operator++().

T QAtomicInteger::operator--(int)

Atomically post-decrements the value of this QAtomicInteger. Returns the old value of this atomic.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also deref(), operator--(), and operator++(int).

T QAtomicInteger::operator-=(T value)

Atomic sub-and-fetch.

Reads the current value of this QAtomicInteger and then subtracts value to the current value, returning the new value.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also fetchAndSubOrdered() and operator+=().

QAtomicInteger<T> &QAtomicInteger::operator=(const QAtomicInteger<T> &other)

Assigns other to this QAtomicInteger and returns a reference to this QAtomicInteger.

QAtomicInteger<T> &QAtomicInteger::operator=(T)

Atomically stores the other value into this atomic type using a sequentially consistent memory ordering if possible; or "Release" ordering if not. This function returns a reference to this object.

This function was introduced in Qt 5.3.

See also store() and storeRelease().

T QAtomicInteger::operator^=(T value)

Atomic xor-and-fetch.

Reads the current value of this QAtomicInteger and then bitwise-XORs value to the current value, returning the new value.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also fetchAndXorOrdered().

T QAtomicInteger::operator|=(T value)

Atomic or-and-fetch.

Reads the current value of this QAtomicInteger and then bitwise-ORs value to the current value, returning the new value.

This function uses a sequentially consistent memory ordering if possible; or "Ordered" ordering if not.

This function was introduced in Qt 5.3.

See also fetchAndOrOrdered().