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 {
 
using ThreadID = SDL_ThreadID;
 
using TLSID = AtomicInt;
 
using ThreadFunction = SDL_ThreadFunction;
 
using ThreadCB = std::function<int()>;
 
using TLSDestructorCallback = SDL_TLSDestructorCallback;
 
// Forward decl
struct ThreadBase;
 
// Forward decl
struct ThreadRef;
 
// Forward decl
struct Thread;
 
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;
 
struct ThreadBase : Resource<SDL_Thread*>
{
  using Resource::Resource;
 
  ThreadBase(ThreadCB fn, StringParam name)
    : ThreadBase(
        [](void* handler) {
          return CallbackWrapper<ThreadCB>::CallOnce(handler);
        },
        std::move(name),
        CallbackWrapper<ThreadCB>::Wrap(std::move(fn)))
  {
  }
 
  ThreadBase(ThreadFunction fn, StringParam name, void* data)
    : Resource(CheckError(SDL_CreateThread(fn, name, data)))
  {
  }
 
  ThreadBase(PropertiesBase& props)
    : Resource(CheckError(SDL_CreateThreadWithProperties(props.get())))
  {
  }
 
  const char* GetName() const { return SDL_GetThreadName(get()); }
 
  ThreadID GetID() const { return SDL_GetThreadID(get()); }
 
  static void SetCurrentPriority(ThreadPriority priority)
  {
    CheckError(SDL_SetCurrentThreadPriority(priority));
  }
 
  void Wait(int* status) { SDL_WaitThread(get(), status); }
 
  ThreadState GetState() const { return SDL_GetThreadState(get()); }
};
 
struct ThreadRef : ThreadBase
{
  using ThreadBase::ThreadBase;
 
  constexpr ThreadRef(const ThreadRef& other)
    : ThreadBase(other.get())
  {
  }
 
  constexpr ThreadRef(ThreadRef&& other)
    : ThreadBase(other.release())
  {
  }
 
  constexpr ~ThreadRef() = default;
 
  ThreadRef& operator=(ThreadRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Thread* newResource = {})
  {
    SDL_DetachThread(release(newResource));
  }
 
  void Detach() { reset(); }
};
 
struct Thread : ThreadRef
{
  using ThreadRef::ThreadRef;
 
  constexpr explicit Thread(SDL_Thread* resource = {})
    : ThreadRef(resource)
  {
  }
 
  constexpr Thread(const Thread& other) = delete;
 
  constexpr Thread(Thread&& other) = default;
 
  ~Thread() { reset(); }
 
  Thread& operator=(Thread other)
  {
    reset(other.release());
    return *this;
  }
};
 
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 ThreadID GetCurrentThreadID() { return SDL_GetCurrentThreadID(); }
 
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_ */