AtomicInteger.h

#pragma once
 
#include <Foundation/Types/TypeTraits.h>
 
#include <Foundation/Threading/AtomicUtils.h>
 
template <int T>
struct plAtomicStorageType
{
};
 
template <>
struct plAtomicStorageType<1>
{
  using Type = plInt32;
};
 
template <>
struct plAtomicStorageType<2>
{
  using Type = plInt32;
};
 
template <>
struct plAtomicStorageType<4>
{
  using Type = plInt32;
};
 
template <>
struct plAtomicStorageType<8>
{
  using Type = plInt64;
};
 
template <typename T>
class plAtomicInteger
{
  using UnderlyingType = typename plAtomicStorageType<sizeof(T)>::Type;
 
public:
  PL_DECLARE_POD_TYPE();
 
  plAtomicInteger(); // [tested]
 
  plAtomicInteger(const T value); // [tested]
 
  plAtomicInteger(const plAtomicInteger<T>& value); // [tested]
 
  plAtomicInteger& operator=(T value); // [tested]
 
  plAtomicInteger& operator=(const plAtomicInteger& value); // [tested]
 
  T Increment(); // [tested]
 
  T Decrement(); // [tested]
 
  T PostIncrement(); // [tested]
 
  T PostDecrement();  // [tested]
 
  void Add(T x);      // [tested]
  void Subtract(T x); // [tested]
 
  void And(T x);      // [tested]
  void Or(T x);       // [tested]
  void Xor(T x);      // [tested]
 
  void Min(T x);      // [tested]
  void Max(T x);      // [tested]
 
  T Set(T x); // [tested]
 
  bool TestAndSet(T expected, T x); // [tested]
 
  T CompareAndSwap(T expected, T x); // [tested]
 
  operator T() const;                // [tested]
 
private:
  UnderlyingType m_Value;
};
 
class plAtomicBool
{
public:
  plAtomicBool(); // [tested]
  ~plAtomicBool();
 
  plAtomicBool(bool value); // [tested]
 
  plAtomicBool(const plAtomicBool& rhs);
 
  bool Set(bool value); // [tested]
 
  void operator=(bool value); // [tested]
 
  void operator=(const plAtomicBool& rhs);
 
  operator bool() const; // [tested]
 
  bool TestAndSet(bool bExpected, bool bNewValue);
 
private:
  plAtomicInteger<plInt32> m_iAtomicInt;
};
 
// Include inline file
#include <Foundation/Threading/Implementation/AtomicInteger_inl.h>
 
using plAtomicInteger32 = plAtomicInteger<plInt32>; // [tested]
using plAtomicInteger64 = plAtomicInteger<plInt64>; // [tested]
static_assert(sizeof(plAtomicInteger32) == sizeof(plInt32));
static_assert(sizeof(plAtomicInteger64) == sizeof(plInt64));