SDL3pp_mutex.h

#ifndef SDL3PP_MUTEX_H_
#define SDL3PP_MUTEX_H_
 
#include <SDL3/SDL_mutex.h>
#include "SDL3pp_stdinc.h"
#include "SDL3pp_thread.h"
 
namespace SDL {
 
// Forward decl
struct MutexBase;
 
// Forward decl
struct MutexRef;
 
// Forward decl
struct Mutex;
 
// Forward decl
struct RWLockBase;
 
// Forward decl
struct RWLockRef;
 
// Forward decl
struct RWLock;
 
// Forward decl
struct SemaphoreBase;
 
// Forward decl
struct SemaphoreRef;
 
// Forward decl
struct Semaphore;
 
// Forward decl
struct ConditionBase;
 
// Forward decl
struct ConditionRef;
 
// Forward decl
struct Condition;
 
struct MutexBase : Resource<SDL_Mutex*>
{
  using Resource::Resource;
 
  MutexBase()
    : Resource(SDL_CreateMutex())
  {
  }
 
  void Lock() { SDL_LockMutex(get()); }
 
  void TryLock() { CheckError(SDL_TryLockMutex(get())); }
 
  void Unlock() { SDL_UnlockMutex(get()); }
};
 
struct MutexRef : MutexBase
{
  using MutexBase::MutexBase;
 
  constexpr MutexRef(const MutexRef& other)
    : MutexBase(other.get())
  {
  }
 
  constexpr MutexRef(MutexRef&& other)
    : MutexBase(other.release())
  {
  }
 
  constexpr ~MutexRef() = default;
 
  MutexRef& operator=(MutexRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Mutex* newResource = {})
  {
    SDL_DestroyMutex(release(newResource));
  }
};
 
struct Mutex : MutexRef
{
  using MutexRef::MutexRef;
 
  constexpr explicit Mutex(SDL_Mutex* resource = {})
    : MutexRef(resource)
  {
  }
 
  constexpr Mutex(const Mutex& other) = delete;
 
  constexpr Mutex(Mutex&& other) = default;
 
  ~Mutex() { reset(); }
 
  Mutex& operator=(Mutex other)
  {
    reset(other.release());
    return *this;
  }
};
 
struct RWLockBase : Resource<SDL_RWLock*>
{
  using Resource::Resource;
 
  RWLockBase()
    : Resource(SDL_CreateRWLock())
  {
  }
 
  void LockForReading() { SDL_LockRWLockForReading(get()); }
 
  void LockForWriting() { SDL_LockRWLockForWriting(get()); }
 
  void TryLockForReading() { CheckError(SDL_TryLockRWLockForReading(get())); }
 
  void TryLockForWriting() { CheckError(SDL_TryLockRWLockForWriting(get())); }
 
  void Unlock() { SDL_UnlockRWLock(get()); }
};
 
struct RWLockRef : RWLockBase
{
  using RWLockBase::RWLockBase;
 
  constexpr RWLockRef(const RWLockRef& other)
    : RWLockBase(other.get())
  {
  }
 
  constexpr RWLockRef(RWLockRef&& other)
    : RWLockBase(other.release())
  {
  }
 
  constexpr ~RWLockRef() = default;
 
  RWLockRef& operator=(RWLockRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_RWLock* newResource = {})
  {
    SDL_DestroyRWLock(release(newResource));
  }
};
 
struct RWLock : RWLockRef
{
  using RWLockRef::RWLockRef;
 
  constexpr explicit RWLock(SDL_RWLock* resource = {})
    : RWLockRef(resource)
  {
  }
 
  constexpr RWLock(const RWLock& other) = delete;
 
  constexpr RWLock(RWLock&& other) = default;
 
  ~RWLock() { reset(); }
 
  RWLock& operator=(RWLock other)
  {
    reset(other.release());
    return *this;
  }
};
 
struct SemaphoreBase : Resource<SDL_Semaphore*>
{
  using Resource::Resource;
 
  SemaphoreBase(Uint32 initial_value)
    : Resource(SDL_CreateSemaphore(initial_value))
  {
  }
 
  void Wait() { SDL_WaitSemaphore(get()); }
 
  bool TryWait() { return SDL_TryWaitSemaphore(get()); }
 
  bool WaitTimeout(std::chrono::milliseconds timeout)
  {
    return SDL_WaitSemaphoreTimeout(get(), timeout.count());
  }
 
  void Signal() { SDL_SignalSemaphore(get()); }
 
  Uint32 GetValue() const { return SDL_GetSemaphoreValue(get()); }
};
 
struct SemaphoreRef : SemaphoreBase
{
  using SemaphoreBase::SemaphoreBase;
 
  constexpr SemaphoreRef(const SemaphoreRef& other)
    : SemaphoreBase(other.get())
  {
  }
 
  constexpr SemaphoreRef(SemaphoreRef&& other)
    : SemaphoreBase(other.release())
  {
  }
 
  constexpr ~SemaphoreRef() = default;
 
  SemaphoreRef& operator=(SemaphoreRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Semaphore* newResource = {})
  {
    SDL_DestroySemaphore(release(newResource));
  }
};
 
struct Semaphore : SemaphoreRef
{
  using SemaphoreRef::SemaphoreRef;
 
  constexpr explicit Semaphore(SDL_Semaphore* resource = {})
    : SemaphoreRef(resource)
  {
  }
 
  constexpr Semaphore(const Semaphore& other) = delete;
 
  constexpr Semaphore(Semaphore&& other) = default;
 
  ~Semaphore() { reset(); }
 
  Semaphore& operator=(Semaphore other)
  {
    reset(other.release());
    return *this;
  }
};
 
struct ConditionBase : Resource<SDL_Condition*>
{
  using Resource::Resource;
 
  ConditionBase()
    : Resource(SDL_CreateCondition())
  {
  }
 
  void Signal() { SDL_SignalCondition(get()); }
 
  void Broadcast() { SDL_BroadcastCondition(get()); }
 
  void Wait(MutexBase& mutex) { SDL_WaitCondition(get(), mutex.get()); }
 
  bool WaitTimeout(MutexBase& mutex, std::chrono::milliseconds timeout)
  {
    return SDL_WaitConditionTimeout(get(), mutex.get(), timeout.count());
  }
};
 
struct ConditionRef : ConditionBase
{
  using ConditionBase::ConditionBase;
 
  constexpr ConditionRef(const ConditionRef& other)
    : ConditionBase(other.get())
  {
  }
 
  constexpr ConditionRef(ConditionRef&& other)
    : ConditionBase(other.release())
  {
  }
 
  constexpr ~ConditionRef() = default;
 
  ConditionRef& operator=(ConditionRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Condition* newResource = {})
  {
    SDL_DestroyCondition(release(newResource));
  }
};
 
struct Condition : ConditionRef
{
  using ConditionRef::ConditionRef;
 
  constexpr explicit Condition(SDL_Condition* resource = {})
    : ConditionRef(resource)
  {
  }
 
  constexpr Condition(const Condition& other) = delete;
 
  constexpr Condition(Condition&& other) = default;
 
  ~Condition() { reset(); }
 
  Condition& operator=(Condition other)
  {
    reset(other.release());
    return *this;
  }
};
 
using InitStatus = SDL_InitStatus;
 
constexpr InitStatus INIT_STATUS_UNINITIALIZED =
  SDL_INIT_STATUS_UNINITIALIZED; 
 
constexpr InitStatus INIT_STATUS_INITIALIZING =
  SDL_INIT_STATUS_INITIALIZING; 
 
constexpr InitStatus INIT_STATUS_INITIALIZED =
  SDL_INIT_STATUS_INITIALIZED; 
 
constexpr InitStatus INIT_STATUS_UNINITIALIZING =
  SDL_INIT_STATUS_UNINITIALIZING; 
 
struct InitState : SDL_InitState
{
  constexpr InitState()
    : SDL_InitState{0}
  {
  }
 
  bool ShouldInit() { return SDL_ShouldInit(this); }
 
  bool ShouldQuit() { return SDL_ShouldQuit(this); }
 
  void SetInitialized(bool initialized)
  {
    SDL_SetInitialized(this, initialized);
  }
};
 
 
} // namespace SDL
 
#endif /* SDL3PP_MUTEX_H_ */