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)

Constructs a QAtomicInteger with the given value.

QAtomicInteger::​QAtomicInteger(const QAtomicInteger & 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--().

int QAtomicInteger::​fetchAndAddAcquire(int 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().

int QAtomicInteger::​fetchAndAddOrdered(int 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().

int QAtomicInteger::​fetchAndAddRelaxed(int 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().

int QAtomicInteger::​fetchAndAddRelease(int 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().

int QAtomicInteger::​fetchAndAndAcquire(int 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&=().

int QAtomicInteger::​fetchAndAndOrdered(int 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&=().

int QAtomicInteger::​fetchAndAndRelaxed(int 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&=().

int QAtomicInteger::​fetchAndAndRelease(int 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&=().

int QAtomicInteger::​fetchAndOrAcquire(int 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|=().

int QAtomicInteger::​fetchAndOrOrdered(int 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|=().

int QAtomicInteger::​fetchAndOrRelaxed(int 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|=().

int QAtomicInteger::​fetchAndOrRelease(int 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|=().

int QAtomicInteger::​fetchAndStoreAcquire(int 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.

int QAtomicInteger::​fetchAndStoreOrdered(int 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.

int QAtomicInteger::​fetchAndStoreRelaxed(int 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.

int QAtomicInteger::​fetchAndStoreRelease(int 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.

int QAtomicInteger::​fetchAndSubAcquire(int 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().

int QAtomicInteger::​fetchAndSubOrdered(int 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().

int QAtomicInteger::​fetchAndSubRelaxed(int 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().

int QAtomicInteger::​fetchAndSubRelease(int 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().

int QAtomicInteger::​fetchAndXorAcquire(int 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^=().

int QAtomicInteger::​fetchAndXorOrdered(int 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^=().

int QAtomicInteger::​fetchAndXorRelaxed(int 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^=().

int QAtomicInteger::​fetchAndXorRelease(int 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.

int 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().

int 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(int newValue)

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

See also storeRelease() and load().

void QAtomicInteger::​storeRelease(int newValue)

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

See also store() and load().

bool QAtomicInteger::​testAndSetAcquire(int expectedValue, int 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(int expectedValue, int 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(int expectedValue, int 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(int expectedValue, int 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.

QAtomicInteger::​operator int() 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().

int QAtomicInteger::​operator&=(int valueToAnd)

Atomic add-and-fetch.

Reads the current value of this QAtomicInteger and then bitwise-ANDs valueToAnd to the current value, returning the new value 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().

int 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--().

int 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).

int QAtomicInteger::​operator+=(int valueToAdd)

Atomic add-and-fetch.

Reads the current value of this QAtomicInteger and then adds valueToAdd to the current value, returning the new value 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-=().

int 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++().

int 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).

int QAtomicInteger::​operator-=(int valueToSub)

Atomic sub-and-fetch.

Reads the current value of this QAtomicInteger and then subtracts valueToSub to the current value, returning the new value 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 & QAtomicInteger::​operator=(const QAtomicInteger & other)

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

QAtomicInteger & QAtomicInteger::​operator=(int newValue)

Atomically stores the newValue 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().

int QAtomicInteger::​operator^=(int valueToXor)

Atomic xor-and-fetch.

Reads the current value of this QAtomicInteger and then bitwise-XORs valueToXor to the current value, returning the new value 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().

int QAtomicInteger::​operator|=(int valueToOr)

Atomic or-and-fetch.

Reads the current value of this QAtomicInteger and then bitwise-ORs valueToOr to the current value, returning the new value 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().