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 ThreadRef;
 
// Forward decl
struct Thread;
 
using ThreadShared = ResourceShared<Thread>;
 
using ThreadWeak = ResourceWeak<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 ThreadRef : Resource<SDL_Thread*>
{
  using Resource::Resource;
 
  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()); }
 
  static void reset(SDL_Thread* resource) { SDL_DetachThread(resource); }
};
 
struct Thread : ResourceUnique<ThreadRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Thread Create(ThreadCB fn, StringParam name)
  {
    return Create(
      [](void* handler) {
        return CallbackWrapper<ThreadCB>::CallOnce(handler);
      },
      std::move(name),
      CallbackWrapper<ThreadCB>::Wrap(std::move(fn)));
  }
 
  static Thread Create(ThreadFunction fn, StringParam name, void* data)
  {
    return Thread(CheckError(SDL_CreateThread(fn, name, data)));
  }
 
  static Thread CreateWithProperties(PropertiesRef props)
  {
    return Thread(CheckError(SDL_CreateThreadWithProperties(props)));
  }
 
  void Detach() { reset(); }
  ThreadShared share();
 
};
 
 
inline ThreadShared Thread::share()
{
  return ThreadShared(std::move(*this));
}
 
struct ThreadUnsafe : ResourceUnsafe<ThreadRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit ThreadUnsafe(Thread&& other)
    : ThreadUnsafe(other.release())
  {
  }
};
 
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_ */