mirror of
https://github.com/wiiu-env/WiiUPluginSystem.git
synced 2024-09-29 01:28:36 +02:00
425 lines
18 KiB
C++
425 lines
18 KiB
C++
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
typedef enum {
|
|
WUPS_STORAGE_ERROR_SUCCESS = 0,
|
|
WUPS_STORAGE_ERROR_INVALID_ARGS = -0x01,
|
|
WUPS_STORAGE_ERROR_MALLOC_FAILED = -0x02,
|
|
WUPS_STORAGE_ERROR_UNEXPECTED_DATA_TYPE = -0x03,
|
|
WUPS_STORAGE_ERROR_BUFFER_TOO_SMALL = -0x04,
|
|
WUPS_STORAGE_ERROR_ALREADY_EXISTS = -0x05,
|
|
WUPS_STORAGE_ERROR_IO_ERROR = -0x06,
|
|
WUPS_STORAGE_ERROR_NOT_FOUND = -0x10,
|
|
WUPS_STORAGE_ERROR_INTERNAL_NOT_INITIALIZED = -0xF0,
|
|
WUPS_STORAGE_ERROR_INTERNAL_INVALID_VERSION = -0xF1,
|
|
WUPS_STORAGE_ERROR_UNKNOWN_ERROR = -0x100,
|
|
} WUPSStorageError;
|
|
|
|
typedef enum {
|
|
WUPS_STORAGE_ITEM_S32 = 0,
|
|
WUPS_STORAGE_ITEM_S64 = 1,
|
|
WUPS_STORAGE_ITEM_U32 = 2,
|
|
WUPS_STORAGE_ITEM_U64 = 3,
|
|
WUPS_STORAGE_ITEM_STRING = 4,
|
|
WUPS_STORAGE_ITEM_BINARY = 5,
|
|
WUPS_STORAGE_ITEM_BOOL = 6,
|
|
WUPS_STORAGE_ITEM_FLOAT = 7,
|
|
WUPS_STORAGE_ITEM_DOUBLE = 8,
|
|
} WUPSStorageItemTypes;
|
|
|
|
typedef uint32_t WUPSStorageItemType;
|
|
|
|
typedef void *wups_storage_root_item;
|
|
typedef void *wups_storage_item;
|
|
|
|
typedef WUPSStorageError (*WUPSStorage_SaveFunction)(wups_storage_root_item root, bool force);
|
|
typedef WUPSStorageError (*WUPSStorage_ForceReloadFunction)(wups_storage_root_item root);
|
|
typedef WUPSStorageError (*WUPSStorage_WipeStorageFunction)(wups_storage_root_item root);
|
|
typedef WUPSStorageError (*WUPSStorage_DeleteItemFunction)(wups_storage_root_item root, wups_storage_item parent, const char *key);
|
|
typedef WUPSStorageError (*WUPSStorage_CreateSubItemFunction)(wups_storage_root_item root, wups_storage_item parent, const char *key, wups_storage_item *outItem);
|
|
typedef WUPSStorageError (*WUPSStorage_GetSubItemFunction)(wups_storage_root_item root, wups_storage_item parent, const char *key, wups_storage_item *outItem);
|
|
typedef WUPSStorageError (*WUPSStorage_StoreItemFunction)(wups_storage_root_item root, wups_storage_item parent, const char *key, WUPSStorageItemType itemType, void *data, uint32_t length);
|
|
typedef WUPSStorageError (*WUPSStorage_GetItemFunction)(wups_storage_root_item root, wups_storage_item parent, const char *key, WUPSStorageItemType itemType, void *data, uint32_t maxSize, uint32_t *outSize);
|
|
typedef WUPSStorageError (*WUPSStorage_GetItemSizeFunction)(wups_storage_root_item root, wups_storage_item parent, const char *key, uint32_t *outSize);
|
|
|
|
typedef uint32_t WUPS_STORAGE_API_VERSION;
|
|
#define WUPS_STORAGE_CUR_API_VERSION 0x02
|
|
|
|
typedef struct wups_loader_init_storage_args_t_ {
|
|
WUPS_STORAGE_API_VERSION version;
|
|
wups_storage_root_item root_item;
|
|
WUPSStorage_SaveFunction save_function_ptr;
|
|
WUPSStorage_ForceReloadFunction force_reload_function_ptr;
|
|
WUPSStorage_WipeStorageFunction wipe_storage_function_ptr;
|
|
WUPSStorage_DeleteItemFunction delete_item_function_ptr;
|
|
WUPSStorage_CreateSubItemFunction create_sub_item_function_ptr;
|
|
WUPSStorage_GetSubItemFunction get_sub_item_function_ptr;
|
|
WUPSStorage_StoreItemFunction store_item_function_ptr;
|
|
WUPSStorage_GetItemFunction get_item_function_ptr;
|
|
WUPSStorage_GetItemSizeFunction get_item_size_function_ptr;
|
|
} wups_loader_init_storage_args_t;
|
|
|
|
/* called by backend */
|
|
WUPSStorageError WUPSStorageAPI_InitInternal(wups_loader_init_storage_args_t args);
|
|
|
|
const char *WUPSStorageAPI_GetStatusStr(WUPSStorageError status);
|
|
|
|
WUPSStorageError WUPSStorageAPI_SaveStorage(bool forceSave);
|
|
WUPSStorageError WUPSStorageAPI_ForceReloadStorage();
|
|
WUPSStorageError WUPSStorageAPI_WipeStorage();
|
|
|
|
WUPSStorageError WUPSStorageAPI_DeleteItem(wups_storage_item parent, const char *key);
|
|
|
|
WUPSStorageError WUPSStorageAPI_CreateSubItem(wups_storage_item parent, const char *key, wups_storage_item *outItem);
|
|
WUPSStorageError WUPSStorageAPI_GetSubItem(wups_storage_item parent, const char *key, wups_storage_item *outItem);
|
|
|
|
WUPSStorageError WUPSStorageAPI_StoreItem(wups_storage_item parent, const char *key, WUPSStorageItemType type, void *data, uint32_t size);
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreString(wups_storage_item parent, const char *key, const char *value) {
|
|
if (value == NULL) {
|
|
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
|
}
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_STRING, (void *) value, strlen(value));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreBool(wups_storage_item parent, const char *key, bool value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_BOOL, (void *) &value, sizeof(bool));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreInt(wups_storage_item parent, const char *key, int32_t value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_S32, (void *) &value, sizeof(int32_t));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreS32(wups_storage_item parent, const char *key, int32_t value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_S32, (void *) &value, sizeof(int32_t));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreS64(wups_storage_item parent, const char *key, int64_t value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_S64, (void *) &value, sizeof(int64_t));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreU32(wups_storage_item parent, const char *key, uint32_t value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_U32, (void *) &value, sizeof(uint32_t));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreU64(wups_storage_item parent, const char *key, uint64_t value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_U64, (void *) &value, sizeof(uint64_t));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreFloat(wups_storage_item parent, const char *key, float value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_FLOAT, (void *) &value, sizeof(float));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreDouble(wups_storage_item parent, const char *key, double value) {
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_DOUBLE, (void *) &value, sizeof(double));
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_StoreBinary(wups_storage_item parent, const char *key, const void *data, uint32_t size) {
|
|
if (data == NULL) {
|
|
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
|
}
|
|
return WUPSStorageAPI_StoreItem(parent, key, WUPS_STORAGE_ITEM_BINARY, (void *) data, size);
|
|
}
|
|
|
|
WUPSStorageError WUPSStorageAPI_GetItem(wups_storage_item parent, const char *key, WUPSStorageItemType type, void *data, uint32_t maxSize, uint32_t *outSize);
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetString(wups_storage_item parent, const char *key, char *outString, uint32_t maxSize, uint32_t *outSize) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_STRING, outString, maxSize, outSize);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetBool(wups_storage_item parent, const char *key, bool *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_BOOL, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetInt(wups_storage_item parent, const char *key, int32_t *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_S32, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetS32(wups_storage_item parent, const char *key, int32_t *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_S32, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetS64(wups_storage_item parent, const char *key, int64_t *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_S64, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetU32(wups_storage_item parent, const char *key, uint32_t *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_U32, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetU64(wups_storage_item parent, const char *key, uint64_t *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_U64, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetFloat(wups_storage_item parent, const char *key, float *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_FLOAT, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetDouble(wups_storage_item parent, const char *key, double *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_DOUBLE, outValue, sizeof(*outValue), NULL);
|
|
}
|
|
|
|
inline WUPSStorageError WUPSStorageAPI_GetBinary(wups_storage_item parent, const char *key, void *outData, uint32_t maxSize, uint32_t *outValue) {
|
|
return WUPSStorageAPI_GetItem(parent, key, WUPS_STORAGE_ITEM_BINARY, outData, maxSize, outValue);
|
|
}
|
|
|
|
WUPSStorageError WUPSStorageAPI_GetItemSize(wups_storage_item parent, const char *key, uint32_t *outSize);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
|
|
#include <cstring>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
class WUPSStorageSubItem;
|
|
|
|
namespace WUPSStorageAPI {
|
|
WUPSStorageError DeleteItem(std::string_view key) noexcept;
|
|
|
|
WUPSStorageError SaveStorage(bool forceSave = false);
|
|
WUPSStorageError ForceReloadStorage();
|
|
WUPSStorageError WipeStorage();
|
|
|
|
std::string_view GetStatusStr(const WUPSStorageError &err) noexcept;
|
|
|
|
WUPSStorageSubItem GetRootItem() noexcept;
|
|
|
|
std::optional<WUPSStorageSubItem> CreateSubItem(std::string_view key, WUPSStorageError &err) noexcept;
|
|
std::optional<WUPSStorageSubItem> GetSubItem(std::string_view key, WUPSStorageError &err) noexcept;
|
|
std::optional<WUPSStorageSubItem> GetOrCreateSubItem(std::string_view key, WUPSStorageError &err) noexcept;
|
|
|
|
WUPSStorageError GetItemSize(std::string_view key, uint32_t &outSize) noexcept;
|
|
|
|
WUPSStorageSubItem CreateSubItem(std::string_view key);
|
|
WUPSStorageSubItem GetSubItem(std::string_view key);
|
|
WUPSStorageSubItem GetOrCreateSubItem(std::string_view key);
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError GetEx(wups_storage_item parent, const char *key, T &outValue) noexcept;
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<int32_t>(wups_storage_item parent, const char *key, int32_t &outValue) noexcept {
|
|
return WUPSStorageAPI_GetS32(parent, key, &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<int64_t>(wups_storage_item parent, const char *key, int64_t &outValue) noexcept {
|
|
return WUPSStorageAPI_GetS64(parent, key, &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<uint32_t>(wups_storage_item parent, const char *key, uint32_t &outValue) noexcept {
|
|
return WUPSStorageAPI_GetU32(parent, key, &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<uint64_t>(wups_storage_item parent, const char *key, uint64_t &outValue) noexcept {
|
|
return WUPSStorageAPI_GetU64(parent, key, &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<bool>(wups_storage_item parent, const char *key, bool &outValue) noexcept {
|
|
return WUPSStorageAPI_GetBool(parent, key, &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<float>(wups_storage_item parent, const char *key, float &outValue) noexcept {
|
|
return WUPSStorageAPI_GetFloat(parent, key, &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<double>(wups_storage_item parent, const char *key, double &outValue) noexcept {
|
|
return WUPSStorageAPI_GetDouble(parent, key, &outValue);
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError GetEx(wups_storage_item parent, const char *key, T &outValue) noexcept {
|
|
static_assert(sizeof(T) == sizeof(uint32_t) && std::is_enum<T>::value, "T must be an enum of size sizeof(uint32_t)");
|
|
return WUPSStorageAPI_GetU32(parent, key, (uint32_t *) &outValue);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<std::vector<uint8_t>>(wups_storage_item parent, const char *key, std::vector<uint8_t> &outValue) noexcept {
|
|
uint32_t outSize = 0;
|
|
|
|
if (outValue.empty()) {
|
|
uint32_t resizeToSize = 0;
|
|
auto r = WUPSStorageAPI_GetItemSize(parent, key, &resizeToSize);
|
|
if (r == WUPS_STORAGE_ERROR_SUCCESS) {
|
|
outValue.resize(resizeToSize);
|
|
} else {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
auto res = WUPSStorageAPI_GetBinary(parent, key, outValue.data(), outValue.size(), &outSize);
|
|
if (res == WUPS_STORAGE_ERROR_SUCCESS) {
|
|
outValue.resize(outSize);
|
|
} else {
|
|
outValue.resize(0);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError GetEx<std::string>(wups_storage_item parent, const char *key, std::string &outValue) noexcept {
|
|
uint32_t outSize = 0;
|
|
if (outValue.empty()) {
|
|
uint32_t resizeToSize = 0;
|
|
auto r = WUPSStorageAPI_GetItemSize(parent, key, &resizeToSize);
|
|
if (r == WUPS_STORAGE_ERROR_SUCCESS) {
|
|
outValue.resize(resizeToSize);
|
|
} else {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
auto res = WUPSStorageAPI_GetString(parent, key, outValue.data(), outValue.size(), &outSize);
|
|
if (res == WUPS_STORAGE_ERROR_SUCCESS) {
|
|
// outSize does count the null terminator as well, std::string's size() doesn't include a null terminator.
|
|
outValue.resize(strlen(outValue.c_str()));
|
|
} else {
|
|
outValue.resize(0);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError Get(const char *key, T &outValue) noexcept {
|
|
return GetEx(nullptr, key, outValue);
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError StoreEx(wups_storage_item parent, const char *key, const T &value) noexcept;
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<int32_t>(wups_storage_item parent, const char *key, const int32_t &value) noexcept {
|
|
return WUPSStorageAPI_StoreS32(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<int64_t>(wups_storage_item parent, const char *key, const int64_t &value) noexcept {
|
|
return WUPSStorageAPI_StoreS64(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<uint32_t>(wups_storage_item parent, const char *key, const uint32_t &value) noexcept {
|
|
return WUPSStorageAPI_StoreU32(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<uint64_t>(wups_storage_item parent, const char *key, const uint64_t &value) noexcept {
|
|
return WUPSStorageAPI_StoreU64(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<bool>(wups_storage_item parent, const char *key, const bool &value) noexcept {
|
|
return WUPSStorageAPI_StoreBool(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<float>(wups_storage_item parent, const char *key, const float &value) noexcept {
|
|
return WUPSStorageAPI_StoreFloat(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<double>(wups_storage_item parent, const char *key, const double &value) noexcept {
|
|
return WUPSStorageAPI_StoreDouble(parent, key, value);
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<std::vector<uint8_t>>(wups_storage_item parent, const char *key, const std::vector<uint8_t> &value) noexcept {
|
|
return WUPSStorageAPI_StoreBinary(parent, key, value.data(), value.size());
|
|
}
|
|
|
|
template<>
|
|
inline WUPSStorageError StoreEx<std::string>(wups_storage_item parent, const char *key, const std::string &value) noexcept {
|
|
return WUPSStorageAPI_StoreString(parent, key, value.c_str());
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError StoreEx(wups_storage_item parent, const char *key, const T &value) noexcept {
|
|
static_assert(sizeof(T) == sizeof(uint32_t) && std::is_enum<T>::value, "T must be an enum of size sizeof(uint32_t)");
|
|
return WUPSStorageAPI_StoreU32(parent, key, (uint32_t) value);
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError Store(const char *key, const T &value) noexcept {
|
|
return StoreEx(nullptr, key, value);
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError GetOrStoreDefaultEx(wups_storage_item parent, const char *key, T &outValue, const T &defaultValue) noexcept {
|
|
WUPSStorageError err = GetEx(parent, key, outValue);
|
|
if (err == WUPS_STORAGE_ERROR_NOT_FOUND) {
|
|
err = StoreEx(parent, key, defaultValue);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError GetOrStoreDefault(const char *key, T &outValue, const T &defaultValue) noexcept {
|
|
return GetOrStoreDefaultEx<T>(nullptr, key, outValue, defaultValue);
|
|
}
|
|
} // namespace WUPSStorageAPI
|
|
|
|
class WUPSStorageSubItem {
|
|
public:
|
|
explicit WUPSStorageSubItem(wups_storage_item handle) : mHandle(handle) {
|
|
}
|
|
virtual ~WUPSStorageSubItem() = default;
|
|
|
|
bool operator==(const WUPSStorageSubItem &rhs) const;
|
|
bool operator!=(const WUPSStorageSubItem &rhs) const;
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError Store(const char *key, const T &value) noexcept {
|
|
return WUPSStorageAPI::StoreEx(mHandle, key, value);
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError Get(const char *key, T &value) const noexcept {
|
|
return WUPSStorageAPI::GetEx(mHandle, key, value);
|
|
}
|
|
|
|
template<typename T>
|
|
inline WUPSStorageError GetOrStoreDefault(std::string_view key, T &outValue, const T &defaultValue) const noexcept {
|
|
return WUPSStorageAPI::GetOrStoreDefaultEx(mHandle, key.data(), outValue, defaultValue);
|
|
}
|
|
|
|
WUPSStorageError DeleteItem(std::string_view view) noexcept;
|
|
|
|
WUPSStorageError GetItemSize(std::string_view view, uint32_t &outSize) noexcept;
|
|
|
|
std::optional<WUPSStorageSubItem> CreateSubItem(std::string_view key, WUPSStorageError &err) noexcept;
|
|
|
|
std::optional<WUPSStorageSubItem> GetSubItem(std::string_view key, WUPSStorageError &err) const noexcept;
|
|
|
|
std::optional<WUPSStorageSubItem> GetOrCreateSubItem(std::string_view key, WUPSStorageError &err) noexcept;
|
|
|
|
[[nodiscard]] WUPSStorageSubItem CreateSubItem(std::string_view key);
|
|
|
|
[[nodiscard]] WUPSStorageSubItem GetSubItem(std::string_view key) const;
|
|
|
|
[[nodiscard]] WUPSStorageSubItem GetOrCreateSubItem(std::string_view key);
|
|
|
|
private:
|
|
wups_storage_item mHandle = {};
|
|
};
|
|
|
|
#endif
|