SDL3pp_asyncio.h

#ifndef SDL3PP_ASYNCIO_H_
#define SDL3PP_ASYNCIO_H_
 
#include <SDL3/SDL_asyncio.h>
#include "SDL3pp_log.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct AsyncIO;
 
using AsyncIORaw = SDL_AsyncIO*;
 
// Forward decl
struct AsyncIORef;
 
struct AsyncIOParam
{
  AsyncIORaw value; 
 
  constexpr AsyncIOParam(AsyncIORaw value)
    : value(value)
  {
  }
 
  constexpr AsyncIOParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AsyncIOParam& other) const = default;
 
  constexpr operator AsyncIORaw() const { return value; }
};
 
// Forward decl
struct AsyncIOQueue;
 
using AsyncIOQueueRaw = SDL_AsyncIOQueue*;
 
// Forward decl
struct AsyncIOQueueRef;
 
struct AsyncIOQueueParam
{
  AsyncIOQueueRaw value; 
 
  constexpr AsyncIOQueueParam(AsyncIOQueueRaw value)
    : value(value)
  {
  }
 
  constexpr AsyncIOQueueParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AsyncIOQueueParam& other) const = default;
 
  constexpr operator AsyncIOQueueRaw() const { return value; }
};
 
class AsyncIO
{
  AsyncIORaw m_resource = nullptr;
 
public:
  constexpr AsyncIO() = default;
 
  constexpr explicit AsyncIO(const AsyncIORaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr AsyncIO(const AsyncIO& other) = delete;
 
  constexpr AsyncIO(AsyncIO&& other)
    : AsyncIO(other.release())
  {
  }
 
  constexpr AsyncIO(const AsyncIORef& other) = delete;
 
  constexpr AsyncIO(AsyncIORef&& other) = delete;
 
  AsyncIO(StringParam file, StringParam mode)
    : m_resource(SDL_AsyncIOFromFile(file, mode))
  {
  }
 
  ~AsyncIO()
  {
    if (m_resource) {
      LOG_CATEGORY_ERROR.LogDebug("AsyncIO ID was not properly Destroyed: {}",
                                  (void*)(m_resource));
    }
  }
 
  AsyncIO& operator=(AsyncIO other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr AsyncIORaw get() const { return m_resource; }
 
  constexpr AsyncIORaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const AsyncIO& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator AsyncIOParam() const { return {m_resource}; }
 
  bool Close(bool flush, AsyncIOQueueParam queue, void* userdata);
 
  Sint64 GetSize();
 
  void Read(void* ptr,
            Uint64 offset,
            Uint64 size,
            AsyncIOQueueParam queue,
            void* userdata);
 
  void Write(void* ptr,
             Uint64 offset,
             Uint64 size,
             AsyncIOQueueParam queue,
             void* userdata);
};
 
struct AsyncIORef : AsyncIO
{
  AsyncIORef(AsyncIOParam resource)
    : AsyncIO(resource.value)
  {
  }
 
  AsyncIORef(const AsyncIORef& other)
    : AsyncIO(other.get())
  {
  }
 
  ~AsyncIORef() { release(); }
};
 
using AsyncIOTaskType = SDL_AsyncIOTaskType;
 
constexpr AsyncIOTaskType ASYNCIO_TASK_READ =
  SDL_ASYNCIO_TASK_READ; 
 
constexpr AsyncIOTaskType ASYNCIO_TASK_WRITE =
  SDL_ASYNCIO_TASK_WRITE; 
 
constexpr AsyncIOTaskType ASYNCIO_TASK_CLOSE =
  SDL_ASYNCIO_TASK_CLOSE; 
 
using AsyncIOResult = SDL_AsyncIOResult;
 
constexpr AsyncIOResult ASYNCIO_COMPLETE =
  SDL_ASYNCIO_COMPLETE; 
 
constexpr AsyncIOResult ASYNCIO_FAILURE =
  SDL_ASYNCIO_FAILURE; 
 
constexpr AsyncIOResult ASYNCIO_CANCELED =
  SDL_ASYNCIO_CANCELED; 
 
using AsyncIOOutcome = SDL_AsyncIOOutcome;
 
class AsyncIOQueue
{
  AsyncIOQueueRaw m_resource = nullptr;
 
public:
  constexpr explicit AsyncIOQueue(const AsyncIOQueueRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr AsyncIOQueue(const AsyncIOQueue& other) = delete;
 
  constexpr AsyncIOQueue(AsyncIOQueue&& other)
    : AsyncIOQueue(other.release())
  {
  }
 
  constexpr AsyncIOQueue(const AsyncIOQueueRef& other) = delete;
 
  constexpr AsyncIOQueue(AsyncIOQueueRef&& other) = delete;
 
  AsyncIOQueue()
    : m_resource(SDL_CreateAsyncIOQueue())
  {
  }
 
  ~AsyncIOQueue() { SDL_DestroyAsyncIOQueue(m_resource); }
 
  AsyncIOQueue& operator=(AsyncIOQueue other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr AsyncIOQueueRaw get() const { return m_resource; }
 
  constexpr AsyncIOQueueRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const AsyncIOQueue& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator AsyncIOQueueParam() const { return {m_resource}; }
 
  void Destroy();
 
  std::optional<AsyncIOOutcome> GetResult();
 
  std::optional<AsyncIOOutcome> WaitResult(Milliseconds timeout);
 
  std::optional<AsyncIOOutcome> WaitResult();
 
  void Signal();
};
 
struct AsyncIOQueueRef : AsyncIOQueue
{
  AsyncIOQueueRef(AsyncIOQueueParam resource)
    : AsyncIOQueue(resource.value)
  {
  }
 
  AsyncIOQueueRef(const AsyncIOQueueRef& other)
    : AsyncIOQueue(other.get())
  {
  }
 
  ~AsyncIOQueueRef() { release(); }
};
 
inline AsyncIO AsyncIOFromFile(StringParam file, StringParam mode)
{
  return AsyncIO(std::move(file), std::move(mode));
}
 
inline Sint64 GetAsyncIOSize(AsyncIOParam asyncio)
{
  return CheckError(SDL_GetAsyncIOSize(asyncio));
}
 
inline Sint64 AsyncIO::GetSize() { return SDL::GetAsyncIOSize(m_resource); }
 
inline void ReadAsyncIO(AsyncIOParam asyncio,
                        void* ptr,
                        Uint64 offset,
                        Uint64 size,
                        AsyncIOQueueParam queue,
                        void* userdata)
{
  CheckError(SDL_ReadAsyncIO(asyncio, ptr, offset, size, queue, userdata));
}
 
inline void AsyncIO::Read(void* ptr,
                          Uint64 offset,
                          Uint64 size,
                          AsyncIOQueueParam queue,
                          void* userdata)
{
  SDL::ReadAsyncIO(m_resource, ptr, offset, size, queue, userdata);
}
 
inline void WriteAsyncIO(AsyncIOParam asyncio,
                         void* ptr,
                         Uint64 offset,
                         Uint64 size,
                         AsyncIOQueueParam queue,
                         void* userdata)
{
  CheckError(SDL_WriteAsyncIO(asyncio, ptr, offset, size, queue, userdata));
}
 
inline void AsyncIO::Write(void* ptr,
                           Uint64 offset,
                           Uint64 size,
                           AsyncIOQueueParam queue,
                           void* userdata)
{
  SDL::WriteAsyncIO(m_resource, ptr, offset, size, queue, userdata);
}
 
inline bool CloseAsyncIO(AsyncIORaw asyncio,
                         bool flush,
                         AsyncIOQueueParam queue,
                         void* userdata)
{
  return SDL_CloseAsyncIO(asyncio, flush, queue, userdata);
}
 
inline bool AsyncIO::Close(bool flush, AsyncIOQueueParam queue, void* userdata)
{
  return CloseAsyncIO(release(), flush, queue, userdata);
}
 
inline AsyncIOQueue CreateAsyncIOQueue() { return AsyncIOQueue(); }
 
inline void DestroyAsyncIOQueue(AsyncIOQueueRaw queue)
{
  SDL_DestroyAsyncIOQueue(queue);
}
 
inline void AsyncIOQueue::Destroy() { DestroyAsyncIOQueue(release()); }
 
inline std::optional<AsyncIOOutcome> GetAsyncIOResult(AsyncIOQueueParam queue)
{
  if (AsyncIOOutcome outcome; SDL_GetAsyncIOResult(queue, &outcome)) {
    return outcome;
  }
  return std::nullopt;
}
 
inline std::optional<AsyncIOOutcome> AsyncIOQueue::GetResult()
{
  return SDL::GetAsyncIOResult(m_resource);
}
 
inline std::optional<AsyncIOOutcome> WaitAsyncIOResult(AsyncIOQueueParam queue,
                                                       Milliseconds timeout)
{
  if (AsyncIOOutcome outcome;
      SDL_WaitAsyncIOResult(queue, &outcome, timeout.count())) {
    return outcome;
  }
  return std::nullopt;
}
 
inline std::optional<AsyncIOOutcome> WaitAsyncIOResult(AsyncIOQueueParam queue)
{
  if (AsyncIOOutcome outcome; SDL_WaitAsyncIOResult(queue, &outcome, -1)) {
    return outcome;
  }
  return std::nullopt;
}
 
inline std::optional<AsyncIOOutcome> AsyncIOQueue::WaitResult(
  Milliseconds timeout)
{
  return SDL::WaitAsyncIOResult(m_resource, timeout);
}
 
inline std::optional<AsyncIOOutcome> AsyncIOQueue::WaitResult()
{
  return SDL::WaitAsyncIOResult(m_resource);
}
 
inline void SignalAsyncIOQueue(AsyncIOQueueParam queue)
{
  SDL_SignalAsyncIOQueue(queue);
}
 
inline void AsyncIOQueue::Signal() { SDL::SignalAsyncIOQueue(m_resource); }
 
inline void LoadFileAsync(StringParam file,
                          AsyncIOQueueParam queue,
                          void* userdata)
{
  CheckError(SDL_LoadFileAsync(file, queue, userdata));
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_ASYNCIO_H_ */