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

using IOStreamRaw = SDL_IOStream*;

using IOStreamRef = ResourceRef<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 IOStream : ResourceBase<IOStreamRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit IOStream(IOStreamRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr IOStream(const IOStream& other) = delete;

  constexpr IOStream(IOStream&& other) noexcept
    : IOStream(other.release())
  {
  }
 
  constexpr IOStream(const IOStreamRef& other) = delete;
 
  constexpr IOStream(IOStreamRef&& other) = delete;

  static IOStream FromFile(StringParam file, StringParam mode);

  static IOStream FromMem(TargetBytes mem);

  static IOStream FromConstMem(SourceBytes mem);

  static IOStream FromDynamicMem();

  static IOStream Open(const IOStreamInterface& iface, void* userdata);

  ~IOStream() { SDL_CloseIO(get()); }

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

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

  void Close();

  PropertiesRef GetProperties() const;

  IOStatus GetStatus() const;

  Sint64 GetSize() const;

  Sint64 Seek(Sint64 offset, IOWhence whence);

  Sint64 Tell() const;

  std::string Read(size_t size = -1)
  {
    Sint64 pos = Tell();
    if (auto curSize = SDL_GetIOSize(get()); curSize < 0 || pos < 0) {
      if (size == size_t(-1)) return {};
    } else if (curSize - pos <= 0) {
      return {};
    } else if (size_t(curSize - pos) < size) {
      size = curSize - pos;
    }
    std::string result(size, 0);
    if (auto actualSize = Read(result); actualSize < size) {
      result.resize(actualSize);
    }
    return result;
  }

  size_t Read(TargetBytes buf);

  size_t Write(SourceBytes buf);

  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 = SDL_IOvprintf(get(), fmt, ap);
    va_end(ap);
 
    return result;
  }

  size_t vprintf(SDL_PRINTF_FORMAT_STRING const char* fmt, va_list ap);

  void Flush();

  StringResult LoadFile();

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

  Uint8 ReadU8();

  Sint8 ReadS8();

  Uint16 ReadU16LE();

  Sint16 ReadS16LE();

  Uint16 ReadU16BE();

  Sint16 ReadS16BE();

  Uint32 ReadU32LE();

  Sint32 ReadS32LE();

  Uint32 ReadU32BE();

  Sint32 ReadS32BE();

  Uint64 ReadU64LE();

  Sint64 ReadS64LE();

  Uint64 ReadU64BE();

  Sint64 ReadS64BE();

  std::optional<Uint8> TryReadU8() const
  {
    if (Uint8 value; SDL_ReadU8(get(), &value)) return value;
    return {};
  }

  std::optional<Sint8> TryReadS8() const
  {
    if (Sint8 value; SDL_ReadS8(get(), &value)) return value;
    return {};
  }

  std::optional<Uint16> TryReadU16LE() const
  {
    if (Uint16 value; SDL_ReadU16LE(get(), &value)) return value;
    return {};
  }

  std::optional<Sint16> TryReadS16LE() const
  {
    if (Sint16 value; SDL_ReadS16LE(get(), &value)) return value;
    return {};
  }

  std::optional<Uint16> TryReadU16BE() const
  {
    if (Uint16 value; SDL_ReadU16BE(get(), &value)) return value;
    return {};
  }

  std::optional<Sint16> TryReadS16BE() const
  {
    if (Sint16 value; SDL_ReadS16BE(get(), &value)) return value;
    return {};
  }

  std::optional<Uint32> TryReadU32LE() const
  {
    if (Uint32 value; SDL_ReadU32LE(get(), &value)) return value;
    return {};
  }

  std::optional<Sint32> TryReadS32LE() const
  {
    if (Sint32 value; SDL_ReadS32LE(get(), &value)) return value;
    return {};
  }

  std::optional<Uint32> TryReadU32BE() const
  {
    if (Uint32 value; SDL_ReadU32BE(get(), &value)) return value;
    return {};
  }

  std::optional<Sint32> TryReadS32BE() const
  {
    if (Sint32 value; SDL_ReadS32BE(get(), &value)) return value;
    return {};
  }

  std::optional<Uint64> TryReadU64LE() const
  {
    if (Uint64 value; SDL_ReadU64LE(get(), &value)) return value;
    return {};
  }

  std::optional<Sint64> TryReadS64LE() const
  {
    if (Sint64 value; SDL_ReadS64LE(get(), &value)) return value;
    return {};
  }

  std::optional<Uint64> TryReadU64BE() const
  {
    if (Uint64 value; SDL_ReadU64BE(get(), &value)) return value;
    return {};
  }

  std::optional<Sint64> TryReadS64BE() const
  {
    if (Sint64 value; SDL_ReadS64BE(get(), &value)) return value;
    return {};
  }

  void WriteU8(Uint8 value);

  void WriteS8(Sint8 value);

  void WriteU16LE(Uint16 value);

  void WriteS16LE(Sint16 value);

  void WriteU16BE(Uint16 value);

  void WriteS16BE(Sint16 value);

  void WriteU32LE(Uint32 value);

  void WriteS32LE(Sint32 value);

  void WriteU32BE(Uint32 value);

  void WriteS32BE(Sint32 value);

  void WriteU64LE(Uint64 value);

  void WriteS64LE(Sint64 value);

  void WriteU64BE(Uint64 value);

  void WriteS64BE(Sint64 value);
};

inline IOStream IOFromFile(StringParam file, StringParam mode)
{
  return IOStream(SDL_IOFromFile(file, mode));
}
 
inline IOStream IOStream::FromFile(StringParam file, StringParam mode)
{
  return SDL::IOFromFile(std::move(file), std::move(mode));
}

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; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto MEMORY_FREE_FUNC_POINTER =
  SDL_PROP_IOSTREAM_MEMORY_FREE_FUNC_POINTER; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
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(CheckError(SDL_IOFromMem(mem.data(), mem.size_bytes())));
}
 
inline IOStream IOStream::FromMem(TargetBytes mem)
{
  return SDL::IOFromMem(std::move(mem));
}

inline IOStream IOFromConstMem(SourceBytes mem)
{
  return IOStream(CheckError(SDL_IOFromConstMem(mem.data(), mem.size_bytes())));
}
 
inline IOStream IOStream::FromConstMem(SourceBytes mem)
{
  return SDL::IOFromConstMem(std::move(mem));
}

inline IOStream IOFromDynamicMem() { return IOStream(SDL_IOFromDynamicMem()); }
 
inline IOStream IOStream::FromDynamicMem() { return SDL::IOFromDynamicMem(); }

inline IOStream OpenIO(const IOStreamInterface& iface, void* userdata)
{
  return IOStream(CheckError(SDL_OpenIO(&iface, userdata)));
}
 
inline IOStream IOStream::Open(const IOStreamInterface& iface, void* userdata)
{
  return SDL::OpenIO(iface, userdata);
}

inline void CloseIO(IOStreamRaw context) { CheckError(SDL_CloseIO(context)); }
 
inline void IOStream::Close() { CloseIO(release()); }

inline PropertiesRef GetIOProperties(IOStreamRef context)
{
  return {CheckError(SDL_GetIOProperties(context))};
}
 
inline PropertiesRef IOStream::GetProperties() const
{
  return SDL::GetIOProperties(get());
}

inline IOStatus GetIOStatus(IOStreamRef context)
{
  return SDL_GetIOStatus(context);
}
 
inline IOStatus IOStream::GetStatus() const { return SDL::GetIOStatus(get()); }

inline Sint64 GetIOSize(IOStreamRef context)
{
  return CheckError(SDL_GetIOSize(context));
}
 
inline Sint64 IOStream::GetSize() const { return SDL::GetIOSize(get()); }

inline Sint64 SeekIO(IOStreamRef context, Sint64 offset, IOWhence whence)
{
  return SDL_SeekIO(context, offset, whence);
}
 
inline Sint64 IOStream::Seek(Sint64 offset, IOWhence whence)
{
  return SDL::SeekIO(get(), offset, whence);
}

inline Sint64 TellIO(IOStreamRef context) { return SDL_TellIO(context); }
 
inline Sint64 IOStream::Tell() const { return SDL::TellIO(get()); }

inline size_t ReadIO(IOStreamRef context, TargetBytes buf)
{
  return SDL_ReadIO(context, buf.data(), buf.size_bytes());
}
 
inline size_t IOStream::Read(TargetBytes buf)
{
  return SDL::ReadIO(get(), std::move(buf));
}

inline size_t WriteIO(IOStreamRef context, SourceBytes buf)
{
  return SDL_WriteIO(context, buf.data(), buf.size_bytes());
}
 
inline size_t IOStream::Write(SourceBytes buf)
{
  return SDL::WriteIO(get(), std::move(buf));
}

inline size_t IOprintf(IOStreamRef context,
                       SDL_PRINTF_FORMAT_STRING const char* fmt,
                       ...)
{
  va_list ap;
  size_t result;
 
  va_start(ap, fmt);
  result = SDL_IOvprintf(context, fmt, ap);
  va_end(ap);
 
  return result;
}

inline size_t IOvprintf(IOStreamRef context,
                        SDL_PRINTF_FORMAT_STRING const char* fmt,
                        va_list ap)
{
  return SDL_IOvprintf(context, fmt, ap);
}
 
inline size_t IOStream::vprintf(SDL_PRINTF_FORMAT_STRING const char* fmt,
                                va_list ap)
{
  return SDL::IOvprintf(get(), fmt, ap);
}

inline void FlushIO(IOStreamRef context) { CheckError(SDL_FlushIO(context)); }
 
inline void IOStream::Flush() { SDL::FlushIO(get()); }

inline StringResult LoadFile_IO(IOStreamRef src, bool closeio = true)
{
  size_t datasize = 0;
  auto data = static_cast<char*>(SDL_LoadFile_IO(src, &datasize, closeio));
  return StringResult{CheckError(data), datasize};
}
 
inline StringResult IOStream::LoadFile() { return SDL::LoadFile_IO(get()); }

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 StringResult LoadFile(StringParam file)
{
  size_t datasize = 0;
  auto data = static_cast<char*>(SDL_LoadFile(file, &datasize));
  return StringResult{CheckError(data), datasize};
}

inline void SaveFile_IO(IOStreamRef src, SourceBytes data, bool closeio = true)
{
  CheckError(SDL_SaveFile_IO(src, data.data(), data.size_bytes(), closeio));
}
 
inline void IOStream::SaveFile(SourceBytes data)
{
  SDL::SaveFile_IO(get(), std::move(data));
}

inline void SaveFile(StringParam file, SourceBytes data)
{
  CheckError(SDL_SaveFile(file, data.data(), data.size_bytes()));
}

inline Uint8 ReadU8(IOStreamRef src)
{
  Uint8 value;
  CheckError(SDL_ReadU8(src, &value));
  return value;
}
 
inline Uint8 IOStream::ReadU8() { return SDL::ReadU8(get()); }

inline Sint8 ReadS8(IOStreamRef src)
{
  Sint8 value;
  CheckError(SDL_ReadS8(src, &value));
  return value;
}
 
inline Sint8 IOStream::ReadS8() { return SDL::ReadS8(get()); }

inline Uint16 ReadU16LE(IOStreamRef src)
{
  Uint16 value;
  CheckError(SDL_ReadU16LE(src, &value));
  return value;
}
 
inline Uint16 IOStream::ReadU16LE() { return SDL::ReadU16LE(get()); }

inline Sint16 ReadS16LE(IOStreamRef src)
{
  Sint16 value;
  CheckError(SDL_ReadS16LE(src, &value));
  return value;
}
 
inline Sint16 IOStream::ReadS16LE() { return SDL::ReadS16LE(get()); }

inline Uint16 ReadU16BE(IOStreamRef src)
{
  Uint16 value;
  CheckError(SDL_ReadU16BE(src, &value));
  return value;
}
 
inline Uint16 IOStream::ReadU16BE() { return SDL::ReadU16BE(get()); }

inline Sint16 ReadS16BE(IOStreamRef src)
{
  Sint16 value;
  CheckError(SDL_ReadS16BE(src, &value));
  return value;
}
 
inline Sint16 IOStream::ReadS16BE() { return SDL::ReadS16BE(get()); }

inline Uint32 ReadU32LE(IOStreamRef src)
{
  Uint32 value;
  CheckError(SDL_ReadU32LE(src, &value));
  return value;
}
 
inline Uint32 IOStream::ReadU32LE() { return SDL::ReadU32LE(get()); }

inline Sint32 ReadS32LE(IOStreamRef src)
{
  Sint32 value;
  CheckError(SDL_ReadS32LE(src, &value));
  return value;
}
 
inline Sint32 IOStream::ReadS32LE() { return SDL::ReadS32LE(get()); }

inline Uint32 ReadU32BE(IOStreamRef src)
{
  Uint32 value;
  CheckError(SDL_ReadU32BE(src, &value));
  return value;
}
 
inline Uint32 IOStream::ReadU32BE() { return SDL::ReadU32BE(get()); }

inline Sint32 ReadS32BE(IOStreamRef src)
{
  Sint32 value;
  CheckError(SDL_ReadS32BE(src, &value));
  return value;
}
 
inline Sint32 IOStream::ReadS32BE() { return SDL::ReadS32BE(get()); }

inline Uint64 ReadU64LE(IOStreamRef src)
{
  Uint64 value;
  CheckError(SDL_ReadU64LE(src, &value));
  return value;
}
 
inline Uint64 IOStream::ReadU64LE() { return SDL::ReadU64LE(get()); }

inline Sint64 ReadS64LE(IOStreamRef src)
{
  Sint64 value;
  CheckError(SDL_ReadS64LE(src, &value));
  return value;
}
 
inline Sint64 IOStream::ReadS64LE() { return SDL::ReadS64LE(get()); }

inline Uint64 ReadU64BE(IOStreamRef src)
{
  Uint64 value;
  CheckError(SDL_ReadU64BE(src, &value));
  return value;
}
 
inline Uint64 IOStream::ReadU64BE() { return SDL::ReadU64BE(get()); }

inline Sint64 ReadS64BE(IOStreamRef src)
{
  Sint64 value;
  CheckError(SDL_ReadS64BE(src, &value));
  return value;
}
 
inline Sint64 IOStream::ReadS64BE() { return SDL::ReadS64BE(get()); }

inline void WriteU8(IOStreamRef dst, Uint8 value)
{
  CheckError(SDL_WriteU8(dst, value));
}
 
inline void IOStream::WriteU8(Uint8 value) { SDL::WriteU8(get(), value); }

inline void WriteS8(IOStreamRef dst, Sint8 value)
{
  CheckError(SDL_WriteS8(dst, value));
}
 
inline void IOStream::WriteS8(Sint8 value) { SDL::WriteS8(get(), value); }

inline void WriteU16LE(IOStreamRef dst, Uint16 value)
{
  CheckError(SDL_WriteU16LE(dst, value));
}
 
inline void IOStream::WriteU16LE(Uint16 value)
{
  SDL::WriteU16LE(get(), value);
}

inline void WriteS16LE(IOStreamRef dst, Sint16 value)
{
  CheckError(SDL_WriteS16LE(dst, value));
}
 
inline void IOStream::WriteS16LE(Sint16 value)
{
  SDL::WriteS16LE(get(), value);
}

inline void WriteU16BE(IOStreamRef dst, Uint16 value)
{
  CheckError(SDL_WriteU16BE(dst, value));
}
 
inline void IOStream::WriteU16BE(Uint16 value)
{
  SDL::WriteU16BE(get(), value);
}

inline void WriteS16BE(IOStreamRef dst, Sint16 value)
{
  CheckError(SDL_WriteS16BE(dst, value));
}
 
inline void IOStream::WriteS16BE(Sint16 value)
{
  SDL::WriteS16BE(get(), value);
}

inline void WriteU32LE(IOStreamRef dst, Uint32 value)
{
  CheckError(SDL_WriteU32LE(dst, value));
}
 
inline void IOStream::WriteU32LE(Uint32 value)
{
  SDL::WriteU32LE(get(), value);
}

inline void WriteS32LE(IOStreamRef dst, Sint32 value)
{
  CheckError(SDL_WriteS32LE(dst, value));
}
 
inline void IOStream::WriteS32LE(Sint32 value)
{
  SDL::WriteS32LE(get(), value);
}

inline void WriteU32BE(IOStreamRef dst, Uint32 value)
{
  CheckError(SDL_WriteU32BE(dst, value));
}
 
inline void IOStream::WriteU32BE(Uint32 value)
{
  SDL::WriteU32BE(get(), value);
}

inline void WriteS32BE(IOStreamRef dst, Sint32 value)
{
  CheckError(SDL_WriteS32BE(dst, value));
}
 
inline void IOStream::WriteS32BE(Sint32 value)
{
  SDL::WriteS32BE(get(), value);
}

inline void WriteU64LE(IOStreamRef dst, Uint64 value)
{
  CheckError(SDL_WriteU64LE(dst, value));
}
 
inline void IOStream::WriteU64LE(Uint64 value)
{
  SDL::WriteU64LE(get(), value);
}

inline void WriteS64LE(IOStreamRef dst, Sint64 value)
{
  CheckError(SDL_WriteS64LE(dst, value));
}
 
inline void IOStream::WriteS64LE(Sint64 value)
{
  SDL::WriteS64LE(get(), value);
}

inline void WriteU64BE(IOStreamRef dst, Uint64 value)
{
  CheckError(SDL_WriteU64BE(dst, value));
}
 
inline void IOStream::WriteU64BE(Uint64 value)
{
  SDL::WriteU64BE(get(), value);
}

inline void WriteS64BE(IOStreamRef dst, Sint64 value)
{
  CheckError(SDL_WriteS64BE(dst, value));
}
 
inline void IOStream::WriteS64BE(Sint64 value)
{
  SDL::WriteS64BE(get(), value);
}

 
} // namespace SDL
 
#endif /* SDL3PP_IOSTREAM_H_ */