mirror of
https://github.com/wiiu-env/WiiUPluginSystem.git
synced 2026-08-24 18:56:31 -05:00
Rewrite of the StorageAPI
This commit is contained in:
Maschell
@@ -2,632 +2,249 @@
|
||||
#include <cstring>
|
||||
#include <wups.h>
|
||||
|
||||
#include "utils/base64.h"
|
||||
struct wups_internal_functions_t {
|
||||
OpenStorageFunction openfunction_ptr = nullptr;
|
||||
CloseStorageFunction closefunction_ptr = nullptr;
|
||||
DeleteItemFunction delete_item_function_ptr = nullptr;
|
||||
CreateSubItemFunction create_sub_item_function_ptr = nullptr;
|
||||
GetSubItemFunction get_sub_item_function_ptr = nullptr;
|
||||
StoreItemFunction store_item_function_ptr = nullptr;
|
||||
GetItemFunction get_item_function_ptr = nullptr;
|
||||
GetItemSizeFunction get_item_size_function_ptr = nullptr;
|
||||
char plugin_id[256]{};
|
||||
wups_storage_root_item __storageroot_item = nullptr;
|
||||
};
|
||||
|
||||
static OpenStorageFunction openfunction_ptr __attribute__((section(".data"))) = nullptr;
|
||||
static CloseStorageFunction closefunction_ptr __attribute__((section(".data"))) = nullptr;
|
||||
static char plugin_id[256] __attribute__((section(".data")));
|
||||
static wups_internal_functions_t __internal_functions __attribute__((section(".data"))) = {};
|
||||
|
||||
static uint32_t storage_initialized __attribute__((section(".data"))) = false;
|
||||
static uint32_t isOpened __attribute__((section(".data")));
|
||||
static uint32_t isDirty __attribute__((section(".data")));
|
||||
static wups_storage_item_t rootItem __attribute__((section(".data")));
|
||||
WUPSStorageError WUPS_InitStorage(wups_loader_init_storage_args_t args) {
|
||||
if (args.version != WUPS_STORAGE_CUR_API_VERSION) {
|
||||
__internal_functions = {};
|
||||
return WUPS_STORAGE_ERROR_INVALID_VERSION;
|
||||
}
|
||||
__internal_functions.openfunction_ptr = args.open_storage_ptr;
|
||||
__internal_functions.closefunction_ptr = args.close_storage_ptr;
|
||||
__internal_functions.delete_item_function_ptr = args.delete_item_function_ptr;
|
||||
__internal_functions.create_sub_item_function_ptr = args.create_sub_item_function_ptr;
|
||||
__internal_functions.get_sub_item_function_ptr = args.get_sub_item_function_ptr;
|
||||
__internal_functions.store_item_function_ptr = args.store_item_function_ptr;
|
||||
__internal_functions.get_item_function_ptr = args.get_item_function_ptr;
|
||||
__internal_functions.get_item_size_function_ptr = args.get_item_size_function_ptr;
|
||||
|
||||
static wups_storage_item_t *sActiveSubItem __attribute__((section(".data"))) = nullptr;
|
||||
|
||||
void WUPS_InitStorage(wups_loader_init_storage_args_t args) {
|
||||
openfunction_ptr = args.open_storage_ptr;
|
||||
closefunction_ptr = args.close_storage_ptr;
|
||||
strncpy(plugin_id, args.plugin_id, sizeof(plugin_id) - 1);
|
||||
|
||||
storage_initialized = true;
|
||||
isOpened = false;
|
||||
isDirty = false;
|
||||
sActiveSubItem = nullptr;
|
||||
|
||||
rootItem.key = nullptr;
|
||||
rootItem.data = nullptr;
|
||||
rootItem.data_size = 0;
|
||||
rootItem.deleted = false;
|
||||
rootItem.type = WUPS_STORAGE_TYPE_ITEM;
|
||||
strncpy(__internal_functions.plugin_id, args.plugin_id, sizeof(__internal_functions.plugin_id) - 1);
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
const char *WUPS_GetStorageStatusStr(WUPSStorageError status) {
|
||||
switch (status) {
|
||||
case WUPS_STORAGE_ERROR_SUCCESS:
|
||||
return "WUPS_STORAGE_ERROR_SUCCESS";
|
||||
case WUPS_STORAGE_ERROR_NOT_OPENED:
|
||||
return "WUPS_STORAGE_ERROR_NOT_OPENED";
|
||||
case WUPS_STORAGE_ERROR_ALREADY_OPENED:
|
||||
return "WUPS_STORAGE_ERROR_ALREADY_OPENED";
|
||||
case WUPS_STORAGE_ERROR_INVALID_ARGS:
|
||||
return "WUPS_STORAGE_ERROR_INVALID_ARGS";
|
||||
case WUPS_STORAGE_ERROR_INVALID_POINTER:
|
||||
return "WUPS_STORAGE_ERROR_INVALID_POINTER";
|
||||
case WUPS_STORAGE_ERROR_INVALID_VERSION:
|
||||
return "WUPS_STORAGE_ERROR_INVALID_VERSION";
|
||||
case WUPS_STORAGE_ERROR_UNEXPECTED_DATA_TYPE:
|
||||
return "WUPS_STORAGE_ERROR_UNEXPECTED_DATA_TYPE";
|
||||
case WUPS_STORAGE_ERROR_NOT_FOUND:
|
||||
return "WUPS_STORAGE_ERROR_NOT_FOUND";
|
||||
case WUPS_STORAGE_ERROR_NOT_INITIALIZED:
|
||||
return "WUPS_STORAGE_ERROR_NOT_INITIALIZED";
|
||||
case WUPS_STORAGE_ERROR_INVALID_BACKEND_PARAMS:
|
||||
return "WUPS_STORAGE_ERROR_INVALID_BACKEND_PARAMS";
|
||||
case WUPS_STORAGE_ERROR_INVALID_JSON:
|
||||
return "WUPS_STORAGE_ERROR_INVALID_JSON";
|
||||
case WUPS_STORAGE_ERROR_IO:
|
||||
return "WUPS_STORAGE_ERROR_IO";
|
||||
case WUPS_STORAGE_ERROR_B64_DECODE_FAILED:
|
||||
return "WUPS_STORAGE_ERROR_B64_DECODE_FAILED";
|
||||
case WUPS_STORAGE_ERROR_BUFFER_TOO_SMALL:
|
||||
return "WUPS_STORAGE_ERROR_BUFFER_TOO_SMALL";
|
||||
case WUPS_STORAGE_ERROR_MALLOC_FAILED:
|
||||
return "WUPS_STORAGE_ERROR_MALLOC_FAILED";
|
||||
case WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY:
|
||||
return "WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY";
|
||||
case WUPS_STORAGE_ERROR_ALREADY_OPENED:
|
||||
return "WUPS_STORAGE_ERROR_ALREADY_OPENED";
|
||||
case WUPS_STORAGE_ERROR_BUFFER_TOO_SMALL:
|
||||
return "WUPS_STORAGE_ERROR_BUFFER_TOO_SMALL";
|
||||
case WUPS_STORAGE_ERROR_ALREADY_EXISTS:
|
||||
return "WUPS_STORAGE_ERROR_ALREADY_EXISTS";
|
||||
case WUPS_STORAGE_ERROR_UNKNOWN_ERROR:
|
||||
return "WUPS_STORAGE_ERROR_UNKNOWN_ERROR";
|
||||
}
|
||||
return "WUPS_STORAGE_ERROR_UNKNOWN";
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_OpenStorage(void) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
if (__internal_functions.openfunction_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
if (isOpened) {
|
||||
return WUPS_STORAGE_ERROR_ALREADY_OPENED;
|
||||
auto res = __internal_functions.openfunction_ptr(__internal_functions.plugin_id, &__internal_functions.__storageroot_item);
|
||||
if (res != WUPS_STORAGE_ERROR_SUCCESS) {
|
||||
__internal_functions.__storageroot_item = nullptr;
|
||||
}
|
||||
|
||||
WUPSStorageError result = openfunction_ptr(plugin_id, &rootItem);
|
||||
|
||||
if (result == WUPS_STORAGE_ERROR_SUCCESS || result == WUPS_STORAGE_ERROR_INVALID_JSON) {
|
||||
isOpened = true;
|
||||
isDirty = false;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void closeItem(wups_storage_item_t *item) {
|
||||
if (!item) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (item->type == WUPS_STORAGE_TYPE_ITEM) {
|
||||
auto *items = (wups_storage_item_t *) item->data;
|
||||
for (uint32_t i = 0; i < item->data_size; i++) {
|
||||
closeItem(&items[i]);
|
||||
}
|
||||
}
|
||||
free(item->data);
|
||||
free(item->key);
|
||||
return res;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_CloseStorage(void) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
if (__internal_functions.closefunction_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
auto res = __internal_functions.closefunction_ptr(__internal_functions.plugin_id);
|
||||
if (res == WUPS_STORAGE_ERROR_SUCCESS) {
|
||||
__internal_functions.__storageroot_item = nullptr;
|
||||
}
|
||||
|
||||
WUPSStorageError result = WUPS_STORAGE_ERROR_SUCCESS;
|
||||
if (isDirty) {
|
||||
result = closefunction_ptr(plugin_id, &rootItem);
|
||||
}
|
||||
|
||||
if (result == WUPS_STORAGE_ERROR_SUCCESS) {
|
||||
isOpened = false;
|
||||
isDirty = false;
|
||||
|
||||
closeItem(&rootItem);
|
||||
rootItem.data_size = 0;
|
||||
rootItem.data = nullptr;
|
||||
rootItem.key = nullptr;
|
||||
}
|
||||
sActiveSubItem = nullptr;
|
||||
|
||||
return result;
|
||||
return res;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_DeleteItem(wups_storage_item_t *parent, const char *key) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
WUPSStorageError WUPS_DeleteItem(wups_storage_item parent, const char *key) {
|
||||
if (__internal_functions.delete_item_function_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
return __internal_functions.delete_item_function_ptr(__internal_functions.__storageroot_item, parent, key);
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
WUPSStorageError WUPS_CreateSubItem(wups_storage_item parent, const char *key, wups_storage_item *outItem) {
|
||||
if (__internal_functions.create_sub_item_function_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
return __internal_functions.create_sub_item_function_ptr(__internal_functions.__storageroot_item, parent, key, outItem);
|
||||
}
|
||||
|
||||
if (!key) {
|
||||
WUPSStorageError WUPS_GetSubItem(wups_storage_item parent, const char *key, wups_storage_item *outItem) {
|
||||
if (__internal_functions.get_sub_item_function_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
return __internal_functions.get_sub_item_function_ptr(__internal_functions.__storageroot_item, parent, key, outItem);
|
||||
}
|
||||
|
||||
static inline WUPSStorageError WUPS_StoreItem(wups_storage_item parent, const char *key, WUPSStorageItemType type, void *data, uint32_t size) {
|
||||
if (__internal_functions.store_item_function_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
return __internal_functions.store_item_function_ptr(__internal_functions.__storageroot_item, parent, key, type, data, size);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreString(wups_storage_item parent, const char *key, const char *value) {
|
||||
if (value == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_STRING, (void *) value, strlen(value));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreBool(wups_storage_item parent, const char *key, bool value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_BOOL, (void *) &value, sizeof(bool));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreInt(wups_storage_item parent, const char *key, int32_t value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_S32, (void *) &value, sizeof(int32_t));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreS32(wups_storage_item parent, const char *key, int32_t value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_S32, (void *) &value, sizeof(int32_t));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreS64(wups_storage_item parent, const char *key, int64_t value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_S64, (void *) &value, sizeof(int64_t));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreU32(wups_storage_item parent, const char *key, uint32_t value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_U32, (void *) &value, sizeof(uint32_t));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreU64(wups_storage_item parent, const char *key, uint64_t value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_U64, (void *) &value, sizeof(uint64_t));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreFloat(wups_storage_item parent, const char *key, float value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_FLOAT, (void *) &value, sizeof(float));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreDouble(wups_storage_item parent, const char *key, double value) {
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_DOUBLE, (void *) &value, sizeof(double));
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreBinary(wups_storage_item parent, const char *key, const void *data, uint32_t size) {
|
||||
if (data == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_StoreItem(parent, key, WUPS_STORAGE_ITEM_BINARY, (void *) data, size);
|
||||
}
|
||||
|
||||
static inline WUPSStorageError WUPS_GetItem(wups_storage_item parent, const char *key, WUPSStorageItemType type, void *data, uint32_t maxSize, uint32_t *outSize) {
|
||||
if (__internal_functions.get_item_function_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
return __internal_functions.get_item_function_ptr(__internal_functions.__storageroot_item, parent, key, type, data, maxSize, outSize);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetString(wups_storage_item parent, const char *key, char *outString, uint32_t maxSize, uint32_t *outSize) {
|
||||
if (outString == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
isDirty = true;
|
||||
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->deleted || item->type == WUPS_STORAGE_TYPE_INVALID) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(item->key, key) == 0) {
|
||||
free(item->data);
|
||||
free(item->key);
|
||||
item->key = nullptr;
|
||||
item->data = nullptr;
|
||||
item->deleted = true;
|
||||
if (sActiveSubItem == item) {
|
||||
sActiveSubItem = nullptr;
|
||||
}
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
return WUPS_STORAGE_ERROR_NOT_FOUND;
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_STRING, outString, maxSize, outSize);
|
||||
}
|
||||
|
||||
// int32_t WUPS_GetSize(const char* key) {
|
||||
// if (!storage_initialized) {
|
||||
// return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
// }
|
||||
|
||||
// if (!isOpened) {
|
||||
// return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
// }
|
||||
|
||||
// for (uint32_t i = 0; i < amount_of_items; i++) {
|
||||
// wups_loader_storage_item_t* item = &items[i];
|
||||
|
||||
// if (item->pending_delete || item->type == WUPS_STORAGE_TYPE_INVALID) {
|
||||
// continue;
|
||||
// }
|
||||
|
||||
// if (strcmp(item->key, key) == 0) {
|
||||
// return item->data_size;
|
||||
// }
|
||||
// }
|
||||
|
||||
// return WUPS_STORAGE_ERROR_NOT_FOUND;
|
||||
// }
|
||||
|
||||
static wups_storage_item_t *addItem(wups_storage_item_t *parent, const char *key, wups_storage_type_t type, WUPSStorageError *error) {
|
||||
wups_storage_item_t *foundItem = nullptr;
|
||||
// First check for existing item with the same name.
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->key && strcmp(item->key, key) == 0) {
|
||||
free(item->data);
|
||||
foundItem = item;
|
||||
break;
|
||||
}
|
||||
WUPSStorageError WUPS_GetBool(wups_storage_item parent, const char *key, bool *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!foundItem) {
|
||||
// Then check if there are any deleted item we can override.
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->deleted) {
|
||||
free(item->data);
|
||||
free(item->key);
|
||||
item->data = nullptr;
|
||||
item->key = nullptr;
|
||||
|
||||
item->key = strdup(key);
|
||||
if (item->key == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
foundItem = item;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!foundItem) {
|
||||
auto *newPtr = (wups_storage_item_t *) realloc(parent->data, (parent->data_size + 1) * sizeof(wups_storage_item_t));
|
||||
if (newPtr == nullptr) {
|
||||
*error = WUPS_STORAGE_ERROR_MALLOC_FAILED;
|
||||
return nullptr;
|
||||
}
|
||||
parent->data = newPtr;
|
||||
|
||||
foundItem = &((wups_storage_item_t *) parent->data)[parent->data_size];
|
||||
memset(foundItem, 0, sizeof(wups_storage_item_t));
|
||||
foundItem->deleted = true;
|
||||
|
||||
parent->data_size += 1;
|
||||
|
||||
foundItem->key = strdup(key);
|
||||
if (foundItem->key == nullptr) {
|
||||
*error = WUPS_STORAGE_ERROR_MALLOC_FAILED;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
foundItem->type = type;
|
||||
foundItem->deleted = false;
|
||||
foundItem->data = nullptr;
|
||||
foundItem->data_size = 0;
|
||||
return foundItem;
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_BOOL, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_CreateSubItem(wups_storage_item_t *parent, const char *key, wups_storage_item_t **outItem) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
WUPSStorageError WUPS_GetInt(wups_storage_item parent, const char *key, int32_t *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_S32, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
WUPSStorageError WUPS_GetS32(wups_storage_item parent, const char *key, int32_t *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_S32, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
if (!key || !outItem) {
|
||||
WUPSStorageError WUPS_GetS64(wups_storage_item parent, const char *key, int64_t *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_S64, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetU32(wups_storage_item parent, const char *key, uint32_t *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_U32, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetU64(wups_storage_item parent, const char *key, uint64_t *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_U64, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetFloat(wups_storage_item parent, const char *key, float *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_FLOAT, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetDouble(wups_storage_item parent, const char *key, double *outValue) {
|
||||
if (outValue == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_DOUBLE, outValue, sizeof(*outValue), nullptr);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetBinary(wups_storage_item parent, const char *key, void *outData, uint32_t maxSize, uint32_t *outValue) {
|
||||
if (outData == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
isDirty = true;
|
||||
|
||||
WUPSStorageError error;
|
||||
wups_storage_item_t *item = addItem(parent, key, WUPS_STORAGE_TYPE_ITEM, &error);
|
||||
if (item == nullptr) {
|
||||
return error;
|
||||
}
|
||||
sActiveSubItem = item;
|
||||
|
||||
*outItem = item;
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
return WUPS_GetItem(parent, key, WUPS_STORAGE_ITEM_BINARY, outData, maxSize, outValue);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetSubItem(wups_storage_item_t *parent, const char *key, wups_storage_item_t **outItem) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key || outItem == nullptr) {
|
||||
WUPSStorageError WUPS_GetItemSize(wups_storage_item parent, const char *key, uint32_t *outSize) {
|
||||
if (outSize == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
if (__internal_functions.get_item_size_function_ptr == nullptr) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->deleted || item->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(item->key, key) == 0) {
|
||||
sActiveSubItem = item;
|
||||
*outItem = item;
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
return WUPS_STORAGE_ERROR_NOT_FOUND;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreString(wups_storage_item_t *parent, const char *key, const char *string) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key || !string) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
isDirty = true;
|
||||
|
||||
WUPSStorageError error;
|
||||
wups_storage_item_t *item = addItem(parent, key, WUPS_STORAGE_TYPE_STRING, &error);
|
||||
if (item == nullptr) {
|
||||
return error;
|
||||
}
|
||||
|
||||
uint32_t size = strlen(string) + 1;
|
||||
item->data = malloc(size);
|
||||
if (item->data == nullptr) {
|
||||
item->key = nullptr;
|
||||
item->deleted = true;
|
||||
return WUPS_STORAGE_ERROR_MALLOC_FAILED;
|
||||
}
|
||||
item->data_size = size;
|
||||
strcpy((char *) item->data, string);
|
||||
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreBool(wups_storage_item_t *parent, const char *key, bool value) {
|
||||
return WUPS_StoreInt(parent, key, (int32_t) value);
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreInt(wups_storage_item_t *parent, const char *key, int32_t value) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
isDirty = true;
|
||||
|
||||
WUPSStorageError error;
|
||||
wups_storage_item_t *item = addItem(parent, key, WUPS_STORAGE_TYPE_INT, &error);
|
||||
if (item == nullptr) {
|
||||
return error;
|
||||
}
|
||||
|
||||
item->data = malloc(sizeof(int32_t));
|
||||
if (item->data == nullptr) {
|
||||
item->key = nullptr;
|
||||
item->deleted = true;
|
||||
return WUPS_STORAGE_ERROR_MALLOC_FAILED;
|
||||
}
|
||||
item->data_size = sizeof(int32_t);
|
||||
*(int32_t *) item->data = value;
|
||||
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_StoreBinary(wups_storage_item_t *parent, const char *key, const void *data, uint32_t size) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key || !data || size == 0) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
isDirty = true;
|
||||
|
||||
WUPSStorageError error;
|
||||
wups_storage_item_t *item = addItem(parent, key, WUPS_STORAGE_TYPE_STRING, &error);
|
||||
if (item == nullptr) {
|
||||
return error;
|
||||
}
|
||||
|
||||
item->data = b64_encode((const uint8_t *) data, size);
|
||||
if (item->data == nullptr) {
|
||||
item->key = nullptr;
|
||||
item->deleted = true;
|
||||
return WUPS_STORAGE_ERROR_MALLOC_FAILED;
|
||||
}
|
||||
item->data_size = strlen((char *) data) + 1;
|
||||
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetString(wups_storage_item_t *parent, const char *key, char *outString, uint32_t maxSize) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key || !outString || maxSize == 0) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->deleted || item->type != WUPS_STORAGE_TYPE_STRING) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(item->key, key) == 0) {
|
||||
strncpy(outString, (char *) item->data, maxSize);
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
}
|
||||
return WUPS_STORAGE_ERROR_NOT_FOUND;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetBool(wups_storage_item_t *parent, const char *key, bool *outBool) {
|
||||
int32_t out;
|
||||
WUPSStorageError result = WUPS_GetInt(parent, key, &out);
|
||||
if (result != WUPS_STORAGE_ERROR_SUCCESS) {
|
||||
return result;
|
||||
}
|
||||
|
||||
*outBool = out != 0;
|
||||
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetInt(wups_storage_item_t *parent, const char *key, int32_t *outInt) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key || !outInt) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->deleted || item->type != WUPS_STORAGE_TYPE_INT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(item->key, key) == 0) {
|
||||
*outInt = *(int32_t *) item->data;
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
return WUPS_STORAGE_ERROR_NOT_FOUND;
|
||||
}
|
||||
|
||||
WUPSStorageError WUPS_GetBinary(wups_storage_item_t *parent, const char *key, void *outData, uint32_t maxSize) {
|
||||
if (!storage_initialized) {
|
||||
return WUPS_STORAGE_ERROR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
if (!isOpened) {
|
||||
return WUPS_STORAGE_ERROR_NOT_OPENED;
|
||||
}
|
||||
|
||||
if (!key || !outData || maxSize == 0) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (!parent) {
|
||||
parent = &rootItem;
|
||||
} else {
|
||||
// We can only safely process items of a parent if the parent was the last
|
||||
// item returned by WUPS_GetSubItem or WUPS_CreateSubItem
|
||||
if (parent != sActiveSubItem) {
|
||||
return WUPS_STORAGE_ERROR_NOT_ACTIVE_CATEGORY;
|
||||
}
|
||||
if (parent->type != WUPS_STORAGE_TYPE_ITEM) {
|
||||
return WUPS_STORAGE_ERROR_INVALID_ARGS;
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < parent->data_size; i++) {
|
||||
wups_storage_item_t *item = &((wups_storage_item_t *) parent->data)[i];
|
||||
|
||||
if (item->deleted || item->type != WUPS_STORAGE_TYPE_STRING) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(item->key, key) == 0) {
|
||||
if (b64_decoded_size((char *) item->data) > maxSize) {
|
||||
return WUPS_STORAGE_ERROR_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
if (b64_decode((char *) item->data, (uint8_t *) outData, item->data_size)) {
|
||||
return WUPS_STORAGE_ERROR_SUCCESS;
|
||||
} else {
|
||||
return WUPS_STORAGE_ERROR_B64_DECODE_FAILED;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return WUPS_STORAGE_ERROR_NOT_FOUND;
|
||||
return __internal_functions.get_item_size_function_ptr(__internal_functions.__storageroot_item, parent, key, outSize);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user