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*;

using AsyncIORef = ResourceRef<AsyncIO>;
 
// Forward decl
struct AsyncIOQueue;

using AsyncIOQueueRaw = SDL_AsyncIOQueue*;

using AsyncIOQueueRef = ResourceRef<AsyncIOQueue>;

struct AsyncIO : ResourceBase<AsyncIORaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit AsyncIO(AsyncIORaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr AsyncIO(const AsyncIO& other) = delete;

  constexpr AsyncIO(AsyncIO&& other) noexcept
    : AsyncIO(other.release())
  {
  }
 
  constexpr AsyncIO(const AsyncIORef& other) = delete;
 
  constexpr AsyncIO(AsyncIORef&& other) = delete;

  AsyncIO(StringParam file, StringParam mode);

  ~AsyncIO()
  {
    if (get()) {
      LOG_CATEGORY_ERROR.LogDebug("AsyncIO ID was not properly Destroyed: {}",
                                  (void*)(get()));
    }
  }

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

  AsyncIO& operator=(const AsyncIO& other) = delete;

  bool Close(bool flush, AsyncIOQueueRef queue, void* userdata);

  Sint64 GetSize();

  void Read(void* ptr,
            Uint64 offset,
            Uint64 size,
            AsyncIOQueueRef queue,
            void* userdata);

  void Write(void* ptr,
             Uint64 offset,
             Uint64 size,
             AsyncIOQueueRef queue,
             void* userdata);
};

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;

struct AsyncIOQueue : ResourceBase<AsyncIOQueueRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit AsyncIOQueue(AsyncIOQueueRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr AsyncIOQueue(const AsyncIOQueue& other) = delete;

  constexpr AsyncIOQueue(AsyncIOQueue&& other) noexcept
    : AsyncIOQueue(other.release())
  {
  }
 
  constexpr AsyncIOQueue(const AsyncIOQueueRef& other) = delete;
 
  constexpr AsyncIOQueue(AsyncIOQueueRef&& other) = delete;

  AsyncIOQueue();

  ~AsyncIOQueue() { SDL_DestroyAsyncIOQueue(get()); }

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

  AsyncIOQueue& operator=(const AsyncIOQueue& other) = delete;

  void Destroy();

  std::optional<AsyncIOOutcome> GetResult();

  std::optional<AsyncIOOutcome> WaitResult(Milliseconds timeout);

  std::optional<AsyncIOOutcome> WaitResult();

  void Signal();
};

inline AsyncIO AsyncIOFromFile(StringParam file, StringParam mode)
{
  return AsyncIO(std::move(file), std::move(mode));
}
 
inline AsyncIO::AsyncIO(StringParam file, StringParam mode)
  : AsyncIO(SDL_AsyncIOFromFile(file, mode))
{
}

inline Sint64 GetAsyncIOSize(AsyncIORef asyncio)
{
  return CheckError(SDL_GetAsyncIOSize(asyncio));
}
 
inline Sint64 AsyncIO::GetSize() { return SDL::GetAsyncIOSize(get()); }

inline void ReadAsyncIO(AsyncIORef asyncio,
                        void* ptr,
                        Uint64 offset,
                        Uint64 size,
                        AsyncIOQueueRef queue,
                        void* userdata)
{
  CheckError(SDL_ReadAsyncIO(asyncio, ptr, offset, size, queue, userdata));
}
 
inline void AsyncIO::Read(void* ptr,
                          Uint64 offset,
                          Uint64 size,
                          AsyncIOQueueRef queue,
                          void* userdata)
{
  SDL::ReadAsyncIO(get(), ptr, offset, size, queue, userdata);
}

inline void WriteAsyncIO(AsyncIORef asyncio,
                         void* ptr,
                         Uint64 offset,
                         Uint64 size,
                         AsyncIOQueueRef queue,
                         void* userdata)
{
  CheckError(SDL_WriteAsyncIO(asyncio, ptr, offset, size, queue, userdata));
}
 
inline void AsyncIO::Write(void* ptr,
                           Uint64 offset,
                           Uint64 size,
                           AsyncIOQueueRef queue,
                           void* userdata)
{
  SDL::WriteAsyncIO(get(), ptr, offset, size, queue, userdata);
}

inline bool CloseAsyncIO(AsyncIORaw asyncio,
                         bool flush,
                         AsyncIOQueueRef queue,
                         void* userdata)
{
  return SDL_CloseAsyncIO(asyncio, flush, queue, userdata);
}
 
inline bool AsyncIO::Close(bool flush, AsyncIOQueueRef queue, void* userdata)
{
  return CloseAsyncIO(release(), flush, queue, userdata);
}

inline AsyncIOQueue CreateAsyncIOQueue() { return AsyncIOQueue(); }
 
inline AsyncIOQueue::AsyncIOQueue()
  : AsyncIOQueue(SDL_CreateAsyncIOQueue())
{
}

inline void DestroyAsyncIOQueue(AsyncIOQueueRaw queue)
{
  SDL_DestroyAsyncIOQueue(queue);
}
 
inline void AsyncIOQueue::Destroy() { DestroyAsyncIOQueue(release()); }

inline std::optional<AsyncIOOutcome> GetAsyncIOResult(AsyncIOQueueRef queue)
{
  if (AsyncIOOutcome outcome; SDL_GetAsyncIOResult(queue, &outcome)) {
    return outcome;
  }
  return std::nullopt;
}
 
inline std::optional<AsyncIOOutcome> AsyncIOQueue::GetResult()
{
  return SDL::GetAsyncIOResult(get());
}

inline std::optional<AsyncIOOutcome> WaitAsyncIOResult(AsyncIOQueueRef queue,
                                                       Milliseconds timeout)
{
  if (AsyncIOOutcome outcome;
      SDL_WaitAsyncIOResult(queue, &outcome, narrowS32(timeout.count()))) {
    return outcome;
  }
  return std::nullopt;
}

inline std::optional<AsyncIOOutcome> WaitAsyncIOResult(AsyncIOQueueRef 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(get(), timeout);
}
 
inline std::optional<AsyncIOOutcome> AsyncIOQueue::WaitResult()
{
  return SDL::WaitAsyncIOResult(get());
}

inline void SignalAsyncIOQueue(AsyncIOQueueRef queue)
{
  SDL_SignalAsyncIOQueue(queue);
}
 
inline void AsyncIOQueue::Signal() { SDL::SignalAsyncIOQueue(get()); }

inline void LoadFileAsync(StringParam file,
                          AsyncIOQueueRef queue,
                          void* userdata)
{
  CheckError(SDL_LoadFileAsync(file, queue, userdata));
}

 
} // namespace SDL
 
#endif /* SDL3PP_ASYNCIO_H_ */