SDL3pp_atomic.h

#ifndef SDL3PP_ATOMIC_H_
#define SDL3PP_ATOMIC_H_
 
#include <SDL3/SDL_atomic.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
inline void MemoryBarrierRelease() { SDL_MemoryBarrierReleaseFunction(); }
 
inline void MemoryBarrierAcquire() { SDL_MemoryBarrierAcquireFunction(); }
 
#ifdef SDL3PP_DOC
 
#define SDL_CompilerBarrier() DoCompilerSpecificReadWriteBarrier()
 
#define SDL_MemoryBarrierRelease() SDL_MemoryBarrierReleaseFunction()
 
#define SDL_MemoryBarrierAcquire() SDL_MemoryBarrierAcquireFunction()
 
#define SDL_CPUPauseInstruction()                                              \
  DoACPUPauseInACompilerAndArchitectureSpecificWay
 
#endif
 
class AtomicInt
{
  SDL_AtomicInt m_value;
 
public:
  constexpr AtomicInt(int value = 0)
    : m_value(value)
  {
  }
 
  AtomicInt(const AtomicInt& value) = delete;
 
  AtomicInt& operator=(const AtomicInt& value) = delete;
 
  constexpr operator SDL_AtomicInt*() { return &m_value; }
 
  bool CompareAndSwap(int oldval, int newval)
  {
    return SDL_CompareAndSwapAtomicInt(&m_value, oldval, newval);
  }
 
  int Set(int v) { return SDL_SetAtomicInt(&m_value, v); }
 
  int Get() { return SDL_GetAtomicInt(&m_value); }
 
  int Add(int v) { return SDL_AddAtomicInt(&m_value, v); }
 
  bool AtomicIncRef() { return SDL_AtomicIncRef(&m_value); }
 
  bool AtomicDecRef() { return SDL_AtomicDecRef(&m_value); }
};
 
class AtomicU32
{
  SDL_AtomicU32 m_value;
 
public:
  constexpr AtomicU32(Uint32 value = 0)
    : m_value(value)
  {
  }
 
  AtomicU32(const AtomicU32& value) = delete;
 
  AtomicU32& operator=(const AtomicU32& value) = delete;
 
  constexpr operator SDL_AtomicU32*() { return &m_value; }
 
  bool CompareAndSwap(Uint32 oldval, Uint32 newval)
  {
    return SDL_CompareAndSwapAtomicU32(&m_value, oldval, newval);
  }
 
  Uint32 Set(Uint32 v) { return SDL_SetAtomicU32(&m_value, v); }
 
  Uint32 Get() { return SDL_GetAtomicU32(&m_value); }
};
 
template<class T>
class AtomicPointer
{
  T* m_value;
 
public:
  constexpr AtomicPointer(T* value = nullptr)
    : m_value(value)
  {
  }
 
  AtomicPointer(const AtomicPointer& value) = delete;
 
  AtomicPointer& operator=(const AtomicPointer& value) = delete;
 
  bool CompareAndSwap(T* oldval, T* newval)
  {
    return SDL_CompareAndSwapAtomicPointer(&m_value, oldval, newval);
  }
 
  T* Set(T* v) { return SDL_SetAtomicPointer(&m_value, v); }
 
  T* Get() { return SDL_GetAtomicPointer(&m_value); }
};
 
} // namespace SDL
 
#endif /* SDL3PP_ATOMIC_H_ */