SYS/SYS_AtomicInt.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        SYS_AtomicInt.h ( UT Library, C++)
 *
 * COMMENTS:    Thread-safe operations on 32-bit integers
 */

#ifndef __SYS_AtomicInt__
#define __SYS_AtomicInt__

#include "SYS_API.h"
#include "SYS_Types.h"
#include "SYS_MemoryOrder.h"

class SYS_API SYS_AtomicInt32 
{
public:
    explicit SYS_AtomicInt32(int32 value = 0) : myValue(value) {}

    /// Note that to use any of these three methods you must
    /// #include SYS_AtomicIntImpl.  Do *not* include that file
    /// in a .h file as it brings in windows.h!
    
    /// Atomically assigns val to myValue, returning the prior value of
    /// myValue.
    inline int32        exchange(int32 val);

    /// Atomically adds val to myValue, returning the prior value of
    /// myValue.
    inline int32        exchangeAdd(int32 val);

    /// Atomically adds val to myValue, returning the new value of myValue.
    inline int32        add(int32 val);

    /// Atomically set myValue to the maximum of val and myValue.
    inline void         maximum(int32 val);

    /// Atomically compares (myValue == expected), and if true, replaces
    /// myValue with desired. Returns prior myValue.
    inline int32        compare_swap(int32 expected, int32 desired);

    /// @pre The supplied order must be one of [RELAXED, RELEASE, SEQ_CST].
    inline void         store(int32 val,
                              SYS_MemoryOrder order = SYS_MEMORY_ORDER_SEQ_CST);

    /// @pre The supplied order must be one of [RELAXED, CONSUME, ACQUIRE,
    /// SEQ_CST].
    inline int32        load(SYS_MemoryOrder order = SYS_MEMORY_ORDER_SEQ_CST)
                                                                        const;
    /// Atomically retrieve value. Same as calling load().
    operator            int32() const;

private:
    int32       myValue;

private:
    // Prohibited operators
    SYS_AtomicInt32(const SYS_AtomicInt32 &);
    SYS_AtomicInt32     &operator=(const SYS_AtomicInt32 &);
};

#endif

---