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 StorageRef;
 
// Forward decl
struct Storage;
 
using StorageInterface = SDL_StorageInterface;
 
struct StorageBase : Resource<SDL_Storage*>
{
  using Resource::Resource;
 
  StorageBase(StringParam override, PropertiesBase& props)
    : Resource(CheckError(SDL_OpenTitleStorage(override, props.get())))
  {
  }
 
  StorageBase(StringParam org, StringParam app, PropertiesBase& props)
    : Resource(CheckError(SDL_OpenUserStorage(org, app, props.get())))
  {
  }
 
  StorageBase(StringParam path)
    : Resource(CheckError(SDL_OpenFileStorage(path)))
  {
  }
 
  StorageBase(const StorageInterface& iface, void* userdata)
    : Resource(CheckError(SDL_OpenStorage(&iface, userdata)))
  {
  }
 
  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)};
  }
};
 
struct StorageRef : StorageBase
{
  using StorageBase::StorageBase;
 
  constexpr StorageRef(const StorageRef& other)
    : StorageBase(other.get())
  {
  }
 
  constexpr StorageRef(StorageRef&& other)
    : StorageBase(other.release())
  {
  }
 
  constexpr ~StorageRef() = default;
 
  StorageRef& operator=(StorageRef other)
  {
    release(other.release());
    return *this;
  }
 
  bool reset(SDL_Storage* newResource = {})
  {
    return SDL_CloseStorage(release(newResource));
  }
 
  bool Close() { return reset(); }
};
 
struct Storage : StorageRef
{
  using StorageRef::StorageRef;
 
  constexpr explicit Storage(SDL_Storage* resource = {})
    : StorageRef(resource)
  {
  }
 
  constexpr Storage(const Storage& other) = delete;
 
  constexpr Storage(Storage&& other) = default;
 
  ~Storage() { reset(); }
 
  Storage& operator=(Storage other)
  {
    reset(other.release());
    return *this;
  }
};
 
} // namespace SDL
 
#endif /* SDL3PP_STORAGE_H_ */