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 MutexRef;
 
// Forward decl
struct Mutex;
 
using MutexShared = ResourceShared<Mutex>;
 
using MutexWeak = ResourceWeak<Mutex>;
 
// Forward decl
struct RWLockRef;
 
// Forward decl
struct RWLock;
 
using RWLockShared = ResourceShared<RWLock>;
 
using RWLockWeak = ResourceWeak<RWLock>;
 
// Forward decl
struct SemaphoreRef;
 
// Forward decl
struct Semaphore;
 
using SemaphoreShared = ResourceShared<Semaphore>;
 
using SemaphoreWeak = ResourceWeak<Semaphore>;
 
// Forward decl
struct ConditionRef;
 
// Forward decl
struct Condition;
 
using ConditionShared = ResourceShared<Condition>;
 
using ConditionWeak = ResourceWeak<Condition>;
 
struct MutexRef : Resource<SDL_Mutex*>
{
  using Resource::Resource;
 
  void Lock() { SDL_LockMutex(get()); }
 
  void TryLock() { CheckError(SDL_TryLockMutex(get())); }
 
  void Unlock() { SDL_UnlockMutex(get()); }
 
  static void reset(SDL_Mutex* resource) { SDL_DestroyMutex(resource); }
};
 
struct Mutex : ResourceUnique<MutexRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Mutex Create() { return Mutex(SDL_CreateMutex()); }
 
  void Destroy() { reset(); }
  MutexShared share();
 
};
 
 
inline MutexShared Mutex::share()
{
  return MutexShared(std::move(*this));
}
 
struct MutexUnsafe : ResourceUnsafe<MutexRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit MutexUnsafe(Mutex&& other)
    : MutexUnsafe(other.release())
  {
  }
};
 
struct RWLockRef : Resource<SDL_RWLock*>
{
  using Resource::Resource;
 
  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()); }
 
  static void reset(SDL_RWLock* resource) { SDL_DestroyRWLock(resource); }
};
 
struct RWLock : ResourceUnique<RWLockRef>
{
  using ResourceUnique::ResourceUnique;
 
  static RWLock Create() { return RWLock(SDL_CreateRWLock()); }
 
  void Destroy() { reset(); }
  RWLockShared share();
 
};
 
 
inline RWLockShared RWLock::share()
{
  return RWLockShared(std::move(*this));
}
 
struct RWLockUnsafe : ResourceUnsafe<RWLockRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit RWLockUnsafe(RWLock&& other)
    : RWLockUnsafe(other.release())
  {
  }
};
 
struct SemaphoreRef : Resource<SDL_Semaphore*>
{
  using Resource::Resource;
 
  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()); }
 
  static void reset(SDL_Semaphore* resource) { SDL_DestroySemaphore(resource); }
};
 
struct Semaphore : ResourceUnique<SemaphoreRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Semaphore Create(Uint32 initial_value)
  {
    return Semaphore(SDL_CreateSemaphore(initial_value));
  }
 
  void Destroy() { reset(); }
  SemaphoreShared share();
 
};
 
 
inline SemaphoreShared Semaphore::share()
{
  return SemaphoreShared(std::move(*this));
}
 
struct SemaphoreUnsafe : ResourceUnsafe<SemaphoreRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit SemaphoreUnsafe(Semaphore&& other)
    : SemaphoreUnsafe(other.release())
  {
  }
};
 
struct ConditionRef : Resource<SDL_Condition*>
{
  using Resource::Resource;
 
  void Signal() { SDL_SignalCondition(get()); }
 
  void Broadcast() { SDL_BroadcastCondition(get()); }
 
  void Wait(MutexRef mutex) { SDL_WaitCondition(get(), mutex); }
 
  bool WaitTimeout(MutexRef mutex, std::chrono::milliseconds timeout)
  {
    return SDL_WaitConditionTimeout(get(), mutex, timeout.count());
  }
 
  static void reset(SDL_Condition* resource) { SDL_DestroyCondition(resource); }
};
 
struct Condition : ResourceUnique<ConditionRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Condition Create() { return Condition(SDL_CreateCondition()); }
 
  void Destroy() { reset(); }
  ConditionShared share();
 
};
 
 
inline ConditionShared Condition::share()
{
  return ConditionShared(std::move(*this));
}
 
struct ConditionUnsafe : ResourceUnsafe<ConditionRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit ConditionUnsafe(Condition&& other)
    : ConditionUnsafe(other.release())
  {
  }
};
 
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_ */