BeAtomic.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once


#include "Bentley.h"


#if !defined (_MANAGED) && (_MSC_VER > 1600)

#if !defined (BEATOMIC_TEMPLATED)
#define BEATOMIC_TEMPLATED

#include <atomic>

template<class T> struct BeAtomic : std::atomic<T>
{
    explicit BeAtomic(T val=T(0)) : std::atomic<T>(val){}
    T IncrementAtomicPre(std::memory_order order=std::memory_order_seq_cst) {return this->fetch_add(1, order)+1;}
    T DecrementAtomicPost(std::memory_order order=std::memory_order_seq_cst) {return this->fetch_sub(1, order);}
};
#endif // BEATOMIC_TEMPLATED

#else

    extern "C" long __cdecl _InterlockedIncrement (long volatile*);
    extern "C" long __cdecl _InterlockedDecrement (long volatile*);
    extern "C" long __cdecl _InterlockedExchange (long volatile*, long);
    extern "C" long __cdecl _InterlockedExchangeAdd(long volatile*, long);
    extern "C" void* __cdecl _InterlockedExchangePointer (void* volatile*, void*);
    extern "C" long __cdecl _InterlockedCompareExchange (long volatile *, long, long);
    extern "C" void* __cdecl _InterlockedCompareExchangePointer (void* volatile*, void*, void*);

    BEGIN_BENTLEY_NAMESPACE

    #define BE_ATOMIC_IMPL(UTYPE,TYPE_SUFFIX,CAST_TYPE)\
        private:\
            UTYPE volatile m_value;\
            BeAtomic& operator= (BeAtomic const&);\
            BeAtomic (BeAtomic const&);\
        public:\
            BeAtomic() : m_value(0) {;}\
            BeAtomic (UInt32 v) : m_value(v) {;}\
            UTYPE operator++()    volatile {return _InterlockedIncrement ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value);}\
            UTYPE operator++(int) volatile {return _InterlockedIncrement ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value)-1;}\
            UTYPE operator--()    volatile {return _InterlockedDecrement ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value);}\
            UTYPE operator--(int) volatile {return _InterlockedDecrement ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value)+1;}\
            UTYPE load() const {return _InterlockedCompareExchange ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value,0,0);}\
            void store (UTYPE v) const {_InterlockedExchange ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value,v);} \
            UTYPE IncrementAtomicPre () {return _InterlockedIncrement ## TYPE_SUFFIX ((CAST_TYPE volatile*)&m_value);}

    /*=================================================================================**/
    template <typename T>
    struct BeAtomic
        {
        };

    template <>
    struct BeAtomic<UInt32>
        {
        BE_ATOMIC_IMPL(UInt32,,long)
        };

    template <>
    struct BeAtomic<int>
        {
        BE_ATOMIC_IMPL(int,,long)
        };

    END_BENTLEY_NAMESPACE

#endif  // _MANAGED