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 StorageBase;
 
// Forward decl
struct Storage;

using StorageRaw = SDL_Storage*;

using StorageRef = ResourceRefT<StorageBase>;

using StorageInterface = SDL_StorageInterface;

struct StorageBase : ResourceBaseT<StorageRaw>
{
  using ResourceBaseT::ResourceBaseT;

  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 Storage : StorageBase
{
  using StorageBase::StorageBase;

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

  constexpr Storage(Storage&& other) noexcept
    : Storage(other.release())
  {
  }

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

inline Storage OpenTitleStorage(StringParam override, PropertiesRef props)
{
  return Storage(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(org, app, props);
}

inline Storage OpenFileStorage(StringParam path) { return Storage(path); }

inline Storage OpenStorage(const StorageInterface& iface, void* userdata)
{
  return Storage(iface, userdata);
}

inline bool CloseStorage(StorageRaw storage)
{
  return SDL_CloseStorage(storage);
}
 
inline bool StorageBase::Close() { return CloseStorage(release()); }

inline bool StorageReady(StorageRef storage)
{
  return SDL_StorageReady(storage);
}
 
inline bool StorageBase::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> StorageBase::GetFileSize(StringParam path)
{
  return SDL::GetStorageFileSize(get(), 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, path, buffer));
  return buffer;
}
 
inline bool StorageBase::ReadFile(StringParam path, TargetBytes destination)
{
  return SDL::ReadStorageFile(get(), path, destination);
}
 
inline std::string StorageBase::ReadFile(StringParam path)
{
  return SDL::ReadStorageFile(get(), 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(path, {buffer.data(), *sz}));
  return buffer;
}
 
template<class T>
inline std::vector<T> StorageBase::ReadFileAs(StringParam path)
{
  return SDL::ReadStorageFileAs<T>(get(), path);
}

inline void WriteStorageFile(StorageRef storage,
                             StringParam path,
                             SourceBytes source)
{
  CheckError(
    SDL_WriteStorageFile(storage, path, source.data(), source.size_bytes()));
}
 
inline void StorageBase::WriteFile(StringParam path, SourceBytes source)
{
  SDL::WriteStorageFile(get(), path, source);
}

inline void CreateStorageDirectory(StorageRef storage, StringParam path)
{
  CheckError(SDL_CreateStorageDirectory(storage, path));
}
 
inline void StorageBase::CreateDirectory(StringParam path)
{
  SDL::CreateStorageDirectory(get(), 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,
    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, path, [&](const char*, const char* fname) {
    r.emplace_back(fname);
    return ENUM_CONTINUE;
  });
  return r;
}
 
inline void StorageBase::EnumerateDirectory(StringParam path,
                                            EnumerateDirectoryCallback callback,
                                            void* userdata)
{
  SDL::EnumerateStorageDirectory(get(), path, callback, userdata);
}
 
inline std::vector<Path> StorageBase::EnumerateDirectory(StringParam path)
{
  return SDL::EnumerateStorageDirectory(get(), path);
}
 
inline void StorageBase::EnumerateDirectory(StringParam path,
                                            EnumerateDirectoryCB callback)
{
  SDL::EnumerateStorageDirectory(get(), path, callback);
}

inline void RemoveStoragePath(StorageRef storage, StringParam path)
{
  CheckError(SDL_RemoveStoragePath(storage, path));
}
 
inline void StorageBase::RemovePath(StringParam path)
{
  SDL::RemoveStoragePath(get(), path);
}

inline void RenameStoragePath(StorageRef storage,
                              StringParam oldpath,
                              StringParam newpath)
{
  CheckError(SDL_RenameStoragePath(storage, oldpath, newpath));
}
 
inline void StorageBase::RenamePath(StringParam oldpath, StringParam newpath)
{
  SDL::RenameStoragePath(get(), oldpath, newpath);
}

inline void CopyStorageFile(StorageRef storage,
                            StringParam oldpath,
                            StringParam newpath)
{
  CheckError(SDL_CopyStorageFile(storage, oldpath, newpath));
}
 
inline void StorageBase::CopyFile(StringParam oldpath, StringParam newpath)
{
  SDL::CopyStorageFile(get(), oldpath, newpath);
}

inline PathInfo GetStoragePathInfo(StorageRef storage, StringParam path)
{
  if (PathInfo info; SDL_GetStoragePathInfo(storage, path, &info)) {
    return info;
  }
  return {};
}
 
inline PathInfo StorageBase::GetPathInfo(StringParam path)
{
  return SDL::GetStoragePathInfo(get(), path);
}

inline Uint64 GetStorageSpaceRemaining(StorageRef storage)
{
  return SDL_GetStorageSpaceRemaining(storage);
}
 
inline Uint64 StorageBase::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*> StorageBase::GlobDirectory(StringParam path,
                                                  StringParam pattern,
                                                  GlobFlags flags)
{
  return SDL::GlobStorageDirectory(get(), path, pattern, flags);
}

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