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 Mutex;
 
using MutexRaw = SDL_Mutex*;
 
// Forward decl
struct MutexRef;
 
// Forward decl
struct RWLock;
 
using RWLockRaw = SDL_RWLock*;
 
// Forward decl
struct RWLockRef;
 
// Forward decl
struct Semaphore;
 
using SemaphoreRaw = SDL_Semaphore*;
 
// Forward decl
struct SemaphoreRef;
 
// Forward decl
struct Condition;
 
using ConditionRaw = SDL_Condition*;
 
// Forward decl
struct ConditionRef;
 
using InitStateRaw = SDL_InitState;
 
// Forward decl
struct InitState;
 
class Mutex
{
  MutexRaw m_resource = nullptr;
 
public:
  constexpr Mutex(std::nullptr_t) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Mutex(MutexRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Mutex(const Mutex& other) noexcept = delete;
 
  constexpr Mutex(Mutex&& other) noexcept
    : Mutex(other.release())
  {
  }
 
  constexpr Mutex(const MutexRef& other) = delete;
 
  constexpr Mutex(MutexRef&& other) = delete;
 
  Mutex();
 
  ~Mutex() { SDL_DestroyMutex(m_resource); }
 
  constexpr Mutex& operator=(Mutex&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Mutex& operator=(const Mutex& other) = delete;
 
  constexpr MutexRaw get() const noexcept { return m_resource; }
 
  constexpr MutexRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Mutex& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  void Lock();
 
  bool TryLock();
 
  void Unlock();
};
 
struct MutexRef : Mutex
{
  using Mutex::Mutex;
 
  constexpr MutexRef(MutexRaw resource) noexcept
    : Mutex(resource)
  {
  }
 
  constexpr MutexRef(const Mutex& resource) noexcept
    : Mutex(resource.get())
  {
  }
 
  constexpr MutexRef(Mutex&& resource) noexcept
    : Mutex(std::move(resource).release())
  {
  }
 
  constexpr MutexRef(const MutexRef& other) noexcept
    : Mutex(other.get())
  {
  }
 
  constexpr MutexRef(MutexRef&& other) noexcept
    : Mutex(other.get())
  {
  }
 
  ~MutexRef() { release(); }
 
  MutexRef& operator=(const MutexRef& other) noexcept
  {
    release();
    Mutex::operator=(Mutex(other.get()));
    return *this;
  }
 
  constexpr operator MutexRaw() const noexcept { return get(); }
};
 
inline Mutex CreateMutex() { return Mutex(); }
 
inline Mutex::Mutex()
  : m_resource(SDL_CreateMutex())
{
}
 
inline void LockMutex(MutexRef mutex) { SDL_LockMutex(mutex); }
 
inline void Mutex::Lock() { SDL::LockMutex(m_resource); }
 
inline bool TryLockMutex(MutexRef mutex) { return SDL_TryLockMutex(mutex); }
 
inline bool Mutex::TryLock() { return SDL::TryLockMutex(m_resource); }
 
inline void UnlockMutex(MutexRef mutex) { SDL_UnlockMutex(mutex); }
 
inline void Mutex::Unlock() { SDL::UnlockMutex(m_resource); }
 
inline void DestroyMutex(MutexRaw mutex) { SDL_DestroyMutex(mutex); }
 
inline void Mutex::Destroy() { DestroyMutex(release()); }
 
class RWLock
{
  RWLockRaw m_resource = nullptr;
 
public:
  constexpr RWLock(std::nullptr_t) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit RWLock(RWLockRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr RWLock(const RWLock& other) noexcept = delete;
 
  constexpr RWLock(RWLock&& other) noexcept
    : RWLock(other.release())
  {
  }
 
  constexpr RWLock(const RWLockRef& other) = delete;
 
  constexpr RWLock(RWLockRef&& other) = delete;
 
  RWLock();
 
  ~RWLock() { SDL_DestroyRWLock(m_resource); }
 
  constexpr RWLock& operator=(RWLock&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  RWLock& operator=(const RWLock& other) = delete;
 
  constexpr RWLockRaw get() const noexcept { return m_resource; }
 
  constexpr RWLockRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const RWLock& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  void LockForReading();
 
  void LockForWriting();
 
  bool TryLockForReading();
 
  bool TryLockForWriting();
 
  void Unlock();
};
 
struct RWLockRef : RWLock
{
  using RWLock::RWLock;
 
  constexpr RWLockRef(RWLockRaw resource) noexcept
    : RWLock(resource)
  {
  }
 
  constexpr RWLockRef(const RWLock& resource) noexcept
    : RWLock(resource.get())
  {
  }
 
  constexpr RWLockRef(RWLock&& resource) noexcept
    : RWLock(std::move(resource).release())
  {
  }
 
  constexpr RWLockRef(const RWLockRef& other) noexcept
    : RWLock(other.get())
  {
  }
 
  constexpr RWLockRef(RWLockRef&& other) noexcept
    : RWLock(other.get())
  {
  }
 
  ~RWLockRef() { release(); }
 
  RWLockRef& operator=(const RWLockRef& other) noexcept
  {
    release();
    RWLock::operator=(RWLock(other.get()));
    return *this;
  }
 
  constexpr operator RWLockRaw() const noexcept { return get(); }
};
 
inline RWLock CreateRWLock() { return RWLock(); }
 
inline RWLock::RWLock()
  : m_resource(SDL_CreateRWLock())
{
}
 
inline void LockRWLockForReading(RWLockRef rwlock)
{
  SDL_LockRWLockForReading(rwlock);
}
 
inline void RWLock::LockForReading() { SDL::LockRWLockForReading(m_resource); }
 
inline void LockRWLockForWriting(RWLockRef rwlock)
{
  SDL_LockRWLockForWriting(rwlock);
}
 
inline void RWLock::LockForWriting() { SDL::LockRWLockForWriting(m_resource); }
 
inline bool TryLockRWLockForReading(RWLockRef rwlock)
{
  return SDL_TryLockRWLockForReading(rwlock);
}
 
inline bool RWLock::TryLockForReading()
{
  return SDL::TryLockRWLockForReading(m_resource);
}
 
inline bool TryLockRWLockForWriting(RWLockRef rwlock)
{
  return SDL_TryLockRWLockForWriting(rwlock);
}
 
inline bool RWLock::TryLockForWriting()
{
  return SDL::TryLockRWLockForWriting(m_resource);
}
 
inline void UnlockRWLock(RWLockRef rwlock) { SDL_UnlockRWLock(rwlock); }
 
inline void RWLock::Unlock() { SDL::UnlockRWLock(m_resource); }
 
inline void DestroyRWLock(RWLockRaw rwlock) { SDL_DestroyRWLock(rwlock); }
 
inline void RWLock::Destroy() { DestroyRWLock(release()); }
 
class Semaphore
{
  SemaphoreRaw m_resource = nullptr;
 
public:
  constexpr Semaphore(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Semaphore(SemaphoreRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Semaphore(const Semaphore& other) noexcept = delete;
 
  constexpr Semaphore(Semaphore&& other) noexcept
    : Semaphore(other.release())
  {
  }
 
  constexpr Semaphore(const SemaphoreRef& other) = delete;
 
  constexpr Semaphore(SemaphoreRef&& other) = delete;
 
  Semaphore(Uint32 initial_value);
 
  ~Semaphore() { SDL_DestroySemaphore(m_resource); }
 
  constexpr Semaphore& operator=(Semaphore&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Semaphore& operator=(const Semaphore& other) = delete;
 
  constexpr SemaphoreRaw get() const noexcept { return m_resource; }
 
  constexpr SemaphoreRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Semaphore& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  void Wait();
 
  bool TryWait();
 
  bool WaitTimeout(std::chrono::milliseconds timeout);
 
  void Signal();
 
  Uint32 GetValue() const;
};
 
struct SemaphoreRef : Semaphore
{
  using Semaphore::Semaphore;
 
  constexpr SemaphoreRef(SemaphoreRaw resource) noexcept
    : Semaphore(resource)
  {
  }
 
  constexpr SemaphoreRef(const Semaphore& resource) noexcept
    : Semaphore(resource.get())
  {
  }
 
  constexpr SemaphoreRef(Semaphore&& resource) noexcept
    : Semaphore(std::move(resource).release())
  {
  }
 
  constexpr SemaphoreRef(const SemaphoreRef& other) noexcept
    : Semaphore(other.get())
  {
  }
 
  constexpr SemaphoreRef(SemaphoreRef&& other) noexcept
    : Semaphore(other.get())
  {
  }
 
  ~SemaphoreRef() { release(); }
 
  SemaphoreRef& operator=(const SemaphoreRef& other) noexcept
  {
    release();
    Semaphore::operator=(Semaphore(other.get()));
    return *this;
  }
 
  constexpr operator SemaphoreRaw() const noexcept { return get(); }
};
 
inline Semaphore CreateSemaphore(Uint32 initial_value)
{
  return Semaphore(initial_value);
}
 
inline Semaphore::Semaphore(Uint32 initial_value)
  : m_resource(SDL_CreateSemaphore(initial_value))
{
}
 
inline void DestroySemaphore(SemaphoreRaw sem) { SDL_DestroySemaphore(sem); }
 
inline void Semaphore::Destroy() { DestroySemaphore(release()); }
 
inline void WaitSemaphore(SemaphoreRef sem) { SDL_WaitSemaphore(sem); }
 
inline void Semaphore::Wait() { SDL::WaitSemaphore(m_resource); }
 
inline bool TryWaitSemaphore(SemaphoreRef sem)
{
  return SDL_TryWaitSemaphore(sem);
}
 
inline bool Semaphore::TryWait() { return SDL::TryWaitSemaphore(m_resource); }
 
inline bool WaitSemaphoreTimeout(SemaphoreRef sem,
                                 std::chrono::milliseconds timeout)
{
  return SDL_WaitSemaphoreTimeout(sem, narrowS32(timeout.count()));
}
 
inline bool Semaphore::WaitTimeout(std::chrono::milliseconds timeout)
{
  return SDL::WaitSemaphoreTimeout(m_resource, timeout);
}
 
inline void SignalSemaphore(SemaphoreRef sem) { SDL_SignalSemaphore(sem); }
 
inline void Semaphore::Signal() { SDL::SignalSemaphore(m_resource); }
 
inline Uint32 GetSemaphoreValue(SemaphoreRef sem)
{
  return SDL_GetSemaphoreValue(sem);
}
 
inline Uint32 Semaphore::GetValue() const
{
  return SDL::GetSemaphoreValue(m_resource);
}
 
class Condition
{
  ConditionRaw m_resource = nullptr;
 
public:
  constexpr Condition(std::nullptr_t) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Condition(ConditionRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Condition(const Condition& other) noexcept = delete;
 
  constexpr Condition(Condition&& other) noexcept
    : Condition(other.release())
  {
  }
 
  constexpr Condition(const ConditionRef& other) = delete;
 
  constexpr Condition(ConditionRef&& other) = delete;
 
  Condition();
 
  ~Condition() { SDL_DestroyCondition(m_resource); }
 
  constexpr Condition& operator=(Condition&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Condition& operator=(const Condition& other) = delete;
 
  constexpr ConditionRaw get() const noexcept { return m_resource; }
 
  constexpr ConditionRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Condition& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  void Signal();
 
  void Broadcast();
 
  void Wait(MutexRef mutex);
 
  bool WaitTimeout(MutexRef mutex, std::chrono::milliseconds timeout);
};
 
struct ConditionRef : Condition
{
  using Condition::Condition;
 
  constexpr ConditionRef(ConditionRaw resource) noexcept
    : Condition(resource)
  {
  }
 
  constexpr ConditionRef(const Condition& resource) noexcept
    : Condition(resource.get())
  {
  }
 
  constexpr ConditionRef(Condition&& resource) noexcept
    : Condition(std::move(resource).release())
  {
  }
 
  constexpr ConditionRef(const ConditionRef& other) noexcept
    : Condition(other.get())
  {
  }
 
  constexpr ConditionRef(ConditionRef&& other) noexcept
    : Condition(other.get())
  {
  }
 
  ~ConditionRef() { release(); }
 
  ConditionRef& operator=(const ConditionRef& other) noexcept
  {
    release();
    Condition::operator=(Condition(other.get()));
    return *this;
  }
 
  constexpr operator ConditionRaw() const noexcept { return get(); }
};
 
inline Condition CreateCondition() { return Condition(); }
 
inline Condition::Condition()
  : m_resource(SDL_CreateCondition())
{
}
 
inline void DestroyCondition(ConditionRaw cond) { SDL_DestroyCondition(cond); }
 
inline void Condition::Destroy() { DestroyCondition(release()); }
 
inline void SignalCondition(ConditionRef cond) { SDL_SignalCondition(cond); }
 
inline void Condition::Signal() { SDL::SignalCondition(m_resource); }
 
inline void BroadcastCondition(ConditionRef cond)
{
  SDL_BroadcastCondition(cond);
}
 
inline void Condition::Broadcast() { SDL::BroadcastCondition(m_resource); }
 
inline void WaitCondition(ConditionRef cond, MutexRef mutex)
{
  SDL_WaitCondition(cond, mutex);
}
 
inline void Condition::Wait(MutexRef mutex)
{
  SDL::WaitCondition(m_resource, mutex);
}
 
inline bool WaitConditionTimeout(ConditionRef cond,
                                 MutexRef mutex,
                                 std::chrono::milliseconds timeout)
{
  return SDL_WaitConditionTimeout(cond, mutex, narrowS32(timeout.count()));
}
 
inline bool Condition::WaitTimeout(MutexRef mutex,
                                   std::chrono::milliseconds timeout)
{
  return SDL::WaitConditionTimeout(m_resource, 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_ */