flat_tree.h

 
 
 
#ifndef ASRT_FLAT_TREE_H
#define ASRT_FLAT_TREE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "./allocator.h"
#include "./status.h"
#include "./util.h"
 
#include <stdint.h>
#include <string.h>
 
typedef uint32_t asrt_flat_id;
 
enum asrt_flat_stype
{
        ASRT_FLAT_STYPE_NONE  = 0,
        ASRT_FLAT_STYPE_STR   = 1,
        ASRT_FLAT_STYPE_U32   = 2,
        ASRT_FLAT_STYPE_FLOAT = 3,
        ASRT_FLAT_STYPE_BOOL  = 4,
        ASRT_FLAT_STYPE_NULL  = 5,
        ASRT_FLAT_STYPE_I32   = 6,
};
 
enum asrt_flat_ctype
{
        ASRT_FLAT_CTYPE_NONE   = 0,
        ASRT_FLAT_CTYPE_OBJECT = 7,
        ASRT_FLAT_CTYPE_ARRAY  = 8,
};
 
typedef uint8_t asrt_flat_value_type;
 
struct asrt_flat_child_list
{
        asrt_flat_id first_child;
        asrt_flat_id last_child;
};
 
union asrt_flat_scalar
{
        char const* str_val;
        uint32_t    u32_val;
        int32_t     i32_val;
        float       float_val;
        uint32_t    bool_val;
};
 
union asrt_flat_data
{
        union asrt_flat_scalar      s;
        struct asrt_flat_child_list cont;
};
 
struct asrt_flat_value
{
        asrt_flat_value_type type;
        union asrt_flat_data data;
};
 
struct asrt_flat_node
{
        struct asrt_flat_value value;
        char const*  key;  
        asrt_flat_id next_sibling;  
};
 
struct asrt_flat_block
{
        struct asrt_flat_node* nodes;
        uint32_t               node_count;
};
 
enum asrt_status asrt_flat_block_init(
    struct asrt_flat_block* block,
    struct asrt_allocator*  alloc,
    uint32_t                node_capacity );
 
enum asrt_status asrt_flat_block_deinit(
    struct asrt_flat_block* block,
    struct asrt_allocator*  alloc,
    uint32_t                node_capacity );
 
struct asrt_flat_tree
{
        struct asrt_allocator alloc;
 
        struct asrt_flat_block* blocks;
        uint32_t                block_capacity;
 
        uint32_t node_capacity;  
};
 
enum asrt_status asrt_flat_tree_init(
    struct asrt_flat_tree* tree,
    struct asrt_allocator  alloc,
    uint32_t               block_capacity,
    uint32_t               node_capacity );
 
enum asrt_status asrt_flat_tree_append_scalar(
    struct asrt_flat_tree* tree,
    asrt_flat_id           parent_id,
    asrt_flat_id           node_id,
    char const*            key,
    asrt_flat_value_type   type,
    union asrt_flat_scalar scalar );
 
enum asrt_status asrt_flat_tree_append_cont(
    struct asrt_flat_tree* tree,
    asrt_flat_id           parent_id,
    asrt_flat_id           node_id,
    char const*            key,
    asrt_flat_value_type   type );
 
struct asrt_flat_query_result
{
        asrt_flat_id           id;
        char const*            key;
        struct asrt_flat_value value;
        asrt_flat_id           next_sibling;  
};
 
enum asrt_status asrt_flat_tree_query(
    struct asrt_flat_tree const*   tree,
    asrt_flat_id                   node_id,
    struct asrt_flat_query_result* result );
 
enum asrt_status asrt_flat_tree_find_by_key(
    struct asrt_flat_tree*         tree,
    asrt_flat_id                   parent_id,
    char const*                    key,
    struct asrt_flat_query_result* result );
 
enum asrt_status asrt_flat_tree_deinit( struct asrt_flat_tree* tree );
 
size_t asrt_flat_value_wire_size( struct asrt_flat_value v );
 
void asrt_flat_value_write( uint8_t** p, struct asrt_flat_value v );
 
enum asrt_status asrt_flat_value_decode(
    struct asrt_span*       buff,
    uint8_t                 raw_type,
    struct asrt_flat_value* val );
 
#ifdef __cplusplus
}
#endif
 
#endif