serialize_spaces.c File Reference

#include <rz_util/rz_serialize.h>
#include <rz_util/rz_spaces.h>

Go to the source code of this file.

Macros
#define	KEY_NAME   "name"
#define	KEY_SPACESTACK   "spacestack"
#define	KEY_SPACES   "spaces"

Functions
RZ_API void	rz_serialize_spaces_save (RZ_NONNULL Sdb *db, RZ_NONNULL RzSpaces *spaces)
static bool	foreach_space_cb (void *user, const char *k, const char *v)
RZ_API bool	rz_serialize_spaces_load (RZ_NONNULL Sdb *db, RZ_NONNULL RzSpaces *spaces, bool load_name, RZ_NULLABLE RzSerializeResultInfo *res)

Macro Definition Documentation

KEY_NAME

#define KEY_NAME   "name"

Definition at line 18 of file serialize_spaces.c.

KEY_SPACES

#define KEY_SPACES   "spaces"

Definition at line 20 of file serialize_spaces.c.

KEY_SPACESTACK

#define KEY_SPACESTACK   "spacestack"

Definition at line 19 of file serialize_spaces.c.

Function Documentation

foreach_space_cb()

static bool foreach_space_cb ( void *  user, const char *  k, const char *  v  )

static

Definition at line 48 of file serialize_spaces.c.

                                                                       {
    RzSpaces *spaces = user;
    rz_spaces_add(spaces, k);
    return true;
}

References k, rz_spaces_add(), and spaces().

Referenced by rz_serialize_spaces_load().

rz_serialize_spaces_load()

RZ_API bool rz_serialize_spaces_load	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzSpaces *	spaces,
		bool	load_name,
		RZ_NULLABLE RzSerializeResultInfo *	res
	)

Parameters

load_name

whether to overwrite the name in spaces with the value from db

Definition at line 54 of file serialize_spaces.c.

                                                                                                                                              {
    if (load_name) {
        char *old_name = (char *)spaces->name;
        spaces->name = sdb_get(db, KEY_NAME, NULL);
        if (!spaces->name) {
            spaces->name = old_name;
            RZ_SERIALIZE_ERR(res, "failed to get spaces name from db");
            return false;
        }
        free(old_name);
    }
 
    rz_spaces_purge(spaces);
 
    Sdb *db_spaces = sdb_ns(db, KEY_SPACES, false);
    if (!db_spaces) {
        RZ_SERIALIZE_ERR(res, "failed to get spaces sub-namespace");
        return false;
    }
    sdb_foreach(db_spaces, foreach_space_cb, spaces);
 
    char *stack_json_str = sdb_get(db, KEY_SPACESTACK, NULL);
    if (!stack_json_str) {
        RZ_SERIALIZE_ERR(res, "spacestack is missing");
        return false;
    }
 
    bool ret = true;
    RzJson *stack_json = rz_json_parse(stack_json_str);
    if (!stack_json) {
        RZ_SERIALIZE_ERR(res, "failed to parse stackspace json");
        ret = false;
        goto beach;
    }
    if (stack_json->type != RZ_JSON_ARRAY) {
        RZ_SERIALIZE_ERR(res, "stackspace json is not an array");
        ret = false;
        goto beach;
    }
    RzJson *stack_element;
    for (stack_element = stack_json->children.first; stack_element; stack_element = stack_element->next) {
        if (stack_element->type != RZ_JSON_STRING) {
            RZ_SERIALIZE_ERR(res, "stackspace element is not a string");
            ret = false;
            goto beach;
        }
        RzSpace *space = rz_spaces_get(spaces, stack_element->str_value);
        rz_list_append(spaces->spacestack, space ? space->name : "*");
    }
 
    rz_spaces_pop(spaces); // current is the top stack element, pop it
 
beach:
    rz_json_free(stack_json);
    free(stack_json_str);
    return ret;
}

References rz_json_t::children, foreach_space_cb(), free(), KEY_NAME, KEY_SPACES, KEY_SPACESTACK, rz_space_t::name, rz_json_t::next, NULL, RZ_JSON_ARRAY, rz_json_free(), rz_json_parse(), RZ_JSON_STRING, rz_list_append(), RZ_SERIALIZE_ERR, rz_spaces_get(), rz_spaces_pop(), rz_spaces_purge(), sdb_foreach(), sdb_get(), sdb_ns(), spaces(), rz_json_t::str_value, and rz_json_t::type.

Referenced by rz_serialize_analysis_meta_load(), and rz_serialize_flag_load().

rz_serialize_spaces_save()

RZ_API void rz_serialize_spaces_save	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzSpaces *	spaces
	)

Definition at line 22 of file serialize_spaces.c.

                                                                                      {
    sdb_set(db, KEY_NAME, spaces->name, 0);
 
    PJ *j = pj_new();
    if (!j) {
        return;
    }
    pj_a(j);
    RzListIter *iter;
    char *spacename;
    rz_list_foreach (spaces->spacestack, iter, spacename) {
        pj_s(j, spacename);
    }
    pj_s(j, spaces->current ? spaces->current->name : "*"); // push current manually, will be popped on load
    pj_end(j);
    sdb_set(db, KEY_SPACESTACK, pj_string(j), 0);
    pj_free(j);
 
    Sdb *db_spaces = sdb_ns(db, KEY_SPACES, true);
    RBIter rbiter;
    RzSpace *space;
    rz_rbtree_foreach (spaces->spaces, rbiter, space, RzSpace, rb) {
        sdb_set(db_spaces, space->name, "s", 0);
    }
}

References KEY_NAME, KEY_SPACES, KEY_SPACESTACK, rz_space_t::name, pj_a(), pj_end(), pj_free(), pj_new(), pj_s(), pj_string(), rz_rbtree_foreach, sdb_ns(), sdb_set(), and spaces().

Referenced by rz_serialize_analysis_meta_save(), and rz_serialize_flag_save().