YiAtomic.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_ATOMIC_H_
#define _YI_ATOMIC_H_

#include "framework/YiPredef.h"

#if defined(_MSC_VER)
#   if !defined(YI_MSVC_ATOMIC)
#       define YI_MSVC_ATOMIC
#   endif
#elif defined (YI_IOS) || defined (YI_TVOS) || defined (YI_OSX)
#   if !defined(YI_OSX_ATOMIC)
#       define YI_OSX_ATOMIC
#   endif
#elif defined (__clang__) || (defined (__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2) && (defined(__x86_64__) || defined(__i386__))) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || __GNUC__ > 4))  // GCC Atomics are only available since gcc 4.2.x for the x86 architecture only, and available on any other cpu architecture since gcc 4.3.x
#   if !defined(YI_GCC_ATOMIC)
#       define YI_GCC_ATOMIC
#   endif
#else
#   if !defined(YI_GENERIC_ATOMIC)
#       define YI_GENERIC_ATOMIC
#   endif
#   include "thread/YiMutex.h"
#   include "thread/YiAutoMutex.h"
#endif


namespace yi {

namespace deprecated
{
#if defined(DOXY)

template<typename YI_ATOMIC_TYPE>
class CYIAtomic
{
public:

    CYIAtomic(YI_ATOMIC_TYPE nValue = (YI_ATOMIC_TYPE)0);
    CYIAtomic(const CYIAtomic<YI_ATOMIC_TYPE> &rOther);
    bool operator==(YI_ATOMIC_TYPE nValue) const;
    bool operator!=(YI_ATOMIC_TYPE nValue) const;
    bool operator!() const;
    operator YI_ATOMIC_TYPE() const;
    CYIAtomic<YI_ATOMIC_TYPE> &operator=(YI_ATOMIC_TYPE nValue);
    YI_ATOMIC_TYPE operator+=(YI_ATOMIC_TYPE nValueToAdd);
    YI_ATOMIC_TYPE operator-=(YI_ATOMIC_TYPE nValueToSub);
    YI_ATOMIC_TYPE operator*=(YI_ATOMIC_TYPE nValueToMult);
    YI_ATOMIC_TYPE operator/=(YI_ATOMIC_TYPE nValueToDiv);
    YI_ATOMIC_TYPE operator&=(YI_ATOMIC_TYPE nValueToAnd);
    YI_ATOMIC_TYPE operator|=(YI_ATOMIC_TYPE nValueToOr);
    YI_ATOMIC_TYPE operator^=(YI_ATOMIC_TYPE nValueToXor);
    YI_ATOMIC_TYPE operator++();
    YI_ATOMIC_TYPE operator++(int);
    YI_ATOMIC_TYPE operator--();
    YI_ATOMIC_TYPE operator--(int);

    YI_ATOMIC_TYPE FetchAndAdd(YI_ATOMIC_TYPE nValueToAdd);

    YI_ATOMIC_TYPE FetchAndSub(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE FetchAndAnd(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE FetchAndOr(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE FetchAndXor(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE AddAndFetch(YI_ATOMIC_TYPE nValue);


    YI_ATOMIC_TYPE SubAndFetch(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE AndAndFetch(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE OrAndFetch(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE XorAndFetch(YI_ATOMIC_TYPE nValue);

    YI_ATOMIC_TYPE CompareAndSwap(YI_ATOMIC_TYPE nCurrentValue, YI_ATOMIC_TYPE nNewValue);

    YI_ATOMIC_TYPE Load() const;

    void Store(YI_ATOMIC_TYPE nNewValue);

    static bool IsLockFree() const;
};
#else


template<typename YI_ATOMIC_TYPE>
class CYIAtomic
{
public:
    CYIAtomic(YI_ATOMIC_TYPE nValue = (YI_ATOMIC_TYPE)0);
    CYIAtomic(const CYIAtomic<YI_ATOMIC_TYPE> &rOther);
    bool operator==(YI_ATOMIC_TYPE nValue) const;
    bool operator!=(YI_ATOMIC_TYPE nValue) const;
    bool operator!() const;
    operator YI_ATOMIC_TYPE() const;
    CYIAtomic<YI_ATOMIC_TYPE> &operator=(const CYIAtomic<YI_ATOMIC_TYPE> &rOther);
    CYIAtomic<YI_ATOMIC_TYPE> &operator=(YI_ATOMIC_TYPE nValue);
    YI_ATOMIC_TYPE operator+=(YI_ATOMIC_TYPE nValueToAdd);
    YI_ATOMIC_TYPE operator-=(YI_ATOMIC_TYPE nValueToSub);
    YI_ATOMIC_TYPE operator*=(YI_ATOMIC_TYPE nValueToMult);
    YI_ATOMIC_TYPE operator/=(YI_ATOMIC_TYPE nValueToDiv);
    YI_ATOMIC_TYPE operator&=(YI_ATOMIC_TYPE nValueToAnd);
    YI_ATOMIC_TYPE operator|=(YI_ATOMIC_TYPE nValueToOr);
    YI_ATOMIC_TYPE operator^=(YI_ATOMIC_TYPE nValueToXor);
    YI_ATOMIC_TYPE operator++();
    YI_ATOMIC_TYPE operator++(int);
    YI_ATOMIC_TYPE operator--();
    YI_ATOMIC_TYPE operator--(int);
    YI_ATOMIC_TYPE FetchAndAdd(YI_ATOMIC_TYPE nValueToAdd);
    YI_ATOMIC_TYPE FetchAndSub(YI_ATOMIC_TYPE nValueToSub);
    YI_ATOMIC_TYPE FetchAndAnd(YI_ATOMIC_TYPE nValueToAnd);
    YI_ATOMIC_TYPE FetchAndOr(YI_ATOMIC_TYPE nValueToOr);
    YI_ATOMIC_TYPE FetchAndXor(YI_ATOMIC_TYPE nValueToXor);
    YI_ATOMIC_TYPE AddAndFetch(YI_ATOMIC_TYPE nValueToAdd);
    YI_ATOMIC_TYPE SubAndFetch(YI_ATOMIC_TYPE nValueToSub);
    YI_ATOMIC_TYPE AndAndFetch(YI_ATOMIC_TYPE nValueToAnd);
    YI_ATOMIC_TYPE OrAndFetch(YI_ATOMIC_TYPE nValueToOr);
    YI_ATOMIC_TYPE XorAndFetch(YI_ATOMIC_TYPE nValueToXor);
    YI_ATOMIC_TYPE CompareAndSwap(YI_ATOMIC_TYPE nCurrentValue, YI_ATOMIC_TYPE nNewValue);
    YI_ATOMIC_TYPE Load() const;
    void Store(YI_ATOMIC_TYPE nValue);
    static bool IsLockFree();
private:
#if defined(YI_GENERIC_ATOMIC)
    YI_ATOMIC_TYPE m_nValue;
    mutable CYIMutex m_mutex;
#else
    volatile YI_ATOMIC_TYPE m_nValue;
#endif
};

// Specialization for pointer types.
template<typename YI_ATOMIC_TYPE>
class CYIAtomic<YI_ATOMIC_TYPE*>
{
public:
    CYIAtomic(YI_ATOMIC_TYPE *pPtr = 0);
    CYIAtomic(const CYIAtomic<YI_ATOMIC_TYPE*> &rOther);
    bool operator==(YI_ATOMIC_TYPE *pPtr) const;
    bool operator!=(YI_ATOMIC_TYPE *pPtr) const;
    bool operator!() const;
    operator YI_ATOMIC_TYPE *();
    operator const YI_ATOMIC_TYPE *() const;
    YI_ATOMIC_TYPE &operator*();
    const YI_ATOMIC_TYPE &operator*() const;
    YI_ATOMIC_TYPE *operator->();
    const YI_ATOMIC_TYPE *operator->() const;
    CYIAtomic<YI_ATOMIC_TYPE *> &operator=(const CYIAtomic<YI_ATOMIC_TYPE*> &rOther);
    CYIAtomic<YI_ATOMIC_TYPE *> &operator=(YI_ATOMIC_TYPE *pPtr);
    YI_ATOMIC_TYPE *operator+=(ssize_t nValueToAdd);
    YI_ATOMIC_TYPE *operator-=(ssize_t nValueToSub);
    YI_ATOMIC_TYPE *operator++();
    YI_ATOMIC_TYPE *operator++(int);
    YI_ATOMIC_TYPE *operator--();
    YI_ATOMIC_TYPE *operator--(int);
    YI_ATOMIC_TYPE *FetchAndAdd(ssize_t nValueToAdd);
    YI_ATOMIC_TYPE *FetchAndSub(ssize_t nValueToSub);
    YI_ATOMIC_TYPE *AddAndFetch(ssize_t nValueToAdd);
    YI_ATOMIC_TYPE *SubAndFetch(ssize_t nValueToSub);
    YI_ATOMIC_TYPE *CompareAndSwap(YI_ATOMIC_TYPE *pCurrentValue, YI_ATOMIC_TYPE *pNewValue);
    YI_ATOMIC_TYPE *Load() const;
    void Store(YI_ATOMIC_TYPE *pPtr);
    static bool IsLockFree();
private:
#if defined(YI_GENERIC_ATOMIC)
    YI_ATOMIC_TYPE *m_pPtr;
    mutable CYIMutex m_mutex;
#else
    YI_ATOMIC_TYPE * volatile m_pPtr;
#endif
};

// Specialization for bool
template<>
class CYIAtomic<bool>
{
public:
    CYIAtomic(bool bValue = false);
    CYIAtomic(const CYIAtomic<bool> &rOther);
    bool operator==(bool bValue) const;
    bool operator!=(bool bValue) const;
    bool operator!() const;
    operator bool() const;
    CYIAtomic<bool> &operator=(const CYIAtomic<bool> &rOther);
    CYIAtomic<bool> &operator=(bool bValue);
    bool CompareAndSwap(bool bCurrentValue, bool bNewValue);
    bool Load() const;
    void Store(bool bValue);
    static bool IsLockFree();

private:
#if defined(YI_GENERIC_ATOMIC)
    uint32_t m_uValue;
    mutable CYIMutex m_mutex;
#else
    volatile uint32_t m_uValue;
#endif
};

#endif /* DOXY */

typedef CYIAtomic<bool> YI_ATOMIC_BOOL;

typedef CYIAtomic<uint8_t> YI_ATOMIC_UINT8;
typedef CYIAtomic<uint16_t> YI_ATOMIC_UINT16;
typedef CYIAtomic<uint32_t> YI_ATOMIC_UINT32;
typedef CYIAtomic<uint64_t> YI_ATOMIC_UINT64;

typedef CYIAtomic<int8_t> YI_ATOMIC_INT8;
typedef CYIAtomic<int16_t> YI_ATOMIC_INT16;
typedef CYIAtomic<int32_t> YI_ATOMIC_INT32;
typedef CYIAtomic<int64_t> YI_ATOMIC_INT64;

}
}

#include "deprecated/YiAtomic.inl"

#endif /* _YI_ATOMIC_H_ */