SDL3pp_thread.h

#ifndef SDL3PP_THREAD_H_
#define SDL3PP_THREAD_H_
 
#include <SDL3/SDL_thread.h>
#include "SDL3pp_atomic.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct Thread;
 
using ThreadRaw = SDL_Thread*;
 
// Forward decl
struct ThreadRef;
 
struct ThreadParam
{
  ThreadRaw value; 
 
  constexpr ThreadParam(ThreadRaw value)
    : value(value)
  {
  }
 
  constexpr ThreadParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const ThreadParam& other) const = default;
 
  constexpr operator ThreadRaw() const { return value; }
};
 
using ThreadPriority = SDL_ThreadPriority;
 
constexpr ThreadPriority THREAD_PRIORITY_LOW = SDL_THREAD_PRIORITY_LOW; 
 
constexpr ThreadPriority THREAD_PRIORITY_NORMAL =
  SDL_THREAD_PRIORITY_NORMAL; 
 
constexpr ThreadPriority THREAD_PRIORITY_HIGH =
  SDL_THREAD_PRIORITY_HIGH; 
 
constexpr ThreadPriority THREAD_PRIORITY_TIME_CRITICAL =
  SDL_THREAD_PRIORITY_TIME_CRITICAL; 
 
using ThreadState = SDL_ThreadState;
 
constexpr ThreadState THREAD_UNKNOWN =
  SDL_THREAD_UNKNOWN; 
 
constexpr ThreadState THREAD_ALIVE =
  SDL_THREAD_ALIVE; 
 
constexpr ThreadState THREAD_DETACHED =
  SDL_THREAD_DETACHED; 
 
constexpr ThreadState THREAD_COMPLETE = SDL_THREAD_COMPLETE;
 
using ThreadID = SDL_ThreadID;
 
using ThreadFunction = int(SDLCALL*)(void* data);
 
using ThreadCB = std::function<int()>;
 
using TLSDestructorCallback = void(SDLCALL*)(void* value);
 
class Thread
{
  ThreadRaw m_resource = nullptr;
 
public:
  constexpr Thread(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Thread(const ThreadRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Thread(const Thread& other) = delete;
 
  constexpr Thread(Thread&& other) noexcept
    : Thread(other.release())
  {
  }
 
  constexpr Thread(const ThreadRef& other) = delete;
 
  constexpr Thread(ThreadRef&& other) = delete;
 
  Thread(ThreadCB fn, StringParam name) {}
 
  Thread(ThreadFunction fn, StringParam name, void* data)
    : m_resource(CheckError(SDL_CreateThread(fn, name, data)))
  {
  }
 
  Thread(PropertiesParam props)
    : m_resource(CheckError(SDL_CreateThreadWithProperties(props)))
  {
  }
 
  ~Thread() { SDL_DetachThread(m_resource); }
 
  constexpr Thread& operator=(Thread&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Thread& operator=(const Thread& other) noexcept = default;
 
public:
  constexpr ThreadRaw get() const noexcept { return m_resource; }
 
  constexpr ThreadRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Thread& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator ThreadParam() const noexcept { return {m_resource}; }
 
  void Detach();
 
  const char* GetName() const;
 
  ThreadID GetID() const;
 
  static void SetCurrentPriority(ThreadPriority priority);
 
  void Wait(int* status);
 
  ThreadState GetState() const;
};
 
struct ThreadRef : Thread
{
  using Thread::Thread;
 
  ThreadRef(ThreadParam resource) noexcept
    : Thread(resource.value)
  {
  }
 
  ThreadRef(ThreadRaw resource) noexcept
    : Thread(resource)
  {
  }
 
  ThreadRef(const ThreadRef& other) noexcept
    : Thread(other.get())
  {
  }
 
  ~ThreadRef() { release(); }
};
 
using TLSID = AtomicInt;
 
inline Thread CreateThread(ThreadFunction fn, StringParam name, void* data)
{
  return Thread(fn, std::move(name), data);
}
 
inline Thread CreateThreadWithProperties(PropertiesParam props)
{
  return Thread(props);
}
 
namespace prop::thread {
 
constexpr auto CREATE_ENTRY_FUNCTION_POINTER =
  SDL_PROP_THREAD_CREATE_ENTRY_FUNCTION_POINTER;
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_THREAD_CREATE_NAME_STRING;
 
constexpr auto CREATE_USERDATA_POINTER =
  SDL_PROP_THREAD_CREATE_USERDATA_POINTER;
 
constexpr auto CREATE_STACKSIZE_NUMBER =
  SDL_PROP_THREAD_CREATE_STACKSIZE_NUMBER;
 
} // namespace prop::thread
 
inline const char* GetThreadName(ThreadParam thread)
{
  return SDL_GetThreadName(thread);
}
 
inline const char* Thread::GetName() const
{
  return SDL::GetThreadName(m_resource);
}
 
inline ThreadID GetCurrentThreadID() { return SDL_GetCurrentThreadID(); }
 
inline ThreadID GetThreadID(ThreadParam thread)
{
  return SDL_GetThreadID(thread);
}
 
inline ThreadID Thread::GetID() const { return SDL::GetThreadID(m_resource); }
 
inline void SetCurrentThreadPriority(ThreadPriority priority)
{
  CheckError(SDL_SetCurrentThreadPriority(priority));
}
 
inline void Thread::SetCurrentPriority(ThreadPriority priority)
{
  SDL::SetCurrentThreadPriority(priority);
}
 
inline void WaitThread(ThreadParam thread, int* status)
{
  SDL_WaitThread(thread, status);
}
 
inline void Thread::Wait(int* status) { SDL::WaitThread(m_resource, status); }
 
inline ThreadState GetThreadState(ThreadParam thread)
{
  return SDL_GetThreadState(thread);
}
 
inline ThreadState Thread::GetState() const
{
  return SDL::GetThreadState(m_resource);
}
 
inline void DetachThread(ThreadRaw thread) { SDL_DetachThread(thread); }
 
inline void Thread::Detach() { DetachThread(release()); }
 
inline void* GetTLS(TLSID* id) { return SDL_GetTLS(id); }
 
inline void SetTLS(TLSID* id,
                   const void* value,
                   TLSDestructorCallback destructor)
{
  CheckError(SDL_SetTLS(id, value, destructor));
}
 
inline void CleanupTLS() { SDL_CleanupTLS(); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_THREAD_H_ */