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_resource.h"
#include "SDL3pp_spanRef.h"
#include "SDL3pp_strings.h"
 
namespace SDL {


using TimeRaw = SDL_Time;
 
// Forward decl
struct Time;
 
// Forward decl
struct EnvironmentBase;
 
// Forward decl
struct Environment;

using EnvironmentRaw = SDL_Environment*;

using EnvironmentRef = ResourceRefT<EnvironmentBase>;
 
// Forward decl
struct IConvBase;
 
// Forward decl
struct IConv;

using IConvRaw = SDL_iconv_t;

using IConvRef = ResourceRefT<IConvBase>;
 
#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(); }

struct EnvironmentBase : ResourceBaseT<EnvironmentRaw>
{
  using ResourceBaseT::ResourceBaseT;

  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 Environment : EnvironmentBase
{
  using EnvironmentBase::EnvironmentBase;

  constexpr explicit Environment(EnvironmentRaw resource) noexcept
    : EnvironmentBase(resource)
  {
  }

  constexpr Environment(Environment&& other) noexcept
    : Environment(other.release())
  {
  }

  Environment(bool populated);

  ~Environment() { SDL_DestroyEnvironment(get()); }

  constexpr Environment& operator=(Environment&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline EnvironmentRaw GetEnvironment() { return SDL_GetEnvironment(); }

inline Environment CreateEnvironment(bool populated)
{
  return Environment(populated);
}
 
inline Environment::Environment(bool populated)
  : Environment(SDL_CreateEnvironment(populated))
{
}

inline const char* GetEnvironmentVariable(EnvironmentRef env, StringParam name)
{
  return SDL_GetEnvironmentVariable(env, name);
}
 
inline const char* EnvironmentBase::GetVariable(StringParam name)
{
  return SDL::GetEnvironmentVariable(get(), std::move(name));
}

inline OwnArray<char*> GetEnvironmentVariables(EnvironmentRef env)
{
  return OwnArray<char*>{CheckError(SDL_GetEnvironmentVariables(env))};
}
 
inline OwnArray<char*> EnvironmentBase::GetVariables()
{
  return SDL::GetEnvironmentVariables(get());
}

inline void SetEnvironmentVariable(EnvironmentRef env,
                                   StringParam name,
                                   StringParam value,
                                   bool overwrite)
{
  CheckError(SDL_SetEnvironmentVariable(env, name, value, overwrite));
}
 
inline void EnvironmentBase::SetVariable(StringParam name,
                                         StringParam value,
                                         bool overwrite)
{
  SDL::SetEnvironmentVariable(
    get(), std::move(name), std::move(value), overwrite);
}

inline void UnsetEnvironmentVariable(EnvironmentRef env, StringParam name)
{
  CheckError(SDL_UnsetEnvironmentVariable(env, name));
}
 
inline void EnvironmentBase::UnsetVariable(StringParam name)
{
  SDL::UnsetEnvironmentVariable(get(), std::move(name));
}

inline void DestroyEnvironment(EnvironmentRaw env)
{
  SDL_DestroyEnvironment(env);
}
 
inline void EnvironmentBase::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); }

struct IConvBase : ResourceBaseT<IConvRaw>
{
  using ResourceBaseT::ResourceBaseT;

  explicit operator bool() const noexcept
  {
    return reinterpret_cast<size_t>(get()) != SDL_ICONV_ERROR;
  }

  int close();

  size_t iconv(const char** inbuf,
               size_t* inbytesleft,
               char** outbuf,
               size_t* outbytesleft) const;
};

struct IConv : IConvBase
{
  using IConvBase::IConvBase;

  IConv(std::nullptr_t = nullptr) noexcept
    : IConv(IConvRaw(SDL_ICONV_ERROR))
  {
  }

  constexpr explicit IConv(IConvRaw resource) noexcept
    : IConvBase(resource)
  {
  }

  constexpr IConv(IConv&& other) noexcept
    : IConv(other.release())
  {
  }

  IConv(StringParam tocode, StringParam fromcode);

  ~IConv() { SDL_iconv_close(get()); }

  constexpr IConv& operator=(IConv&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline IConv iconv_open(StringParam tocode, StringParam fromcode)
{
  return IConv(std::move(tocode), std::move(fromcode));
}
 
inline IConv::IConv(StringParam tocode, StringParam fromcode)
  : IConv(SDL_iconv_open(tocode, fromcode))
{
}

inline int iconv_close(IConvRaw cd) { return CheckError(SDL_iconv_close(cd)); }
 
inline int IConvBase::close() { return iconv_close(release()); }

inline size_t iconv(IConvRef cd,
                    const char** inbuf,
                    size_t* inbytesleft,
                    char** outbuf,
                    size_t* outbytesleft)
{
  return CheckError(SDL_iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft));
}
 
inline size_t IConvBase::iconv(const char** inbuf,
                               size_t* inbytesleft,
                               char** outbuf,
                               size_t* outbytesleft) const
{
  return SDL::iconv(get(), 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_ */