SDL3pp_iostream.h

#ifndef SDL3PP_IOSTREAM_H_
#define SDL3PP_IOSTREAM_H_
 
#include <SDL3/SDL_iostream.h>
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct IOStreamBase;
 
// Forward decl
struct IOStreamRef;
 
// Forward decl
struct IOStream;
 
using IOStatus = SDL_IOStatus;
 
constexpr IOStatus IO_STATUS_READY =
  SDL_IO_STATUS_READY; 
 
constexpr IOStatus IO_STATUS_ERROR =
  SDL_IO_STATUS_ERROR; 
 
constexpr IOStatus IO_STATUS_EOF = SDL_IO_STATUS_EOF; 
 
constexpr IOStatus IO_STATUS_NOT_READY =
  SDL_IO_STATUS_NOT_READY; 
 
constexpr IOStatus IO_STATUS_READONLY =
  SDL_IO_STATUS_READONLY; 
 
constexpr IOStatus IO_STATUS_WRITEONLY =
  SDL_IO_STATUS_WRITEONLY; 
 
using IOWhence = SDL_IOWhence;
 
constexpr IOWhence IO_SEEK_SET =
  SDL_IO_SEEK_SET; 
 
constexpr IOWhence IO_SEEK_CUR =
  SDL_IO_SEEK_CUR; 
 
constexpr IOWhence IO_SEEK_END =
  SDL_IO_SEEK_END; 
 
using IOStreamInterface = SDL_IOStreamInterface;
 
struct IOStreamBase : Resource<SDL_IOStream*>
{
  using Resource::Resource;
 
  IOStreamBase(StringParam file, StringParam mode)
    : Resource(SDL_IOFromFile(file, mode))
  {
  }
 
  IOStreamBase(const IOStreamInterface& iface, void* userdata)
    : Resource(CheckError(SDL_OpenIO(&iface, userdata)))
  {
  }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetIOProperties(get()));
  }
 
  IOStatus GetStatus() const { return SDL_GetIOStatus(get()); }
 
  Sint64 GetSize() const
  {
    auto size = SDL_GetIOSize(get());
    if (size < 0) throw Error{};
    return size;
  }
 
  Sint64 Seek(Sint64 offset, IOWhence whence)
  {
    return SDL_SeekIO(get(), offset, whence);
  }
 
  Sint64 Tell() const { return SDL_TellIO(get()); }
 
  std::string Read(size_t size = -1)
  {
    Sint64 pos = Tell();
    auto curSize = SDL_GetIOSize(get());
    if ((curSize < 0 || pos < 0)) {
      if (size == size_t(-1)) return {};
    } else if (curSize - pos <= 0) {
      return {};
    } else if (curSize - pos < size) {
      size = curSize - pos;
    }
    std::string result(size, 0);
    auto actualSize = Read(result);
    if (actualSize < size) result.resize(actualSize);
    return result;
  }
 
  size_t Read(TargetBytes buf)
  {
    return SDL_ReadIO(get(), buf.data, buf.size_bytes);
  }
 
  size_t Write(SourceBytes buf)
  {
    return SDL_WriteIO(get(), buf.data, buf.size_bytes);
  }
 
  size_t print(std::string_view fmt, auto... args)
  {
    return Write(std::vformat(fmt, std::make_format_args(args...)));
  }
 
  size_t println(std::string_view fmt, auto... args)
  {
    std::string result =
      std::vformat(fmt, std::make_format_args(args...)) + "\n";
    return Write(result);
  }
 
  size_t printf(SDL_PRINTF_FORMAT_STRING const char* fmt, ...)
  {
    va_list ap;
    size_t result;
 
    va_start(ap, fmt);
    result = vprintf(fmt, ap);
    va_end(ap);
 
    return result;
  }
 
  size_t vprintf(SDL_PRINTF_FORMAT_STRING const char* fmt, va_list ap)
  {
    return SDL_IOvprintf(get(), fmt, ap);
  }
 
  void Flush() { CheckError(SDL_FlushIO(get())); }
 
  StringResult LoadFile()
  {
    size_t datasize = 0;
    auto data = static_cast<char*>(SDL_LoadFile_IO(get(), &datasize, false));
    return StringResult{CheckError(data), datasize};
  }
 
  template<class T>
  OwnArray<T> LoadFileAs()
  {
    size_t datasize = 0;
    auto data = static_cast<T*>(SDL_LoadFile_IO(get(), &datasize, false));
    return OwnArray<T>{CheckError(data), datasize / sizeof(T)};
  }
 
  void SaveFile(SourceBytes data)
  {
    CheckError(SDL_SaveFile_IO(get(), data.data, data.size_bytes, false));
  }
 
  Uint8 ReadU8()
  {
    Uint8 value;
    CheckError(SDL_ReadU8(get(), &value));
    return value;
  }
 
  Sint8 ReadS8()
  {
    Sint8 value;
    CheckError(SDL_ReadS8(get(), &value));
    return value;
  }
 
  Uint16 ReadU16LE()
  {
    Uint16 value;
    CheckError(SDL_ReadU16LE(get(), &value));
    return value;
  }
 
  Sint16 ReadS16LE()
  {
    Sint16 value;
    CheckError(SDL_ReadS16LE(get(), &value));
    return value;
  }
 
  Uint16 ReadU16BE()
  {
    Uint16 value;
    CheckError(SDL_ReadU16BE(get(), &value));
    return value;
  }
 
  Sint16 ReadS16BE()
  {
    Sint16 value;
    CheckError(SDL_ReadS16BE(get(), &value));
    return value;
  }
 
  Uint32 ReadU32LE()
  {
    Uint32 value;
    CheckError(SDL_ReadU32LE(get(), &value));
    return value;
  }
 
  Sint32 ReadS32LE()
  {
    Sint32 value;
    CheckError(SDL_ReadS32LE(get(), &value));
    return value;
  }
 
  Uint32 ReadU32BE()
  {
    Uint32 value;
    CheckError(SDL_ReadU32BE(get(), &value));
    return value;
  }
 
  Sint32 ReadS32BE()
  {
    Sint32 value;
    CheckError(SDL_ReadS32BE(get(), &value));
    return value;
  }
 
  Uint64 ReadU64LE()
  {
    Uint64 value;
    CheckError(SDL_ReadU64LE(get(), &value));
    return value;
  }
 
  Sint64 ReadS64LE()
  {
    Sint64 value;
    CheckError(SDL_ReadS64LE(get(), &value));
    return value;
  }
 
  Uint64 ReadU64BE()
  {
    Uint64 value;
    CheckError(SDL_ReadU64BE(get(), &value));
    return value;
  }
 
  Sint64 ReadS64BE()
  {
    Sint64 value;
    CheckError(SDL_ReadS64BE(get(), &value));
    return value;
  }
 
  void WriteU8(Uint8 value) { CheckError(SDL_WriteU8(get(), value)); }
 
  void WriteS8(Sint8 value) { CheckError(SDL_WriteS8(get(), value)); }
 
  void WriteU16LE(Uint16 value) { CheckError(SDL_WriteU16LE(get(), value)); }
 
  void WriteS16LE(Sint16 value) { CheckError(SDL_WriteS16LE(get(), value)); }
 
  void WriteU16BE(Uint16 value) { CheckError(SDL_WriteU16BE(get(), value)); }
 
  void WriteS16BE(Sint16 value) { CheckError(SDL_WriteS16BE(get(), value)); }
 
  void WriteU32LE(Uint32 value) { CheckError(SDL_WriteU32LE(get(), value)); }
 
  void WriteS32LE(Sint32 value) { CheckError(SDL_WriteS32LE(get(), value)); }
 
  void WriteU32BE(Uint32 value) { CheckError(SDL_WriteU32BE(get(), value)); }
 
  void WriteS32BE(Sint32 value) { CheckError(SDL_WriteS32BE(get(), value)); }
 
  void WriteU64LE(Uint64 value) { CheckError(SDL_WriteU64LE(get(), value)); }
 
  void WriteS64LE(Sint64 value) { CheckError(SDL_WriteS64LE(get(), value)); }
 
  void WriteU64BE(Uint64 value) { CheckError(SDL_WriteU64BE(get(), value)); }
 
  void WriteS64BE(Sint64 value) { CheckError(SDL_WriteS64BE(get(), value)); }
 
  std::optional<Uint8> TryReadU8()
  {
    if (Uint8 value; SDL_ReadU8(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint8> TryReadS8()
  {
    if (Sint8 value; SDL_ReadS8(get(), &value)) return value;
    return {};
  }
 
  std::optional<Uint16> TryReadU16LE()
  {
    if (Uint16 value; SDL_ReadU16LE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint16> TryReadS16LE()
  {
    if (Sint16 value; SDL_ReadS16LE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Uint16> TryReadU16BE()
  {
    if (Uint16 value; SDL_ReadU16BE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint16> TryReadS16BE()
  {
    if (Sint16 value; SDL_ReadS16BE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Uint32> TryReadU32LE()
  {
    if (Uint32 value; SDL_ReadU32LE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint32> TryReadS32LE()
  {
    if (Sint32 value; SDL_ReadS32LE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Uint32> TryReadU32BE()
  {
    if (Uint32 value; SDL_ReadU32BE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint32> TryReadS32BE()
  {
    if (Sint32 value; SDL_ReadS32BE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Uint64> TryReadU64LE()
  {
    if (Uint64 value; SDL_ReadU64LE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint64> TryReadS64LE()
  {
    if (Sint64 value; SDL_ReadS64LE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Uint64> TryReadU64BE()
  {
    if (Uint64 value; SDL_ReadU64BE(get(), &value)) return value;
    return {};
  }
 
  std::optional<Sint64> TryReadS64BE()
  {
    if (Sint64 value; SDL_ReadS64BE(get(), &value)) return value;
    return {};
  }
};
 
struct IOStreamRef : IOStreamBase
{
  using IOStreamBase::IOStreamBase;
 
  constexpr IOStreamRef(const IOStreamRef& other)
    : IOStreamBase(other.get())
  {
  }
 
  constexpr IOStreamRef(IOStreamRef&& other)
    : IOStreamBase(other.release())
  {
  }
 
  constexpr ~IOStreamRef() = default;
 
  IOStreamRef& operator=(IOStreamRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_IOStream* newResource = {})
  {
    CheckError(SDL_CloseIO(release(newResource)));
  }
 
  void Close() { reset(); }
};
 
struct IOStream : IOStreamRef
{
  using IOStreamRef::IOStreamRef;
 
  constexpr explicit IOStream(SDL_IOStream* resource = {})
    : IOStreamRef(resource)
  {
  }
 
  constexpr IOStream(const IOStream& other) = delete;
 
  constexpr IOStream(IOStream&& other) = default;
 
  ~IOStream() { reset(); }
 
  IOStream& operator=(IOStream other)
  {
    reset(other.release());
    return *this;
  }
};
 
namespace prop::IOStream {
 
constexpr auto WINDOWS_HANDLE_POINTER =
  SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER;
 
constexpr auto STDIO_FILE_POINTER = SDL_PROP_IOSTREAM_STDIO_FILE_POINTER;
 
constexpr auto FILE_DESCRIPTOR_NUMBER =
  SDL_PROP_IOSTREAM_FILE_DESCRIPTOR_NUMBER;
 
constexpr auto ANDROID_AASSET_POINTER =
  SDL_PROP_IOSTREAM_ANDROID_AASSET_POINTER;
 
constexpr auto MEMORY_POINTER = SDL_PROP_IOSTREAM_MEMORY_POINTER;
 
constexpr auto MEMORY_SIZE_NUMBER = SDL_PROP_IOSTREAM_MEMORY_SIZE_NUMBER;
 
constexpr auto DYNAMIC_MEMORY_POINTER =
  SDL_PROP_IOSTREAM_DYNAMIC_MEMORY_POINTER;
 
constexpr auto DYNAMIC_CHUNKSIZE_NUMBER =
  SDL_PROP_IOSTREAM_DYNAMIC_CHUNKSIZE_NUMBER;
 
} // namespace prop::IOStream
 
inline IOStream IOFromMem(TargetBytes mem)
{
  return IOStream{SDL_IOFromMem(mem.data, mem.size_bytes)};
}
 
inline IOStream IOFromConstMem(SourceBytes mem)
{
  return IOStream{SDL_IOFromConstMem(mem.data, mem.size_bytes)};
}
 
inline IOStream IOFromDynamicMem() { return IOStream{SDL_IOFromDynamicMem()}; }
 
inline StringResult LoadFile(StringParam file)
{
  size_t datasize = 0;
  auto data = static_cast<char*>(SDL_LoadFile(file, &datasize));
  return StringResult{CheckError(data), datasize};
}
 
template<class T>
inline OwnArray<T> LoadFileAs(StringParam file)
{
  size_t datasize = 0;
  auto data = static_cast<T*>(SDL_LoadFile(file, &datasize));
  return OwnArray<T>{CheckError(data), datasize / sizeof(T)};
}
 
inline void SaveFile(StringParam file, SourceBytes data)
{
  CheckError(SDL_SaveFile(file, data.data, data.size_bytes));
}
 
#pragma region impl
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_IOSTREAM_H_ */