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 StorageRef;
 
// Forward decl
struct Storage;
 
using StorageShared = ResourceShared<Storage>;
 
using StorageWeak = ResourceWeak<Storage>;
 
using StorageInterface = SDL_StorageInterface;
 
struct StorageRef : Resource<SDL_Storage*>
{
  using Resource::Resource;
 
  bool Ready() const { return SDL_StorageReady(get()); }
 
  std::optional<Uint64> GetFileSize(StringParam path) const
  {
    if (Uint64 length; SDL_GetStorageFileSize(get(), path, &length)) {
      return length;
    }
    return 0;
  }
 
  std::string ReadFile(StringParam path) const
  {
    auto sz = GetFileSize(path.c_str());
    if (!sz || *sz == 0) return {};
    std::string buffer(*sz, 0);
    if (ReadFile(std::move(path), buffer)) return buffer;
    return {};
  }
 
  bool ReadFile(StringParam path, TargetBytes destination) const
  {
    return SDL_ReadStorageFile(
      get(), path, destination.data, destination.size_bytes);
  }
 
  template<class T>
  std::vector<T> ReadFileAs(StringParam path) const
  {
    auto sz = GetFileSize(path.c_str());
    if (!sz || *sz == 0) return {};
    std::vector<T> buffer(*sz / sizeof(T) + (*sz % sizeof(T) ? 1 : 0), 0);
    if (ReadFile(std::move(path), {buffer.data(), *sz})) return buffer;
    return {};
  }
 
  void WriteFile(StringParam path, SourceBytes source)
  {
    SDL_WriteStorageFile(get(), path, source.data, source.size_bytes);
  }
 
  void CreateDirectory(StringParam path)
  {
    CheckError(SDL_CreateStorageDirectory(get(), path));
  }
 
  std::vector<Path> EnumerateDirectory(StringParam path)
  {
    std::vector<Path> r;
    EnumerateDirectory(std::move(path), [&](const char*, const char* fname) {
      r.emplace_back(fname);
      return ENUM_CONTINUE;
    });
    return r;
  }
 
  void EnumerateDirectory(StringParam path, EnumerateDirectoryCB callback)
  {
    EnumerateDirectory(
      std::move(path),
      [](void* userdata, const char* dirname, const char* fname) {
        auto& cb = *static_cast<EnumerateDirectoryCB*>(userdata);
        return cb(dirname, fname);
      },
      &callback);
  }
 
  void EnumerateDirectory(StringParam path,
                          EnumerateDirectoryCallback callback,
                          void* userdata)
  {
    CheckError(SDL_EnumerateStorageDirectory(get(), path, callback, userdata));
  }
 
  void RemovePath(StringParam path)
  {
    CheckError(SDL_RemoveStoragePath(get(), path));
  }
 
  void RenamePath(StringParam oldpath, StringParam newpath)
  {
    CheckError(SDL_RenameStoragePath(get(), oldpath, newpath));
  }
 
  void CopyFile(StringParam oldpath, StringParam newpath)
  {
    CheckError(SDL_CopyStorageFile(get(), oldpath, newpath));
  }
 
  PathInfo GetPathInfo(StringParam path) const
  {
    if (PathInfo info; SDL_GetStoragePathInfo(get(), path, &info)) {
      return info;
    }
    return {};
  }
 
  Uint64 GetSpaceRemaining() const
  {
    return SDL_GetStorageSpaceRemaining(get());
  }
 
  OwnArray<char*> GlobDirectory(StringParam path,
                                StringParam pattern,
                                GlobFlags flags)
  {
    int count;
    auto data =
      CheckError(SDL_GlobStorageDirectory(get(), path, pattern, flags, &count));
    return OwnArray<char*>{data, size_t(count)};
  }
 
  static void reset(SDL_Storage* resource)
  {
    CheckError(SDL_CloseStorage(resource));
  }
};
 
struct Storage : ResourceUnique<StorageRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Storage OpenTitle(StringParam override, PropertiesRef props)
  {
    return Storage(CheckError(SDL_OpenTitleStorage(override, props)));
  }
 
  static Storage OpenUser(StringParam org, StringParam app, PropertiesRef props)
  {
    return Storage(CheckError(SDL_OpenUserStorage(org, app, props)));
  }
 
  static Storage OpenFile(StringParam path)
  {
    return Storage(CheckError(SDL_OpenFileStorage(path)));
  }
 
  static Storage Open(const StorageInterface& iface, void* userdata)
  {
    return Storage(CheckError(SDL_OpenStorage(&iface, userdata)));
  }
 
  void Close() { reset(); }
  StorageShared share();
 
};
 
 
inline StorageShared Storage::share()
{
  return StorageShared(std::move(*this));
}
 
struct StorageUnsafe : ResourceUnsafe<StorageRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit StorageUnsafe(Storage&& other)
    : StorageUnsafe(other.release())
  {
  }
};
 
 
} // namespace SDL
 
#endif /* SDL3PP_STORAGE_H_ */