interlocked.h

 
#pragma once
#include <atomic>
#include <type_traits>
#include "system/threading/thread.h"
 
namespace System { namespace Threading {
 
class Interlocked
{
    template <typename T>
    static constexpr bool IsSupportedInt = std::is_same<T, int32_t>::value || std::is_same<T, uint32_t>::value ||
                                           std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value;
 
public:
    static ASPOSECPP_SHARED_API int32_t Increment(int32_t& location);
    static ASPOSECPP_SHARED_API int64_t Increment(int64_t& location);
    static ASPOSECPP_SHARED_API int32_t Decrement(int32_t& location);
    static ASPOSECPP_SHARED_API int64_t Decrement(int64_t& location);
 
    static ASPOSECPP_SHARED_API int32_t Add(int32_t& location1, int32_t value);
    static ASPOSECPP_SHARED_API int64_t Add(int64_t& location1, int64_t value);
 
    static ASPOSECPP_SHARED_API int64_t Read(int64_t& location1);
 
    static ASPOSECPP_SHARED_API int32_t ExchangeAdd(int32_t& location1, int32_t value);
    static ASPOSECPP_SHARED_API int64_t ExchangeAdd(int64_t& location1, int64_t value);
 
    template <typename T>
    static typename std::enable_if<IsSupportedInt<T>, T>::type Exchange(T& location1, T value)
    {
        return std::atomic_exchange((std::atomic<T>*)&location1, value);
    }
    template <typename T>
    static typename std::enable_if<!IsSupportedInt<T>, T>::type Exchange(T& location1, T value)
    {
        throw NotImplementedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    template <typename T>
    static typename std::enable_if<IsSupportedInt<T>, T>::type CompareExchange(T& location1, T value, T comparand)
    {
        auto orig = location1;
        std::atomic_compare_exchange_strong((std::atomic<T>*)&location1, &comparand, value);
        return orig;
    }
    template <typename T>
    static typename std::enable_if<!IsSupportedInt<T>, T>::type CompareExchange(T& location1, T value, T comparand)
    {
        throw NotImplementedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    static ASPOSECPP_SHARED_API int32_t CompareExchange(int32_t& location1, int32_t value, int32_t comparand,
                                                        bool& succeeded);
};
 
}} // namespace System::Threading