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 Mutex;

using MutexRaw = SDL_Mutex*;

using MutexRef = ResourceRefT<MutexBase>;
 
// Forward decl
struct RWLockBase;
 
// Forward decl
struct RWLock;

using RWLockRaw = SDL_RWLock*;

using RWLockRef = ResourceRefT<RWLockBase>;
 
// Forward decl
struct SemaphoreBase;
 
// Forward decl
struct Semaphore;

using SemaphoreRaw = SDL_Semaphore*;

using SemaphoreRef = ResourceRefT<SemaphoreBase>;
 
// Forward decl
struct ConditionBase;
 
// Forward decl
struct Condition;

using ConditionRaw = SDL_Condition*;

using ConditionRef = ResourceRefT<ConditionBase>;

using InitStateRaw = SDL_InitState;
 
// Forward decl
struct InitState;

struct MutexBase : ResourceBaseT<MutexRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  void Lock();

  bool TryLock();

  void Unlock();
};

struct Mutex : MutexBase
{
  using MutexBase::MutexBase;

  constexpr explicit Mutex(MutexRaw resource) noexcept
    : MutexBase(resource)
  {
  }

  constexpr Mutex(Mutex&& other) noexcept
    : Mutex(other.release())
  {
  }

  Mutex();

  ~Mutex() { SDL_DestroyMutex(get()); }

  constexpr Mutex& operator=(Mutex&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline Mutex CreateMutex() { return Mutex(); }
 
inline Mutex::Mutex()
  : Mutex(SDL_CreateMutex())
{
}

inline void LockMutex(MutexRef mutex) { SDL_LockMutex(mutex); }
 
inline void MutexBase::Lock() { SDL::LockMutex(get()); }

inline bool TryLockMutex(MutexRef mutex) { return SDL_TryLockMutex(mutex); }
 
inline bool MutexBase::TryLock() { return SDL::TryLockMutex(get()); }

inline void UnlockMutex(MutexRef mutex) { SDL_UnlockMutex(mutex); }
 
inline void MutexBase::Unlock() { SDL::UnlockMutex(get()); }

inline void DestroyMutex(MutexRaw mutex) { SDL_DestroyMutex(mutex); }
 
inline void MutexBase::Destroy() { DestroyMutex(release()); }

struct RWLockBase : ResourceBaseT<RWLockRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  void LockForReading();

  void LockForWriting();

  bool TryLockForReading();

  bool TryLockForWriting();

  void Unlock();
};

struct RWLock : RWLockBase
{
  using RWLockBase::RWLockBase;

  constexpr explicit RWLock(RWLockRaw resource) noexcept
    : RWLockBase(resource)
  {
  }

  constexpr RWLock(RWLock&& other) noexcept
    : RWLock(other.release())
  {
  }

  RWLock();

  ~RWLock() { SDL_DestroyRWLock(get()); }

  constexpr RWLock& operator=(RWLock&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline RWLock CreateRWLock() { return RWLock(); }
 
inline RWLock::RWLock()
  : RWLock(SDL_CreateRWLock())
{
}

inline void LockRWLockForReading(RWLockRef rwlock)
{
  SDL_LockRWLockForReading(rwlock);
}
 
inline void RWLockBase::LockForReading() { SDL::LockRWLockForReading(get()); }

inline void LockRWLockForWriting(RWLockRef rwlock)
{
  SDL_LockRWLockForWriting(rwlock);
}
 
inline void RWLockBase::LockForWriting() { SDL::LockRWLockForWriting(get()); }

inline bool TryLockRWLockForReading(RWLockRef rwlock)
{
  return SDL_TryLockRWLockForReading(rwlock);
}
 
inline bool RWLockBase::TryLockForReading()
{
  return SDL::TryLockRWLockForReading(get());
}

inline bool TryLockRWLockForWriting(RWLockRef rwlock)
{
  return SDL_TryLockRWLockForWriting(rwlock);
}
 
inline bool RWLockBase::TryLockForWriting()
{
  return SDL::TryLockRWLockForWriting(get());
}

inline void UnlockRWLock(RWLockRef rwlock) { SDL_UnlockRWLock(rwlock); }
 
inline void RWLockBase::Unlock() { SDL::UnlockRWLock(get()); }

inline void DestroyRWLock(RWLockRaw rwlock) { SDL_DestroyRWLock(rwlock); }
 
inline void RWLockBase::Destroy() { DestroyRWLock(release()); }

struct SemaphoreBase : ResourceBaseT<SemaphoreRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  void Wait();

  bool TryWait();

  bool WaitTimeout(Milliseconds timeout);

  void Signal();

  Uint32 GetValue() const;
};

struct Semaphore : SemaphoreBase
{
  using SemaphoreBase::SemaphoreBase;

  constexpr explicit Semaphore(SemaphoreRaw resource) noexcept
    : SemaphoreBase(resource)
  {
  }

  constexpr Semaphore(Semaphore&& other) noexcept
    : Semaphore(other.release())
  {
  }

  Semaphore(Uint32 initial_value);

  ~Semaphore() { SDL_DestroySemaphore(get()); }

  constexpr Semaphore& operator=(Semaphore&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline Semaphore CreateSemaphore(Uint32 initial_value)
{
  return Semaphore(initial_value);
}
 
inline Semaphore::Semaphore(Uint32 initial_value)
  : Semaphore(SDL_CreateSemaphore(initial_value))
{
}

inline void DestroySemaphore(SemaphoreRaw sem) { SDL_DestroySemaphore(sem); }
 
inline void SemaphoreBase::Destroy() { DestroySemaphore(release()); }

inline void WaitSemaphore(SemaphoreRef sem) { SDL_WaitSemaphore(sem); }
 
inline void SemaphoreBase::Wait() { SDL::WaitSemaphore(get()); }

inline bool TryWaitSemaphore(SemaphoreRef sem)
{
  return SDL_TryWaitSemaphore(sem);
}
 
inline bool SemaphoreBase::TryWait() { return SDL::TryWaitSemaphore(get()); }

inline bool WaitSemaphoreTimeout(SemaphoreRef sem, Milliseconds timeout)
{
  return SDL_WaitSemaphoreTimeout(sem, narrowS32(timeout.count()));
}
 
inline bool SemaphoreBase::WaitTimeout(Milliseconds timeout)
{
  return SDL::WaitSemaphoreTimeout(get(), timeout);
}

inline void SignalSemaphore(SemaphoreRef sem) { SDL_SignalSemaphore(sem); }
 
inline void SemaphoreBase::Signal() { SDL::SignalSemaphore(get()); }

inline Uint32 GetSemaphoreValue(SemaphoreRef sem)
{
  return SDL_GetSemaphoreValue(sem);
}
 
inline Uint32 SemaphoreBase::GetValue() const
{
  return SDL::GetSemaphoreValue(get());
}

struct ConditionBase : ResourceBaseT<ConditionRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  void Signal();

  void Broadcast();

  void Wait(MutexRef mutex);

  bool WaitTimeout(MutexRef mutex, Milliseconds timeout);
};

struct Condition : ConditionBase
{
  using ConditionBase::ConditionBase;

  constexpr explicit Condition(ConditionRaw resource) noexcept
    : ConditionBase(resource)
  {
  }

  constexpr Condition(Condition&& other) noexcept
    : Condition(other.release())
  {
  }

  Condition();

  ~Condition() { SDL_DestroyCondition(get()); }

  constexpr Condition& operator=(Condition&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline Condition CreateCondition() { return Condition(); }
 
inline Condition::Condition()
  : Condition(SDL_CreateCondition())
{
}

inline void DestroyCondition(ConditionRaw cond) { SDL_DestroyCondition(cond); }
 
inline void ConditionBase::Destroy() { DestroyCondition(release()); }

inline void SignalCondition(ConditionRef cond) { SDL_SignalCondition(cond); }
 
inline void ConditionBase::Signal() { SDL::SignalCondition(get()); }

inline void BroadcastCondition(ConditionRef cond)
{
  SDL_BroadcastCondition(cond);
}
 
inline void ConditionBase::Broadcast() { SDL::BroadcastCondition(get()); }

inline void WaitCondition(ConditionRef cond, MutexRef mutex)
{
  SDL_WaitCondition(cond, mutex);
}
 
inline void ConditionBase::Wait(MutexRef mutex)
{
  SDL::WaitCondition(get(), mutex);
}

inline bool WaitConditionTimeout(ConditionRef cond,
                                 MutexRef mutex,
                                 Milliseconds timeout)
{
  return SDL_WaitConditionTimeout(cond, mutex, narrowS32(timeout.count()));
}
 
inline bool ConditionBase::WaitTimeout(MutexRef mutex, Milliseconds timeout)
{
  return SDL::WaitConditionTimeout(get(), mutex, timeout);
}

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 : InitStateRaw
{
  constexpr InitState()
    : SDL_InitState{}
  {
  }

  bool ShouldInit();

  bool ShouldQuit();

  void SetInitialized(bool initialized);
};

inline bool ShouldInit(InitStateRaw* state) { return SDL_ShouldInit(state); }
 
inline bool InitState::ShouldInit() { return SDL::ShouldInit(this); }

inline bool ShouldQuit(InitStateRaw* state) { return SDL_ShouldQuit(state); }
 
inline bool InitState::ShouldQuit() { return SDL::ShouldQuit(this); }

inline void SetInitialized(InitStateRaw* state, bool initialized)
{
  SDL_SetInitialized(state, initialized);
}
 
inline void InitState::SetInitialized(bool initialized)
{
  SDL::SetInitialized(this, initialized);
}

 
} // namespace SDL
 
#endif /* SDL3PP_MUTEX_H_ */