SDL3pp_storage.h

#ifndef SDL3PP_STORAGE_H_
#define SDL3PP_STORAGE_H_
 
#include <SDL3/SDL_storage.h>
#include "SDL3pp_filesystem.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct Storage;
 
using StorageRaw = SDL_Storage*;
 
// Forward decl
struct StorageRef;
 
using StorageInterface = SDL_StorageInterface;
 
class Storage
{
  StorageRaw m_resource = nullptr;
 
public:
  constexpr Storage(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Storage(const StorageRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Storage(const Storage& other) noexcept = default;
 
public:
  constexpr Storage(Storage&& other) noexcept
    : Storage(other.release())
  {
  }
 
  constexpr Storage(const StorageRef& other) = delete;
 
  constexpr Storage(StorageRef&& other) = delete;
 
  Storage(StringParam override, PropertiesRef props);
 
  Storage(StringParam org, StringParam app, PropertiesRef props);
 
  Storage(StringParam path);
 
  Storage(const StorageInterface& iface, void* userdata);
 
  ~Storage() { CheckError(SDL_CloseStorage(m_resource)); }
 
  constexpr Storage& operator=(Storage&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Storage& operator=(const Storage& other) noexcept = default;
 
public:
  constexpr StorageRaw get() const noexcept { return m_resource; }
 
  constexpr StorageRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Storage& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  bool Close();
 
  bool Ready();
 
  std::optional<Uint64> GetFileSize(StringParam path);
 
  bool ReadFile(StringParam path, TargetBytes destination);
 
  std::string ReadFile(StringParam path);
 
  template<class T>
  std::vector<T> ReadFileAs(StringParam path);
 
  void WriteFile(StringParam path, SourceBytes source);
 
  void CreateDirectory(StringParam path);
 
  void EnumerateDirectory(StringParam path,
                          EnumerateDirectoryCallback callback,
                          void* userdata);
 
  std::vector<Path> EnumerateDirectory(StringParam path);
 
  void EnumerateDirectory(StringParam path, EnumerateDirectoryCB callback);
 
  void RemovePath(StringParam path);
 
  void RenamePath(StringParam oldpath, StringParam newpath);
 
  void CopyFile(StringParam oldpath, StringParam newpath);
 
  PathInfo GetPathInfo(StringParam path);
 
  Uint64 GetSpaceRemaining();
 
  OwnArray<char*> GlobDirectory(StringParam path,
                                StringParam pattern,
                                GlobFlags flags);
};
 
struct StorageRef : Storage
{
  using Storage::Storage;
 
  StorageRef(StorageRaw resource) noexcept
    : Storage(resource)
  {
  }
 
  constexpr StorageRef(const Storage& resource) noexcept
    : Storage(resource.get())
  {
  }
 
  constexpr StorageRef(Storage&& resource) noexcept
    : Storage(std::move(resource).release())
  {
  }
 
  constexpr StorageRef(const StorageRef& other) noexcept
    : Storage(other.get())
  {
  }
 
  constexpr StorageRef(StorageRef&& other) noexcept
    : Storage(other.get())
  {
  }
 
  ~StorageRef() { release(); }
 
  constexpr StorageRef& operator=(const StorageRef& other) noexcept = default;
 
  constexpr operator StorageRaw() const noexcept { return get(); }
};
 
inline Storage OpenTitleStorage(StringParam override, PropertiesRef props)
{
  return Storage(std::move(override), props);
}
 
inline Storage::Storage(StringParam override, PropertiesRef props)
  : m_resource(CheckError(SDL_OpenTitleStorage(override, props)))
{
}
 
inline Storage::Storage(StringParam org, StringParam app, PropertiesRef props)
  : m_resource(CheckError(SDL_OpenUserStorage(org, app, props)))
{
}
 
inline Storage::Storage(StringParam path)
  : m_resource(CheckError(SDL_OpenFileStorage(path)))
{
}
 
inline Storage::Storage(const StorageInterface& iface, void* userdata)
  : m_resource(CheckError(SDL_OpenStorage(&iface, userdata)))
{
}
 
inline Storage OpenUserStorage(StringParam org,
                               StringParam app,
                               PropertiesRef props)
{
  return Storage(std::move(org), std::move(app), props);
}
 
inline Storage OpenFileStorage(StringParam path)
{
  return Storage(std::move(path));
}
 
inline Storage OpenStorage(const StorageInterface& iface, void* userdata)
{
  return Storage(iface, userdata);
}
 
inline bool CloseStorage(StorageRaw storage)
{
  return SDL_CloseStorage(storage);
}
 
inline bool Storage::Close() { return CloseStorage(release()); }
 
inline bool StorageReady(StorageRef storage)
{
  return SDL_StorageReady(storage);
}
 
inline bool Storage::Ready() { return SDL::StorageReady(m_resource); }
 
inline std::optional<Uint64> GetStorageFileSize(StorageRef storage,
                                                StringParam path)
{
  if (Uint64 length; SDL_GetStorageFileSize(storage, path, &length)) {
    return length;
  }
  return {};
}
 
inline std::optional<Uint64> Storage::GetFileSize(StringParam path)
{
  return SDL::GetStorageFileSize(m_resource, std::move(path));
}
 
inline bool ReadStorageFile(StorageRef storage,
                            StringParam path,
                            TargetBytes destination)
{
  return SDL_ReadStorageFile(
    storage, path, destination.data(), destination.size_bytes());
}
 
inline std::string ReadStorageFile(StorageRef storage, StringParam path)
{
  auto sz = GetStorageFileSize(storage, path.c_str());
  if (!sz || *sz == 0) return {};
  std::string buffer(*sz, 0);
  CheckError(ReadStorageFile(storage, std::move(path), buffer));
  return buffer;
}
 
inline bool Storage::ReadFile(StringParam path, TargetBytes destination)
{
  return SDL::ReadStorageFile(
    m_resource, std::move(path), std::move(destination));
}
 
inline std::string Storage::ReadFile(StringParam path)
{
  return SDL::ReadStorageFile(m_resource, std::move(path));
}
 
template<class T>
inline std::vector<T> ReadStorageFileAs(StorageRef storage, StringParam path)
{
  auto sz = GetStorageFileSize(storage, path.c_str());
  if (!sz || *sz == 0) return {};
  std::vector<T> buffer(*sz / sizeof(T) + (*sz % sizeof(T) ? 1 : 0), 0);
  CheckError(ReadFile(std::move(path), {buffer.data(), *sz}));
  return buffer;
}
 
template<class T>
inline std::vector<T> Storage::ReadFileAs(StringParam path)
{
  return SDL::ReadStorageFileAs<T>(m_resource, std::move(path));
}
 
inline void WriteStorageFile(StorageRef storage,
                             StringParam path,
                             SourceBytes source)
{
  CheckError(
    SDL_WriteStorageFile(storage, path, source.data(), source.size_bytes()));
}
 
inline void Storage::WriteFile(StringParam path, SourceBytes source)
{
  SDL::WriteStorageFile(m_resource, std::move(path), std::move(source));
}
 
inline void CreateStorageDirectory(StorageRef storage, StringParam path)
{
  CheckError(SDL_CreateStorageDirectory(storage, path));
}
 
inline void Storage::CreateDirectory(StringParam path)
{
  SDL::CreateStorageDirectory(m_resource, std::move(path));
}
 
inline void EnumerateStorageDirectory(StorageRef storage,
                                      StringParam path,
                                      EnumerateDirectoryCallback callback,
                                      void* userdata)
{
  CheckError(SDL_EnumerateStorageDirectory(storage, path, callback, userdata));
}
 
inline void EnumerateStorageDirectory(StorageRef storage,
                                      StringParam path,
                                      EnumerateDirectoryCB callback)
{
  EnumerateStorageDirectory(
    storage,
    std::move(path),
    [](void* userdata, const char* dirname, const char* fname) {
      auto& cb = *static_cast<EnumerateDirectoryCB*>(userdata);
      return cb(dirname, fname);
    },
    &callback);
}
 
inline std::vector<Path> EnumerateStorageDirectory(StorageRef storage,
                                                   StringParam path)
{
  std::vector<Path> r;
  EnumerateDirectory(std::move(path), [&](const char*, const char* fname) {
    r.emplace_back(fname);
    return ENUM_CONTINUE;
  });
  return r;
}
 
inline void Storage::EnumerateDirectory(StringParam path,
                                        EnumerateDirectoryCallback callback,
                                        void* userdata)
{
  SDL::EnumerateStorageDirectory(
    m_resource, std::move(path), callback, userdata);
}
 
inline std::vector<Path> Storage::EnumerateDirectory(StringParam path)
{
  return SDL::EnumerateStorageDirectory(m_resource, std::move(path));
}
 
inline void Storage::EnumerateDirectory(StringParam path,
                                        EnumerateDirectoryCB callback)
{
  SDL::EnumerateStorageDirectory(m_resource, std::move(path), callback);
}
 
inline void RemoveStoragePath(StorageRef storage, StringParam path)
{
  CheckError(SDL_RemoveStoragePath(storage, path));
}
 
inline void Storage::RemovePath(StringParam path)
{
  SDL::RemoveStoragePath(m_resource, std::move(path));
}
 
inline void RenameStoragePath(StorageRef storage,
                              StringParam oldpath,
                              StringParam newpath)
{
  CheckError(SDL_RenameStoragePath(storage, oldpath, newpath));
}
 
inline void Storage::RenamePath(StringParam oldpath, StringParam newpath)
{
  SDL::RenameStoragePath(m_resource, std::move(oldpath), std::move(newpath));
}
 
inline void CopyStorageFile(StorageRef storage,
                            StringParam oldpath,
                            StringParam newpath)
{
  CheckError(SDL_CopyStorageFile(storage, oldpath, newpath));
}
 
inline void Storage::CopyFile(StringParam oldpath, StringParam newpath)
{
  SDL::CopyStorageFile(m_resource, std::move(oldpath), std::move(newpath));
}
 
inline PathInfo GetStoragePathInfo(StorageRef storage, StringParam path)
{
  if (PathInfo info; SDL_GetStoragePathInfo(storage, path, &info)) {
    return info;
  }
  return {};
}
 
inline PathInfo Storage::GetPathInfo(StringParam path)
{
  return SDL::GetStoragePathInfo(m_resource, std::move(path));
}
 
inline Uint64 GetStorageSpaceRemaining(StorageRef storage)
{
  return SDL_GetStorageSpaceRemaining(storage);
}
 
inline Uint64 Storage::GetSpaceRemaining()
{
  return SDL::GetStorageSpaceRemaining(m_resource);
}
 
inline OwnArray<char*> GlobStorageDirectory(StorageRef storage,
                                            StringParam path,
                                            StringParam pattern,
                                            GlobFlags flags)
{
  int count;
  auto data =
    CheckError(SDL_GlobStorageDirectory(storage, path, pattern, flags, &count));
  return OwnArray<char*>{data, size_t(count)};
}
 
inline OwnArray<char*> Storage::GlobDirectory(StringParam path,
                                              StringParam pattern,
                                              GlobFlags flags)
{
  return SDL::GlobStorageDirectory(
    m_resource, std::move(path), std::move(pattern), flags);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_STORAGE_H_ */