SDL3pp_atomic.h

#ifndef SDL3PP_ATOMIC_H_
#define SDL3PP_ATOMIC_H_
 
#include <SDL3/SDL_atomic.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
using AtomicIntRaw = SDL_AtomicInt;
 
// Forward decl
struct AtomicInt;
 
using AtomicU32Raw = SDL_AtomicU32;
 
// Forward decl
struct AtomicU32;
 
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 // SDL3PP_DOC
 
struct AtomicInt : AtomicIntRaw
{
  constexpr AtomicInt(int value)
    : AtomicIntRaw(value)
  {
  }
 
  AtomicInt(const AtomicInt& value) = delete;
 
  AtomicInt& operator=(const AtomicInt& value) = delete;
 
  bool CompareAndSwap(int oldval, int newval);
 
  int Set(int v);
 
  int Get();
 
  int Add(int v);
 
  bool AtomicIncRef();
 
  bool AtomicDecRef();
};
 
inline bool CompareAndSwapAtomicInt(AtomicIntRaw* a, int oldval, int newval)
{
  return SDL_CompareAndSwapAtomicInt(a, oldval, newval);
}
 
inline bool AtomicInt::CompareAndSwap(int oldval, int newval)
{
  return SDL::CompareAndSwapAtomicInt(this, oldval, newval);
}
 
inline int SetAtomicInt(AtomicIntRaw* a, int v)
{
  return SDL_SetAtomicInt(a, v);
}
 
inline int AtomicInt::Set(int v) { return SDL::SetAtomicInt(this, v); }
 
inline int GetAtomicInt(AtomicIntRaw* a) { return SDL_GetAtomicInt(a); }
 
inline int AtomicInt::Get() { return SDL::GetAtomicInt(this); }
 
inline int AddAtomicInt(AtomicIntRaw* a, int v)
{
  return SDL_AddAtomicInt(a, v);
}
 
inline int AtomicInt::Add(int v) { return SDL::AddAtomicInt(this, v); }
 
inline bool AtomicIncRef(AtomicIntRaw* a) { return SDL_AtomicIncRef(a); }
 
inline bool AtomicInt::AtomicIncRef() { return SDL::AtomicIncRef(this); }
 
inline bool AtomicDecRef(AtomicIntRaw* a) { return SDL_AtomicDecRef(a); }
 
inline bool AtomicInt::AtomicDecRef() { return SDL::AtomicDecRef(this); }
 
struct AtomicU32 : AtomicU32Raw
{
  constexpr AtomicU32(Uint32 value)
    : AtomicU32Raw(value)
  {
  }
 
  AtomicU32(const AtomicU32& value) = delete;
 
  AtomicU32& operator=(const AtomicU32& value) = delete;
 
  bool CompareAndSwap(Uint32 oldval, Uint32 newval);
 
  Uint32 Set(Uint32 v);
 
  Uint32 Get();
};
 
template<class T>
class AtomicPointer
{
  T* m_value;
 
public:
  constexpr AtomicPointer(T* value)
    : m_value(value)
  {
  }
 
  AtomicPointer(const AtomicPointer& value) = delete;
 
  AtomicPointer& operator=(const AtomicPointer& value) = delete;
 
  bool CompareAndSwap(T* oldval, T* newval);
 
  T* Set(T* v);
 
  T* Get();
};
 
inline bool CompareAndSwapAtomicU32(AtomicU32Raw* a,
                                    Uint32 oldval,
                                    Uint32 newval)
{
  return SDL_CompareAndSwapAtomicU32(a, oldval, newval);
}
 
inline bool AtomicU32::CompareAndSwap(Uint32 oldval, Uint32 newval)
{
  return SDL::CompareAndSwapAtomicU32(this, oldval, newval);
}
 
inline Uint32 SetAtomicU32(AtomicU32Raw* a, Uint32 v)
{
  return SDL_SetAtomicU32(a, v);
}
 
inline Uint32 AtomicU32::Set(Uint32 v) { return SDL::SetAtomicU32(this, v); }
 
inline Uint32 GetAtomicU32(AtomicU32Raw* a) { return SDL_GetAtomicU32(a); }
 
inline Uint32 AtomicU32::Get() { return SDL::GetAtomicU32(this); }
 
template<class T>
inline bool AtomicPointer<T>::CompareAndSwap(T* oldval, T* newval)
{
  return SDL_CompareAndSwapAtomicPointer(&m_value, oldval, newval);
}
 
template<class T>
inline T* AtomicPointer<T>::Set(T* v)
{
  return SDL_SetAtomicPointer(&m_value, v);
}
 
template<class T>
inline T* AtomicPointer<T>::Get()
{
  return SDL_GetAtomicPointer(&m_value);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_ATOMIC_H_ */