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*;
 
// Forward decl
struct IOStreamRef;
 
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;
 
class IOStream
{
  IOStreamRaw m_resource = nullptr;
 
public:
  constexpr IOStream(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit IOStream(const IOStreamRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr IOStream(const IOStream& other) noexcept = default;
 
public:
  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(m_resource); }
 
  constexpr IOStream& operator=(IOStream&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr IOStream& operator=(const IOStream& other) noexcept = default;
 
public:
  constexpr IOStreamRaw get() const noexcept { return m_resource; }
 
  constexpr IOStreamRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const IOStream& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  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();
    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);
 
  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 = vprintf(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()
  {
    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 {};
  }
 
  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);
};
 
struct IOStreamRef : IOStream
{
  using IOStream::IOStream;
 
  IOStreamRef(IOStreamRaw resource) noexcept
    : IOStream(resource)
  {
  }
 
  constexpr IOStreamRef(const IOStream& resource) noexcept
    : IOStream(resource.get())
  {
  }
 
  constexpr IOStreamRef(IOStream&& resource) noexcept
    : IOStream(std::move(resource).release())
  {
  }
 
  constexpr IOStreamRef(const IOStreamRef& other) noexcept
    : IOStream(other.get())
  {
  }
 
  constexpr IOStreamRef(IOStreamRef&& other) noexcept
    : IOStream(other.get())
  {
  }
 
  ~IOStreamRef() { release(); }
 
  constexpr IOStreamRef& operator=(const IOStreamRef& other) noexcept = default;
 
  constexpr operator IOStreamRaw() const noexcept { return get(); }
};
 
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(m_resource);
}
 
inline IOStatus GetIOStatus(IOStreamRef context)
{
  return SDL_GetIOStatus(context);
}
 
inline IOStatus IOStream::GetStatus() const
{
  return SDL::GetIOStatus(m_resource);
}
 
inline Sint64 GetIOSize(IOStreamRef context)
{
  return CheckError(SDL_GetIOSize(context));
}
 
inline Sint64 IOStream::GetSize() const { return SDL::GetIOSize(m_resource); }
 
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(m_resource, offset, whence);
}
 
inline Sint64 TellIO(IOStreamRef context) { return SDL_TellIO(context); }
 
inline Sint64 IOStream::Tell() const { return SDL::TellIO(m_resource); }
 
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(m_resource, 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(m_resource, 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(m_resource, fmt, ap);
}
 
inline void FlushIO(IOStreamRef context) { CheckError(SDL_FlushIO(context)); }
 
inline void IOStream::Flush() { SDL::FlushIO(m_resource); }
 
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(m_resource);
}
 
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(m_resource, 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 Sint8 ReadS8(IOStreamRef src)
{
  Sint8 value;
  CheckError(SDL_ReadS8(src, &value));
  return value;
}
 
inline Uint16 ReadU16LE(IOStreamRef src)
{
  Uint16 value;
  CheckError(SDL_ReadU16LE(src, &value));
  return value;
}
 
inline Uint16 IOStream::ReadU16LE() { return SDL::ReadU16LE(m_resource); }
 
inline Sint16 ReadS16LE(IOStreamRef src)
{
  Sint16 value;
  CheckError(SDL_ReadS16LE(src, &value));
  return value;
}
 
inline Sint16 IOStream::ReadS16LE() { return SDL::ReadS16LE(m_resource); }
 
inline Uint16 ReadU16BE(IOStreamRef src)
{
  Uint16 value;
  CheckError(SDL_ReadU16BE(src, &value));
  return value;
}
 
inline Uint16 IOStream::ReadU16BE() { return SDL::ReadU16BE(m_resource); }
 
inline Sint16 ReadS16BE(IOStreamRef src)
{
  Sint16 value;
  CheckError(SDL_ReadS16BE(src, &value));
  return value;
}
 
inline Sint16 IOStream::ReadS16BE() { return SDL::ReadS16BE(m_resource); }
 
inline Uint32 ReadU32LE(IOStreamRef src)
{
  Uint32 value;
  CheckError(SDL_ReadU32LE(src, &value));
  return value;
}
 
inline Uint32 IOStream::ReadU32LE() { return SDL::ReadU32LE(m_resource); }
 
inline Sint32 ReadS32LE(IOStreamRef src)
{
  Sint32 value;
  CheckError(SDL_ReadS32LE(src, &value));
  return value;
}
 
inline Sint32 IOStream::ReadS32LE() { return SDL::ReadS32LE(m_resource); }
 
inline Uint32 ReadU32BE(IOStreamRef src)
{
  Uint32 value;
  CheckError(SDL_ReadU32BE(src, &value));
  return value;
}
 
inline Uint32 IOStream::ReadU32BE() { return SDL::ReadU32BE(m_resource); }
 
inline Sint32 ReadS32BE(IOStreamRef src)
{
  Sint32 value;
  CheckError(SDL_ReadS32BE(src, &value));
  return value;
}
 
inline Sint32 IOStream::ReadS32BE() { return SDL::ReadS32BE(m_resource); }
 
inline Uint64 ReadU64LE(IOStreamRef src)
{
  Uint64 value;
  CheckError(SDL_ReadU64LE(src, &value));
  return value;
}
 
inline Uint64 IOStream::ReadU64LE() { return SDL::ReadU64LE(m_resource); }
 
inline Sint64 ReadS64LE(IOStreamRef src)
{
  Sint64 value;
  CheckError(SDL_ReadS64LE(src, &value));
  return value;
}
 
inline Sint64 IOStream::ReadS64LE() { return SDL::ReadS64LE(m_resource); }
 
inline Uint64 ReadU64BE(IOStreamRef src)
{
  Uint64 value;
  CheckError(SDL_ReadU64BE(src, &value));
  return value;
}
 
inline Uint64 IOStream::ReadU64BE() { return SDL::ReadU64BE(m_resource); }
 
inline Sint64 ReadS64BE(IOStreamRef src)
{
  Sint64 value;
  CheckError(SDL_ReadS64BE(src, &value));
  return value;
}
 
inline Sint64 IOStream::ReadS64BE() { return SDL::ReadS64BE(m_resource); }
 
inline void WriteU8(IOStreamRef dst, Uint8 value)
{
  CheckError(SDL_WriteU8(dst, value));
}
 
inline void IOStream::WriteU8(Uint8 value) { SDL::WriteU8(m_resource, value); }
 
inline void WriteS8(IOStreamRef dst, Sint8 value)
{
  CheckError(SDL_WriteS8(dst, value));
}
 
inline void IOStream::WriteS8(Sint8 value) { SDL::WriteS8(m_resource, value); }
 
inline void WriteU16LE(IOStreamRef dst, Uint16 value)
{
  CheckError(SDL_WriteU16LE(dst, value));
}
 
inline void IOStream::WriteU16LE(Uint16 value)
{
  SDL::WriteU16LE(m_resource, value);
}
 
inline void WriteS16LE(IOStreamRef dst, Sint16 value)
{
  CheckError(SDL_WriteS16LE(dst, value));
}
 
inline void IOStream::WriteS16LE(Sint16 value)
{
  SDL::WriteS16LE(m_resource, value);
}
 
inline void WriteU16BE(IOStreamRef dst, Uint16 value)
{
  CheckError(SDL_WriteU16BE(dst, value));
}
 
inline void IOStream::WriteU16BE(Uint16 value)
{
  SDL::WriteU16BE(m_resource, value);
}
 
inline void WriteS16BE(IOStreamRef dst, Sint16 value)
{
  CheckError(SDL_WriteS16BE(dst, value));
}
 
inline void IOStream::WriteS16BE(Sint16 value)
{
  SDL::WriteS16BE(m_resource, value);
}
 
inline void WriteU32LE(IOStreamRef dst, Uint32 value)
{
  CheckError(SDL_WriteU32LE(dst, value));
}
 
inline void IOStream::WriteU32LE(Uint32 value)
{
  SDL::WriteU32LE(m_resource, value);
}
 
inline void WriteS32LE(IOStreamRef dst, Sint32 value)
{
  CheckError(SDL_WriteS32LE(dst, value));
}
 
inline void IOStream::WriteS32LE(Sint32 value)
{
  SDL::WriteS32LE(m_resource, value);
}
 
inline void WriteU32BE(IOStreamRef dst, Uint32 value)
{
  CheckError(SDL_WriteU32BE(dst, value));
}
 
inline void IOStream::WriteU32BE(Uint32 value)
{
  SDL::WriteU32BE(m_resource, value);
}
 
inline void WriteS32BE(IOStreamRef dst, Sint32 value)
{
  CheckError(SDL_WriteS32BE(dst, value));
}
 
inline void IOStream::WriteS32BE(Sint32 value)
{
  SDL::WriteS32BE(m_resource, value);
}
 
inline void WriteU64LE(IOStreamRef dst, Uint64 value)
{
  CheckError(SDL_WriteU64LE(dst, value));
}
 
inline void IOStream::WriteU64LE(Uint64 value)
{
  SDL::WriteU64LE(m_resource, value);
}
 
inline void WriteS64LE(IOStreamRef dst, Sint64 value)
{
  CheckError(SDL_WriteS64LE(dst, value));
}
 
inline void IOStream::WriteS64LE(Sint64 value)
{
  SDL::WriteS64LE(m_resource, value);
}
 
inline void WriteU64BE(IOStreamRef dst, Uint64 value)
{
  CheckError(SDL_WriteU64BE(dst, value));
}
 
inline void IOStream::WriteU64BE(Uint64 value)
{
  SDL::WriteU64BE(m_resource, value);
}
 
inline void WriteS64BE(IOStreamRef dst, Sint64 value)
{
  CheckError(SDL_WriteS64BE(dst, value));
}
 
inline void IOStream::WriteS64BE(Sint64 value)
{
  SDL::WriteS64BE(m_resource, value);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_IOSTREAM_H_ */