Atomic.h

#pragma once
 
#include "../FoundationBase.h"
 
#if defined(COGS_SINGLETHREADED)
 
#include <type_traits>
 
namespace Cogs {
 
  template<typename T> struct Atomic {
    constexpr Atomic() noexcept = default;
    constexpr Atomic(T t) noexcept : value(t) {}
    Atomic(const Atomic<T>&) = delete;
 
    Atomic& operator=(const Atomic<T>&) = delete;
 
    constexpr T operator=(const T value) noexcept {
      this->value = value;
      return value;
    }
 
    constexpr T exchange(T desired) noexcept
    {
      T current = value;
      value = desired;
      return current;
    }
 
    constexpr T load() const noexcept { return value; }
 
    void store(T desired) noexcept { value = desired; }
 
    constexpr T fetch_add(const T incr) noexcept { T temp = value; value += incr; return temp; }
 
    constexpr T fetch_sub(const T incr) noexcept { T temp = value; value -= incr; return temp; }
 
    template <typename Integer, typename = std::enable_if_t<std::is_integral<Integer>::value>>
    constexpr T fetch_and(Integer incr) noexcept { T temp = value; value &= incr; return temp; }
 
    template <typename Integer, typename = std::enable_if_t<std::is_integral<Integer>::value>>
    constexpr T fetch_or(Integer incr) noexcept { T temp = value; value |= incr; return temp; }
 
    template <typename Integer, typename = std::enable_if_t<std::is_integral<Integer>::value>>
    constexpr T fetch_xor(Integer incr) noexcept { T temp = value; value ^= incr; return temp; }
 
    // ---- Operators
 
    constexpr T operator++() noexcept { return ++value; }
 
    constexpr T operator--() noexcept { return --value; }
 
    constexpr T operator++(int) noexcept { T temp = value++; return temp; }
 
    constexpr T operator--(int) noexcept { T temp = value--; return temp; }
 
    constexpr Atomic& operator+=(T i) noexcept { value += i; return *this; }
 
    constexpr Atomic& operator-=(T i)  noexcept { value -= i; return *this; }
 
    // ---- Bitwice operators
 
    template <typename Integer, typename = std::enable_if_t<std::is_integral<Integer>::value>>
    constexpr T operator&=(Integer arg) noexcept { value &= arg; return value; }
 
    template <typename Integer, typename = std::enable_if_t<std::is_integral<Integer>::value>>
    constexpr T operator|=(Integer arg) noexcept { value |= arg; return value; }
 
    template <typename Integer, typename = std::enable_if_t<std::is_integral<Integer>::value>>
    constexpr T operator^=(Integer arg) noexcept { value ^= arg; return value; }
 
    constexpr operator T() const  noexcept { return value; }
 
  private:
    T value = {};
  };
 
}
 
#else
 
#include <atomic>
 
namespace Cogs {
 
  template<typename T> using Atomic = std::atomic<T>;
 
}
 
#endif