SDL3pp_stdinc.h

#ifndef SDL3PP_STDINC_H_
#define SDL3PP_STDINC_H_
 
#include <chrono>
#include <span>
#include <SDL3/SDL_stdinc.h>
#include "SDL3pp_callbackWrapper.h"
#include "SDL3pp_error.h"
#include "SDL3pp_optionalRef.h"
#include "SDL3pp_ownPtr.h"
#include "SDL3pp_spanRef.h"
#include "SDL3pp_strings.h"
 
namespace SDL {
 
using TimeRaw = SDL_Time;
 
// Forward decl
struct Time;
 
// Forward decl
struct Environment;
 
using EnvironmentRaw = SDL_Environment*;
 
// Forward decl
struct EnvironmentRef;
 
// Forward decl
struct IConv;
 
using IConvRaw = SDL_iconv_t;
 
// Forward decl
struct IConvRef;
 
#ifdef SDL3PP_DOC
 
#define SDL_NOLONGLONG 1
 
#define SDL_SIZE_MAX SIZE_MAX
 
#define SDL_COMPILE_TIME_ASSERT(name, x) FailToCompileIf_x_IsFalse(x)
 
#endif // SDL3PP_DOC
 
template<class T, std::size_t N>
constexpr std::size_t arraysize(const T (&array)[N])
{
  return std::size(array);
}
 
#ifdef SDL3PP_DOC
 
#define SDL_STRINGIFY_ARG(arg) #arg
 
#endif // SDL3PP_DOC
 
constexpr Uint32 FourCC(Uint8 a, Uint8 b, Uint8 c, Uint8 d)
{
  return SDL_FOURCC(a, b, c, d);
}
 
#ifdef SDL3PP_DOC
 
#define SDL_SINT64_C(c) c##LL /* or whatever the current compiler uses. */
 
#define SDL_UINT64_C(c) c##ULL /* or whatever the current compiler uses. */
 
#endif // SDL3PP_DOC
 
using Sint8 = ::Sint8;
 
constexpr Sint8 MAX_SINT8 = SDL_MAX_SINT8;
 
constexpr Sint8 MIN_SINT8 = SDL_MIN_SINT8;
 
using Uint8 = ::Uint8;
 
constexpr Uint8 MAX_UINT8 = SDL_MAX_UINT8;
 
constexpr Uint8 MIN_UINT8 = SDL_MIN_UINT8;
 
using Sint16 = ::Sint16;
 
constexpr Sint16 MAX_SINT16 = SDL_MAX_SINT16;
 
constexpr Sint16 MIN_SINT16 = SDL_MIN_SINT16;
 
using Uint16 = ::Uint16;
 
constexpr Uint16 MAX_UINT16 = SDL_MAX_UINT16;
 
constexpr Uint16 MIN_UINT16 = SDL_MIN_UINT16;
 
using Sint32 = ::Sint32;
 
constexpr Sint32 MAX_SINT32 = SDL_MAX_SINT32;
 
constexpr Sint32 MIN_SINT32 = SDL_MIN_SINT32;
 
using Uint32 = ::Uint32;
 
constexpr Uint32 MAX_UINT32 = SDL_MAX_UINT32;
 
constexpr Uint8 MIN_UINT32 = SDL_MIN_UINT32;
 
using Sint64 = ::Sint64;
 
constexpr Sint64 MAX_SINT64 = SDL_MAX_SINT64;
 
constexpr Sint64 MIN_SINT64 = SDL_MIN_SINT64;
 
using Uint64 = ::Uint64;
 
constexpr Uint64 MAX_UINT64 = SDL_MAX_UINT64;
 
constexpr Uint8 MIN_UINT64 = SDL_MIN_UINT64;
 
using Seconds = std::chrono::duration<float>;
 
using Nanoseconds = std::chrono::nanoseconds;
 
using Milliseconds = std::chrono::milliseconds;
 
constexpr float ToSeconds(Seconds duration) { return duration.count(); }
 
constexpr Seconds FromSeconds(float duration) { return Seconds(duration); }
 
constexpr Sint64 ToNS(Nanoseconds duration) { return duration.count(); }
 
constexpr Nanoseconds FromNS(Sint64 duration) { return Nanoseconds{duration}; }
 
class Time
{
  Nanoseconds m_time;
 
public:
  constexpr Time() = default;
 
  constexpr explicit Time(TimeRaw time) noexcept
    : m_time(time)
  {
  }
 
  constexpr Time(std::chrono::nanoseconds time) noexcept
    : m_time(time)
  {
  }
 
  constexpr explicit operator bool() const
  {
    return m_time != std::chrono::nanoseconds{};
  }
 
  constexpr operator std::chrono::nanoseconds() const { return m_time; }
 
  static Time Current();
 
  static constexpr Time FromNS(Sint64 time)
  {
    return Time{std::chrono::nanoseconds{time}};
  }
 
  constexpr Sint64 ToNS() const { return m_time.count(); }
 
  static constexpr Time FromPosix(Sint64 time);
 
  constexpr Sint64 ToPosix() const;
 
  static Time FromWindows(Uint32 dwLowDateTime, Uint32 dwHighDateTime);
 
  void ToWindows(Uint32* dwLowDateTime, Uint32* dwHighDateTime) const;
 
  constexpr float ToSeconds() const { return Seconds(m_time).count(); }
 
  static constexpr Time FromSeconds(float interval)
  {
    return std::chrono::duration_cast<std::chrono::nanoseconds>(
      Seconds(interval));
  }
 
  constexpr Time& operator+=(std::chrono::nanoseconds interval)
  {
    m_time += interval;
    return *this;
  }
 
  constexpr Time& operator-=(std::chrono::nanoseconds interval)
  {
    m_time -= interval;
    return *this;
  }
};
 
constexpr Time MAX_TIME = Time::FromNS(SDL_MAX_TIME);
 
constexpr Time MIN_TIME = Time::FromNS(SDL_MIN_TIME);
 
#ifndef FLT_EPSILON
 
constexpr float FLT_EPSILON = 1.1920928955078125e-07F;
 
#endif // FLT_EPSILON
 
template<class I>
concept Interface = requires(I* iface) { (iface)->version = sizeof(I); };
 
template<Interface I>
constexpr void InitInterface(I* iface)
{
  SDL_INIT_INTERFACE(iface);
}
 
inline void* malloc(size_t size) { return SDL_malloc(size); }
 
inline void* calloc(size_t nmemb, size_t size)
{
  return SDL_calloc(nmemb, size);
}
 
inline void* realloc(void* mem, size_t size) { return SDL_realloc(mem, size); }
 
inline void free(void* mem) { SDL_free(mem); }
 
using malloc_func = void*(SDLCALL*)(size_t size);
 
using calloc_func = void*(SDLCALL*)(size_t nmemb, size_t size);
 
using realloc_func = void*(SDLCALL*)(void* mem, size_t size);
 
using free_func = void(SDLCALL*)(void* mem);
 
inline void GetOriginalMemoryFunctions(malloc_func* malloc_func,
                                       calloc_func* calloc_func,
                                       realloc_func* realloc_func,
                                       free_func* free_func)
{
  SDL_GetOriginalMemoryFunctions(
    malloc_func, calloc_func, realloc_func, free_func);
}
 
inline void GetMemoryFunctions(malloc_func* malloc_func,
                               calloc_func* calloc_func,
                               realloc_func* realloc_func,
                               free_func* free_func)
{
  SDL_GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func);
}
 
inline void SetMemoryFunctions(malloc_func malloc_func,
                               calloc_func calloc_func,
                               realloc_func realloc_func,
                               free_func free_func)
{
  CheckError(
    SDL_SetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func));
}
 
inline void* aligned_alloc(size_t alignment, size_t size)
{
  return SDL_aligned_alloc(alignment, size);
}
 
inline void aligned_free(void* mem) { SDL_aligned_free(mem); }
 
inline int GetNumAllocations() { return SDL_GetNumAllocations(); }
 
class Environment
{
  EnvironmentRaw m_resource = nullptr;
 
public:
  constexpr Environment(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Environment(EnvironmentRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Environment(const Environment& other) noexcept = delete;
 
  constexpr Environment(Environment&& other) noexcept
    : Environment(other.release())
  {
  }
 
  constexpr Environment(const EnvironmentRef& other) = delete;
 
  constexpr Environment(EnvironmentRef&& other) = delete;
 
  Environment(bool populated);
 
  ~Environment() { SDL_DestroyEnvironment(m_resource); }
 
  constexpr Environment& operator=(Environment&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Environment& operator=(const Environment& other) = delete;
 
  constexpr EnvironmentRaw get() const noexcept { return m_resource; }
 
  constexpr EnvironmentRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Environment& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  const char* GetVariable(StringParam name);
 
  OwnArray<char*> GetVariables();
 
  Uint64 GetVariableCount() { return GetVariables().size(); }
 
  void SetVariable(StringParam name, StringParam value, bool overwrite);
 
  void UnsetVariable(StringParam name);
};
 
struct EnvironmentRef : Environment
{
  using Environment::Environment;
 
  constexpr EnvironmentRef(EnvironmentRaw resource) noexcept
    : Environment(resource)
  {
  }
 
  constexpr EnvironmentRef(const Environment& resource) noexcept
    : Environment(resource.get())
  {
  }
 
  constexpr EnvironmentRef(Environment&& resource) noexcept
    : Environment(std::move(resource).release())
  {
  }
 
  constexpr EnvironmentRef(const EnvironmentRef& other) noexcept
    : Environment(other.get())
  {
  }
 
  constexpr EnvironmentRef(EnvironmentRef&& other) noexcept
    : Environment(other.get())
  {
  }
 
  ~EnvironmentRef() { release(); }
 
  EnvironmentRef& operator=(const EnvironmentRef& other) noexcept
  {
    release();
    Environment::operator=(Environment(other.get()));
    return *this;
  }
 
  constexpr operator EnvironmentRaw() const noexcept { return get(); }
};
 
inline EnvironmentRaw GetEnvironment() { return SDL_GetEnvironment(); }
 
inline Environment CreateEnvironment(bool populated)
{
  return Environment(populated);
}
 
inline Environment::Environment(bool populated)
  : m_resource(SDL_CreateEnvironment(populated))
{
}
 
inline const char* GetEnvironmentVariable(EnvironmentRef env, StringParam name)
{
  return SDL_GetEnvironmentVariable(env, name);
}
 
inline const char* Environment::GetVariable(StringParam name)
{
  return SDL::GetEnvironmentVariable(m_resource, std::move(name));
}
 
inline OwnArray<char*> GetEnvironmentVariables(EnvironmentRef env)
{
  return OwnArray<char*>{CheckError(SDL_GetEnvironmentVariables(env))};
}
 
inline OwnArray<char*> Environment::GetVariables()
{
  return SDL::GetEnvironmentVariables(m_resource);
}
 
inline void SetEnvironmentVariable(EnvironmentRef env,
                                   StringParam name,
                                   StringParam value,
                                   bool overwrite)
{
  CheckError(SDL_SetEnvironmentVariable(env, name, value, overwrite));
}
 
inline void Environment::SetVariable(StringParam name,
                                     StringParam value,
                                     bool overwrite)
{
  SDL::SetEnvironmentVariable(
    m_resource, std::move(name), std::move(value), overwrite);
}
 
inline void UnsetEnvironmentVariable(EnvironmentRef env, StringParam name)
{
  CheckError(SDL_UnsetEnvironmentVariable(env, name));
}
 
inline void Environment::UnsetVariable(StringParam name)
{
  SDL::UnsetEnvironmentVariable(m_resource, std::move(name));
}
 
inline void DestroyEnvironment(EnvironmentRaw env)
{
  SDL_DestroyEnvironment(env);
}
 
inline void Environment::Destroy() { DestroyEnvironment(release()); }
 
inline const char* getenv(StringParam name) { return SDL_getenv(name); }
 
inline const char* getenv_unsafe(StringParam name)
{
  return SDL_getenv_unsafe(name);
}
 
inline int setenv_unsafe(StringParam name, StringParam value, int overwrite)
{
  return SDL_setenv_unsafe(name, value, overwrite);
}
 
inline int unsetenv_unsafe(StringParam name)
{
  return SDL_unsetenv_unsafe(name);
}
 
using CompareCallback = int(SDLCALL*)(const void* a, const void* b);
 
inline void qsort(void* base,
                  size_t nmemb,
                  size_t size,
                  CompareCallback compare)
{
  SDL_qsort(base, nmemb, size, compare);
}
 
inline void* bsearch(const void* key,
                     const void* base,
                     size_t nmemb,
                     size_t size,
                     CompareCallback compare)
{
  return SDL_bsearch(key, base, nmemb, size, compare);
}
 
using CompareCallback_r = int(SDLCALL*)(void* userdata,
                                        const void* a,
                                        const void* b);
 
using CompareCB = std::function<int(const void* a, const void* b)>;
 
inline void qsort_r(void* base,
                    size_t nmemb,
                    size_t size,
                    CompareCallback_r compare,
                    void* userdata)
{
  SDL_qsort_r(base, nmemb, size, compare, userdata);
}
 
inline void qsort_r(void* base, size_t nmemb, size_t size, CompareCB compare)
{
  return qsort_r(
    base,
    nmemb,
    size,
    [](void* userdata, const void* a, const void* b) {
      auto& cb = *static_cast<const CompareCB*>(userdata);
      return cb(a, b);
    },
    &compare);
}
 
inline void* bsearch_r(const void* key,
                       const void* base,
                       size_t nmemb,
                       size_t size,
                       CompareCallback_r compare,
                       void* userdata)
{
  return SDL_bsearch_r(key, base, nmemb, size, compare, userdata);
}
 
inline void* bsearch_r(const void* key,
                       const void* base,
                       size_t nmemb,
                       size_t size,
                       CompareCB compare)
{
  return bsearch_r(
    key,
    base,
    nmemb,
    size,
    [](void* userdata, const void* a, const void* b) {
      auto& cb = *static_cast<const CompareCB*>(userdata);
      return cb(a, b);
    },
    &compare);
}
 
inline int abs(int x) { return SDL_abs(x); }
 
inline double abs(double x) { return SDL_fabs(x); }
 
inline float abs(float x) { return SDL_fabsf(x); }
 
template<class T, class U>
constexpr T min(T x, U y)
{
  return SDL_min(x, y);
}
 
template<class T, class U>
constexpr T max(T x, U y)
{
  return SDL_max(x, y);
}
 
template<class T, class U, class V>
constexpr T clamp(T x, U a, V b)
{
  return SDL_clamp(x, a, b);
}
 
inline int isalpha(int x) { return SDL_isalpha(x); }
 
inline int isalnum(int x) { return SDL_isalnum(x); }
 
inline int isblank(int x) { return SDL_isblank(x); }
 
inline int iscntrl(int x) { return SDL_iscntrl(x); }
 
inline int isdigit(int x) { return SDL_isdigit(x); }
 
inline int isxdigit(int x) { return SDL_isxdigit(x); }
 
inline int ispunct(int x) { return SDL_ispunct(x); }
 
inline int isspace(int x) { return SDL_isspace(x); }
 
inline int isupper(int x) { return SDL_isupper(x); }
 
inline int islower(int x) { return SDL_islower(x); }
 
inline int isprint(int x) { return SDL_isprint(x); }
 
inline int isgraph(int x) { return SDL_isgraph(x); }
 
inline int toupper(int x) { return SDL_toupper(x); }
 
inline int tolower(int x) { return SDL_tolower(x); }
 
inline Uint16 crc16(Uint16 crc, const void* data, size_t len)
{
  return SDL_crc16(crc, data, len);
}
 
inline Uint32 crc32(Uint32 crc, const void* data, size_t len)
{
  return SDL_crc32(crc, data, len);
}
 
inline Uint32 murmur3_32(const void* data, size_t len, Uint32 seed)
{
  return SDL_murmur3_32(data, len, seed);
}
 
inline void* memcpy(void* dst, const void* src, size_t len)
{
#ifdef SDL_SLOW_MEMCPY
  return SDL_memcpy(dst, src, len);
#else
  return ::memcpy(dst, src, len);
#endif // SDL_SLOW_MEMCPY
}
 
template<typename T, typename U>
constexpr T* copyp(T* dst, const U* src)
{
  SDL_copyp(dst, src);
  return dst;
}
 
inline void* memmove(void* dst, const void* src, size_t len)
{
#ifdef SDL_SLOW_MEMMOVE
  return SDL_memmove(dst, src, len);
#else
  return ::memmove(dst, src, len);
#endif // SDL_SLOW_MEMMOVE
}
 
inline void* memset(void* dst, int c, size_t len)
{
#ifdef SDL_SLOW_MEMSET
  return SDL_memset(dst, c, len);
#else
  return ::memset(dst, c, len);
#endif // SDL_SLOW_MEMSET
}
 
inline void* memset4(void* dst, Uint32 val, size_t dwords)
{
  return SDL_memset4(dst, val, dwords);
}
 
template<class T>
inline void zero(T& x)
{
  SDL_zero(x);
}
 
template<class T>
inline void zerop(T* x)
{
  SDL_zerop(x);
}
 
template<class T, std::size_t N>
inline void zeroa(T (&x)[N])
{
  SDL_zeroa(x);
}
 
inline int memcmp(const void* s1, const void* s2, size_t len)
{
  return SDL_memcmp(s1, s2, len);
}
 
inline size_t wcslen(const wchar_t* wstr) { return SDL_wcslen(wstr); }
 
inline size_t wcsnlen(const wchar_t* wstr, size_t maxlen)
{
  return SDL_wcsnlen(wstr, maxlen);
}
 
inline size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t maxlen)
{
  return SDL_wcslcpy(dst, src, maxlen);
}
 
inline size_t wcslcat(wchar_t* dst, const wchar_t* src, size_t maxlen)
{
  return SDL_wcslcat(dst, src, maxlen);
}
 
inline wchar_t* wcsdup(const wchar_t* wstr) { return SDL_wcsdup(wstr); }
 
inline wchar_t* wcsstr(const wchar_t* haystack, const wchar_t* needle)
{
  return SDL_wcsstr(haystack, needle);
}
 
inline wchar_t* wcsnstr(const wchar_t* haystack,
                        const wchar_t* needle,
                        size_t maxlen)
{
  return SDL_wcsnstr(haystack, needle, maxlen);
}
 
inline int wcscmp(const wchar_t* str1, const wchar_t* str2)
{
  return SDL_wcscmp(str1, str2);
}
 
inline int wcsncmp(const wchar_t* str1, const wchar_t* str2, size_t maxlen)
{
  return SDL_wcsncmp(str1, str2, maxlen);
}
 
inline int wcscasecmp(const wchar_t* str1, const wchar_t* str2)
{
  return SDL_wcscasecmp(str1, str2);
}
 
inline int wcsncasecmp(const wchar_t* str1, const wchar_t* str2, size_t maxlen)
{
  return SDL_wcsncasecmp(str1, str2, maxlen);
}
 
inline long wcstol(const wchar_t* str, wchar_t** endp, int base)
{
  return SDL_wcstol(str, endp, base);
}
 
inline size_t strlen(StringParam str) { return SDL_strlen(str); }
 
inline size_t strnlen(StringParam str, size_t maxlen)
{
  return SDL_strnlen(str, maxlen);
}
 
inline size_t strlcpy(char* dst, StringParam src, size_t maxlen)
{
  return SDL_strlcpy(dst, src, maxlen);
}
 
inline size_t utf8strlcpy(char* dst, StringParam src, size_t dst_bytes)
{
  return SDL_utf8strlcpy(dst, src, dst_bytes);
}
 
inline size_t strlcat(char* dst, StringParam src, size_t maxlen)
{
  return SDL_strlcat(dst, src, maxlen);
}
 
inline char* strdup(StringParam str) { return SDL_strdup(str); }
 
inline char* strndup(StringParam str, size_t maxlen)
{
  return SDL_strndup(str, maxlen);
}
 
inline char* strrev(char* str) { return SDL_strrev(str); }
 
inline char* strupr(char* str) { return SDL_strupr(str); }
 
inline char* strlwr(char* str) { return SDL_strlwr(str); }
 
inline char* strchr(StringParam str, int c) { return SDL_strchr(str, c); }
 
inline char* strrchr(StringParam str, int c) { return SDL_strrchr(str, c); }
 
inline char* strstr(StringParam haystack, StringParam needle)
{
  return SDL_strstr(haystack, needle);
}
 
inline char* strnstr(StringParam haystack, StringParam needle, size_t maxlen)
{
  return SDL_strnstr(haystack, needle, maxlen);
}
 
inline char* strcasestr(StringParam haystack, StringParam needle)
{
  return SDL_strcasestr(haystack, needle);
}
 
inline char* strtok_r(char* str, StringParam delim, char** saveptr)
{
  return SDL_strtok_r(str, delim, saveptr);
}
 
inline size_t utf8strlen(StringParam str) { return SDL_utf8strlen(str); }
 
inline size_t utf8strnlen(StringParam str, size_t bytes)
{
  return SDL_utf8strnlen(str, bytes);
}
 
inline char* itoa(int value, char* str, int radix)
{
  return SDL_itoa(value, str, radix);
}
 
inline char* uitoa(unsigned int value, char* str, int radix)
{
  return SDL_uitoa(value, str, radix);
}
 
inline char* ltoa(long value, char* str, int radix)
{
  return SDL_ltoa(value, str, radix);
}
 
inline char* ultoa(unsigned long value, char* str, int radix)
{
  return SDL_ultoa(value, str, radix);
}
 
#ifndef SDL_NOLONGLONG
 
inline char* lltoa(long long value, char* str, int radix)
{
  return SDL_lltoa(value, str, radix);
}
 
inline char* ulltoa(unsigned long long value, char* str, int radix)
{
  return SDL_ulltoa(value, str, radix);
}
 
#endif // SDL_NOLONGLONG
 
inline int atoi(StringParam str) { return SDL_atoi(str); }
 
inline double atof(StringParam str) { return SDL_atof(str); }
 
inline long strtol(StringParam str, char** endp, int base)
{
  return SDL_strtol(str, endp, base);
}
 
inline unsigned long strtoul(StringParam str, char** endp, int base)
{
  return SDL_strtoul(str, endp, base);
}
 
#ifndef SDL_NOLONGLONG
 
inline long long strtoll(StringParam str, char** endp, int base)
{
  return SDL_strtoll(str, endp, base);
}
 
inline unsigned long long strtoull(StringParam str, char** endp, int base)
{
  return SDL_strtoull(str, endp, base);
}
 
#endif // SDL_NOLONGLONG
 
inline double strtod(StringParam str, char** endp)
{
  return SDL_strtod(str, endp);
}
 
inline int strcmp(StringParam str1, StringParam str2)
{
  return SDL_strcmp(str1, str2);
}
 
inline int strncmp(StringParam str1, StringParam str2, size_t maxlen)
{
  return SDL_strncmp(str1, str2, maxlen);
}
 
inline int strcasecmp(StringParam str1, StringParam str2)
{
  return SDL_strcasecmp(str1, str2);
}
 
inline int strncasecmp(StringParam str1, StringParam str2, size_t maxlen)
{
  return SDL_strncasecmp(str1, str2, maxlen);
}
 
inline char* strpbrk(StringParam str, StringParam breakset)
{
  return SDL_strpbrk(str, breakset);
}
 
constexpr Uint32 INVALID_UNICODE_CODEPOINT = SDL_INVALID_UNICODE_CODEPOINT;
 
inline Uint32 StepUTF8(const char** pstr, size_t* pslen)
{
  return SDL_StepUTF8(pstr, pslen);
}
 
inline Uint32 StepBackUTF8(StringParam start, const char** pstr)
{
  return SDL_StepBackUTF8(start, pstr);
}
 
inline char* UCS4ToUTF8(Uint32 codepoint, char* dst)
{
  return SDL_UCS4ToUTF8(codepoint, dst);
}
 
inline int sscanf(StringParam text,
                  SDL_SCANF_FORMAT_STRING const char* fmt,
                  ...)
{
  int rc;
  va_list ap;
  va_start(ap, fmt);
  rc = SDL_vsscanf(text, fmt, ap);
  va_end(ap);
  return rc;
}
 
inline int vsscanf(StringParam text,
                   SDL_SCANF_FORMAT_STRING const char* fmt,
                   va_list ap)
{
  return SDL_vsscanf(text, fmt, ap);
}
 
inline int snprintf(char* text,
                    size_t maxlen,
                    SDL_PRINTF_FORMAT_STRING const char* fmt,
                    ...)
{
  va_list ap;
  int result;
 
  va_start(ap, fmt);
  result = SDL_vsnprintf(text, maxlen, fmt, ap);
  va_end(ap);
 
  return result;
}
 
inline int swprintf(wchar_t* text,
                    size_t maxlen,
                    SDL_PRINTF_FORMAT_STRING const wchar_t* fmt,
                    ...)
{
  va_list ap;
  int result;
 
  va_start(ap, fmt);
  result = SDL_vswprintf(text, maxlen, fmt, ap);
  va_end(ap);
 
  return result;
}
 
inline int vsnprintf(char* text,
                     size_t maxlen,
                     SDL_PRINTF_FORMAT_STRING const char* fmt,
                     va_list ap)
{
  return SDL_vsnprintf(text, maxlen, fmt, ap);
}
 
inline int vswprintf(wchar_t* text,
                     size_t maxlen,
                     SDL_PRINTF_FORMAT_STRING const wchar_t* fmt,
                     va_list ap)
{
  return SDL_vswprintf(text, maxlen, fmt, ap);
}
 
inline int asprintf(char** strp, SDL_PRINTF_FORMAT_STRING const char* fmt, ...)
{
  va_list ap;
  int result;
 
  va_start(ap, fmt);
  result = SDL_vasprintf(strp, fmt, ap);
  va_end(ap);
 
  return result;
}
 
inline int vasprintf(char** strp,
                     SDL_PRINTF_FORMAT_STRING const char* fmt,
                     va_list ap)
{
  return SDL_vasprintf(strp, fmt, ap);
}
 
inline void srand(Uint64 seed) { SDL_srand(seed); }
 
class Random
{
  Uint64 m_state;
 
public:
  constexpr Random()
    : m_state(0)
  {
  }
 
  constexpr explicit Random(Uint64 state)
    : m_state(state)
  {
  }
 
  constexpr operator Uint64() const { return m_state; }
 
  Sint32 rand(Sint32 n) { return SDL_rand_r(&m_state, n); }
 
  float randf() { return SDL_randf_r(&m_state); }
 
  Uint32 rand_bits() { return SDL_rand_bits_r(&m_state); }
};
 
inline Sint32 rand(Sint32 n) { return SDL_rand(n); }
 
inline Sint32 rand(Uint64* state, Sint32 n) { return SDL_rand_r(state, n); }
 
inline Sint32 rand(Random& state, Sint32 n) { return state.rand(n); }
 
inline float randf() { return SDL_randf(); }
 
inline float randf(Uint64* state) { return SDL_randf_r(state); }
 
inline float randf(Random& state) { return state.randf(); }
 
inline Uint32 rand_bits() { return SDL_rand_bits(); }
 
inline Uint32 rand_bits(Uint64* state) { return SDL_rand_bits_r(state); }
 
inline Uint32 rand_bits(Random& state) { return state.rand_bits(); }
 
constexpr double PI_D = SDL_PI_D;
 
constexpr float PI_F = SDL_PI_F;
 
inline double acos(double x) { return SDL_acos(x); }
 
inline float acos(float x) { return SDL_acosf(x); }
 
inline double asin(double x) { return SDL_asin(x); }
 
inline float asin(float x) { return SDL_asinf(x); }
 
inline double atan(double x) { return SDL_atan(x); }
 
inline float atan(float x) { return SDL_atanf(x); }
 
inline double atan2(double y, double x) { return SDL_atan2(y, x); }
 
inline float atan2(float y, float x) { return SDL_atan2f(y, x); }
 
inline double ceil(double x) { return SDL_ceil(x); }
 
inline float ceil(float x) { return SDL_ceilf(x); }
 
inline double copysign(double x, double y) { return SDL_copysign(x, y); }
 
inline float copysign(float x, float y) { return SDL_copysignf(x, y); }
 
inline double cos(double x) { return SDL_cos(x); }
 
inline float cos(float x) { return SDL_cosf(x); }
 
inline double exp(double x) { return SDL_exp(x); }
 
inline float exp(float x) { return SDL_expf(x); }
 
inline double floor(double x) { return SDL_floor(x); }
 
inline float floor(float x) { return SDL_floorf(x); }
 
inline double trunc(double x) { return SDL_trunc(x); }
 
inline float trunc(float x) { return SDL_truncf(x); }
 
inline double fmod(double x, double y) { return SDL_fmod(x, y); }
 
inline float fmod(float x, float y) { return SDL_fmodf(x, y); }
 
inline int isinf(double x) { return SDL_isinf(x); }
 
inline int isinf(float x) { return SDL_isinff(x); }
 
inline int isnan(double x) { return SDL_isnan(x); }
 
inline int isnan(float x) { return SDL_isnanf(x); }
 
inline double log(double x) { return SDL_log(x); }
 
inline float log(float x) { return SDL_logf(x); }
 
inline double log10(double x) { return SDL_log10(x); }
 
inline float log10(float x) { return SDL_log10f(x); }
 
inline double modf(double x, double* y) { return SDL_modf(x, y); }
 
inline float modf(float x, float* y) { return SDL_modff(x, y); }
 
inline double pow(double x, double y) { return SDL_pow(x, y); }
 
inline float pow(float x, float y) { return SDL_powf(x, y); }
 
inline double round(double x) { return SDL_round(x); }
 
inline float round(float x) { return SDL_roundf(x); }
 
inline long lround(double x) { return SDL_lround(x); }
 
inline long lround(float x) { return SDL_lroundf(x); }
 
inline double scalbn(double x, int n) { return SDL_scalbn(x, n); }
 
inline float scalbn(float x, int n) { return SDL_scalbnf(x, n); }
 
inline double sin(double x) { return SDL_sin(x); }
 
inline float sin(float x) { return SDL_sinf(x); }
 
inline double sqrt(double x) { return SDL_sqrt(x); }
 
inline float sqrt(float x) { return SDL_sqrtf(x); }
 
inline double tan(double x) { return SDL_tan(x); }
 
inline float tan(float x) { return SDL_tanf(x); }
 
class IConv
{
  IConvRaw m_resource = nullptr;
 
public:
  IConv(std::nullptr_t = nullptr) noexcept
    : m_resource(IConvRaw(SDL_ICONV_ERROR))
  {
  }
 
  constexpr explicit IConv(IConvRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr IConv(const IConv& other) noexcept = delete;
 
  constexpr IConv(IConv&& other) noexcept
    : IConv(other.release())
  {
  }
 
  constexpr IConv(const IConvRef& other) = delete;
 
  constexpr IConv(IConvRef&& other) = delete;
 
  IConv(StringParam tocode, StringParam fromcode);
 
  ~IConv() { SDL_iconv_close(m_resource); }
 
  constexpr IConv& operator=(IConv&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  IConv& operator=(const IConv& other) = delete;
 
  constexpr IConvRaw get() const noexcept { return m_resource; }
 
  constexpr IConvRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const IConv& other) const noexcept = default;
 
  explicit operator bool() const noexcept
  {
    return reinterpret_cast<size_t>(m_resource) != SDL_ICONV_ERROR;
  }
 
  int close();
 
  size_t iconv(const char** inbuf,
               size_t* inbytesleft,
               char** outbuf,
               size_t* outbytesleft) const;
};
 
struct IConvRef : IConv
{
  using IConv::IConv;
 
  constexpr IConvRef(IConvRaw resource) noexcept
    : IConv(resource)
  {
  }
 
  constexpr IConvRef(const IConv& resource) noexcept
    : IConv(resource.get())
  {
  }
 
  constexpr IConvRef(IConv&& resource) noexcept
    : IConv(std::move(resource).release())
  {
  }
 
  constexpr IConvRef(const IConvRef& other) noexcept
    : IConv(other.get())
  {
  }
 
  constexpr IConvRef(IConvRef&& other) noexcept
    : IConv(other.get())
  {
  }
 
  ~IConvRef() { release(); }
 
  IConvRef& operator=(const IConvRef& other) noexcept
  {
    release();
    IConv::operator=(IConv(other.get()));
    return *this;
  }
 
  constexpr operator IConvRaw() const noexcept { return get(); }
};
 
inline IConv iconv_open(StringParam tocode, StringParam fromcode)
{
  return IConv(std::move(tocode), std::move(fromcode));
}
 
inline IConv::IConv(StringParam tocode, StringParam fromcode)
  : m_resource(SDL_iconv_open(tocode, fromcode))
{
}
 
inline int iconv_close(IConvRaw cd) { return CheckError(SDL_iconv_close(cd)); }
 
inline int IConv::close() { return iconv_close(release()); }
 
inline size_t iconv(IConvRaw cd,
                    const char** inbuf,
                    size_t* inbytesleft,
                    char** outbuf,
                    size_t* outbytesleft)
{
  return CheckError(SDL_iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft));
}
 
inline size_t IConv::iconv(const char** inbuf,
                           size_t* inbytesleft,
                           char** outbuf,
                           size_t* outbytesleft) const
{
  return SDL::iconv(m_resource, inbuf, inbytesleft, outbuf, outbytesleft);
}
 
constexpr size_t ICONV_ERROR =
  SDL_ICONV_ERROR; 
 
constexpr size_t ICONV_E2BIG =
  SDL_ICONV_E2BIG; 
 
constexpr size_t ICONV_EILSEQ =
  SDL_ICONV_EILSEQ; 
 
constexpr size_t ICONV_EINVAL =
  SDL_ICONV_EINVAL; 
 
inline OwnArray<char> iconv_string(StringParam tocode,
                                   StringParam fromcode,
                                   SourceBytes inbuf)
{
  return OwnArray<char>{
    SDL_iconv_string(tocode, fromcode, inbuf.data(), inbuf.size_bytes())};
}
 
inline OwnArray<char> iconv_utf8_locale(std::string_view S)
{
  return iconv_string("", "UTF-8", S);
}
 
inline OwnArray<Uint16> iconv_utf8_ucs2(std::string_view S)
{
  auto data = SDL_iconv_string("UCS-2", "UTF-8", S.data(), S.size());
  return OwnArray<Uint16>(reinterpret_cast<Uint16*>(data));
}
 
inline OwnArray<Uint32> iconv_utf8_ucs4(std::string_view S)
{
  auto data = SDL_iconv_string("UCS-4", "UTF-8", S.data(), S.size());
  return OwnArray<Uint32>(reinterpret_cast<Uint32*>(data));
}
 
inline OwnArray<char> iconv_wchar_utf8(std::wstring_view S)
{
  return iconv_string("UTF-8", "WCHAR_T", S);
}
 
inline bool size_mul_check_overflow(size_t a, size_t b, size_t* ret)
{
  return SDL_size_mul_check_overflow(a, b, ret);
}
 
inline bool size_add_check_overflow(size_t a, size_t b, size_t* ret)
{
  return SDL_size_add_check_overflow(a, b, ret);
}
 
using FunctionPointer = void(SDLCALL*)();
 
 
inline void PtrDeleter::operator()(void* ptr) const { SDL_free(ptr); }
 
template<std::integral T>
Sint32 narrowS32(T value)
{
  if constexpr (std::is_signed_v<T>) {
    SDL_assert_paranoid(value >= std::numeric_limits<Sint32>::min() &&
                        value <= std::numeric_limits<Sint32>::max());
  } else {
    SDL_assert_paranoid(value <= std::numeric_limits<Sint32>::max());
  }
  return static_cast<Sint32>(value);
}
 
template<std::integral T>
Uint32 narrowU32(T value)
{
  SDL_assert_paranoid(value <= std::numeric_limits<Uint32>::max());
  return static_cast<Uint32>(value);
}
 
} // namespace SDL
 
#endif /* SDL3PP_STDINC_H_ */