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