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

using StorageRef = ResourceRef<Storage>;

using StorageInterface = SDL_StorageInterface;

struct Storage : ResourceBase<StorageRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Storage(StorageRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Storage(const Storage& other) = delete;

  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(get())); }

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

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

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

inline Storage OpenTitleStorage(StringParam override, PropertiesRef props)
{
  return Storage(std::move(override), props);
}
 
inline Storage::Storage(StringParam override, PropertiesRef props)
  : Storage(CheckError(SDL_OpenTitleStorage(override, props)))
{
}
 
inline Storage::Storage(StringParam org, StringParam app, PropertiesRef props)
  : Storage(CheckError(SDL_OpenUserStorage(org, app, props)))
{
}
 
inline Storage::Storage(StringParam path)
  : Storage(CheckError(SDL_OpenFileStorage(path)))
{
}
 
inline Storage::Storage(const StorageInterface& iface, void* userdata)
  : Storage(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(get()); }

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(get(), 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(get(), std::move(path), std::move(destination));
}
 
inline std::string Storage::ReadFile(StringParam path)
{
  return SDL::ReadStorageFile(get(), 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>(get(), 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(get(), 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(get(), 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;
  EnumerateStorageDirectory(
    storage, 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(get(), std::move(path), callback, userdata);
}
 
inline std::vector<Path> Storage::EnumerateDirectory(StringParam path)
{
  return SDL::EnumerateStorageDirectory(get(), std::move(path));
}
 
inline void Storage::EnumerateDirectory(StringParam path,
                                        EnumerateDirectoryCB callback)
{
  SDL::EnumerateStorageDirectory(get(), std::move(path), callback);
}

inline void RemoveStoragePath(StorageRef storage, StringParam path)
{
  CheckError(SDL_RemoveStoragePath(storage, path));
}
 
inline void Storage::RemovePath(StringParam path)
{
  SDL::RemoveStoragePath(get(), 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(get(), 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(get(), 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(get(), std::move(path));
}

inline Uint64 GetStorageSpaceRemaining(StorageRef storage)
{
  return SDL_GetStorageSpaceRemaining(storage);
}
 
inline Uint64 Storage::GetSpaceRemaining()
{
  return SDL::GetStorageSpaceRemaining(get());
}

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(
    get(), std::move(path), std::move(pattern), flags);
}

 
} // namespace SDL
 
#endif /* SDL3PP_STORAGE_H_ */