vl_msgpack.h

Go to the documentation of this file.

#ifndef VL_MSGPACK_H
#define VL_MSGPACK_H
 
#include "vl_hashtable.h"
#include "vl_arena.h"
#include "vl_buffer.h"
#include <string.h>
 
#define VL_MSGPACK_ITER_INVALID     VL_HASHTABLE_ITER_INVALID
#define VL_MSGPACK_EXT_NONE         -127
 
#define VL_MSGPACK_FOREACH_CHILD(packPtr, parentIter, childIterSymbol)                  \
    for(vl_msgpack_iter childIterSymbol = vlMsgPackFirstChild((packPtr), (parentIter)); \
    childIterSymbol != VL_MSGPACK_ITER_INVALID;                                         \
    childIterSymbol = vlMsgPackNextSibling((packPtr), (childIterSymbol)))
 
typedef vl_hash_iter vl_msgpack_iter;
 
typedef enum vl_msgpack_type_{
    VL_MSGPACK_NIL,
    VL_MSGPACK_BOOL,
    VL_MSGPACK_INT,
    VL_MSGPACK_UINT,
    VL_MSGPACK_FLOAT32,
    VL_MSGPACK_FLOAT64,
    VL_MSGPACK_STRING,
    VL_MSGPACK_BINARY,
    VL_MSGPACK_ARRAY,
 
    VL_MSGPACK_MAP,
 
    VL_MSGPACK_EXT
} vl_msgpack_type;
 
typedef struct vl_msgpack_{
    vl_hashtable        nodes;      //hierarchy
    vl_arena            values;     //data
    vl_msgpack_iter     root;       //root node
} vl_msgpack;
 
void                vlMsgPackInit(vl_msgpack* pack);
 
void                vlMsgPackFree(vl_msgpack* pack);
 
vl_msgpack*         vlMsgPackNew();
 
void                vlMsgPackDelete(vl_msgpack* pack);
 
void vlMsgPackClear(vl_msgpack* pack);
 
 
vl_msgpack*         vlMsgPackClone(vl_msgpack* src, vl_msgpack* dest);
 
vl_msgpack_iter vlMsgPackParent(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_dsidx_t vlMsgPackTotalChildren(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_msgpack_iter vlMsgPackFirstChild(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_msgpack_iter vlMsgPackNextSibling(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_msgpack_iter vlMsgPackPrevSibling(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_msgpack_type vlMsgPackType(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_int8_t vlMsgPackExtType(vl_msgpack* pack, vl_msgpack_iter iter);
 
vl_msgpack_iter vlMsgPackInsertExt(
        vl_msgpack *pack,
        vl_msgpack_type type,
        vl_int8_t subType,
        vl_msgpack_iter parent,
        const void *keyPtr,
        vl_memsize_t keyLen,
        const void *dataPtr,
        vl_memsize_t dataLen
);
 
static inline vl_msgpack_iter vlMsgPackInsert(
        vl_msgpack *pack,
        vl_msgpack_type type,
        vl_msgpack_iter parent,
        const void *keyPtr,
        vl_memsize_t keyLen,
        const void *dataPtr,
        vl_memsize_t dataLen
) {
    return vlMsgPackInsertExt(pack, type, VL_MSGPACK_EXT_NONE, parent, keyPtr, keyLen, dataPtr, dataLen);
}
 
void vlMsgPackRemove(vl_msgpack *pack, vl_msgpack_iter iter);
 
vl_msgpack_iter vlMsgPackFindChild(
        vl_msgpack *pack,
        vl_msgpack_iter parent,
        const void *key,
        vl_memsize_t keyLen
);
 
static inline vl_msgpack_iter vlMsgPackFindChildNamed(
        vl_msgpack *pack,
        vl_msgpack_iter parent,
        const char *name
) {
    return vlMsgPackFindChild(pack, parent, name, strlen(name));
}
 
vl_msgpack_iter vlMsgPackFindChildIndexed(
        vl_msgpack *pack,
        vl_msgpack_iter iter,
        vl_dsidx_t idx
);
 
const vl_transient *vlMsgPackSampleKey(
        vl_msgpack *pack,
        vl_msgpack_iter iter,
        vl_memsize_t *size
);
 
static inline vl_dsidx_t vlMsgPackSampleKeyIndex(
        vl_msgpack *pack,
        vl_msgpack_iter iter
) {
    return *((const vl_dsidx_t *) vlMsgPackSampleKey(pack, iter, NULL));
}
 
vl_transient *vlMsgPackSampleValue(
        vl_msgpack *pack,
        vl_msgpack_iter iter,
        vl_memsize_t *size
);
 
#ifndef vlMsgPackRoot
#define vlMsgPackRoot(packPtr) ((packPtr)->root)
#endif
 
static inline vl_msgpack_iter vlMsgPackSetMapNamed(vl_msgpack* pack, vl_msgpack_iter parent, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_MAP, parent, key, strlen(key), NULL, 0);
}
 
static inline vl_msgpack_iter vlMsgPackSetMapIndexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_MAP, parent, &idx, sizeof(vl_dsidx_t), NULL, 0);
}
 
static inline vl_msgpack_iter vlMsgPackSetArrayNamed(vl_msgpack* pack, vl_msgpack_iter parent, vl_dsidx_t arrayLen, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_ARRAY, parent, key, strlen(key), &arrayLen, sizeof(vl_dsidx_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetArrayIndexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_dsidx_t arrayLen, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_ARRAY, parent, &idx, sizeof(vl_dsidx_t), &arrayLen, sizeof(vl_dsidx_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetBoolNamed(vl_msgpack* pack, vl_msgpack_iter parent, vl_bool_t value, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_BOOL, parent, key, strlen(key), &value, sizeof(vl_bool_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetBoolIndexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_bool_t value, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_BOOL, parent, &idx, sizeof(vl_dsidx_t), &value, sizeof(vl_bool_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetIntNamed(vl_msgpack* pack, vl_msgpack_iter parent, vl_ilarge_t value, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_INT, parent, key, strlen(key), &value, sizeof(vl_ilarge_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetIntIndexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_ilarge_t value, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_INT, parent, &idx, sizeof(vl_dsidx_t), &value, sizeof(vl_ilarge_t));
}
static inline vl_msgpack_iter vlMsgPackSetUIntNamed(vl_msgpack* pack, vl_msgpack_iter parent, vl_ularge_t value, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_UINT, parent, key, strlen(key), &value, sizeof(vl_ularge_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetUIntIndexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_ularge_t value, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_UINT, parent, &idx, sizeof(vl_dsidx_t), &value, sizeof(vl_ularge_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetFloat32Named(vl_msgpack* pack, vl_msgpack_iter parent, vl_float32_t value, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_FLOAT32, parent, key, strlen(key), &value, sizeof(vl_float32_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetFloat32Indexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_float32_t value, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_FLOAT32, parent, &idx, sizeof(vl_dsidx_t), &value, sizeof(vl_float32_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetFloat64Named(vl_msgpack* pack, vl_msgpack_iter parent, vl_float64_t value, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_FLOAT64, parent, key, strlen(key), &value, sizeof(vl_float64_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetFloat64Indexed(vl_msgpack* pack, vl_msgpack_iter parent, vl_float64_t value, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_FLOAT64, parent, &idx, sizeof(vl_dsidx_t), &value, sizeof(vl_float64_t));
}
 
static inline vl_msgpack_iter vlMsgPackSetStringNamed(vl_msgpack* pack, vl_msgpack_iter parent, const char* value, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_STRING, parent, key, strlen(key), value, strlen(value));
}
 
static inline vl_msgpack_iter vlMsgPackSetStringIndexed(vl_msgpack* pack, vl_msgpack_iter parent, const char* value, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_STRING, parent, &idx, sizeof(vl_dsidx_t), value, strlen(value));
}
 
static inline vl_msgpack_iter vlMsgPackSetBinaryNamed(vl_msgpack* pack, vl_msgpack_iter parent, const void* value, vl_memsize_t valLen, const char* key){
    return vlMsgPackInsert(pack, VL_MSGPACK_BINARY, parent, key, strlen(key), value, valLen);
}
 
static inline vl_msgpack_iter vlMsgPackSetBinaryIndexed(vl_msgpack* pack, vl_msgpack_iter parent, const void* value, vl_memsize_t valLen, vl_dsidx_t idx){
    return vlMsgPackInsert(pack, VL_MSGPACK_BINARY, parent, &idx, sizeof(vl_dsidx_t), value, valLen);
}
 
static inline vl_bool_t vlMsgPackGetBool(vl_msgpack* pack, vl_msgpack_iter iter, vl_bool_t defaultValue){
    if(iter == VL_MSGPACK_ITER_INVALID)
        return defaultValue;
    if((vlMsgPackType(pack, iter) != VL_MSGPACK_BOOL))
        return defaultValue;
 
    return *((const vl_bool_t*) vlMsgPackSampleValue(pack, iter, NULL));
}
 
static inline vl_ilarge_t vlMsgPackGetInt(vl_msgpack* pack, vl_msgpack_iter iter, vl_ilarge_t defaultValue){
    if(iter == VL_MSGPACK_ITER_INVALID)
        return defaultValue;
    if((vlMsgPackType(pack, iter) != VL_MSGPACK_INT))
        return defaultValue;
 
    return *((const vl_ilarge_t*) vlMsgPackSampleValue(pack, iter, NULL));
}
 
static inline vl_ilarge_t vlMsgPackGetUInt(vl_msgpack* pack, vl_msgpack_iter iter, vl_ularge_t defaultValue){
    if(iter == VL_MSGPACK_ITER_INVALID)
        return defaultValue;
    if((vlMsgPackType(pack, iter) != VL_MSGPACK_UINT))
        return defaultValue;
 
    return *((const vl_ularge_t*) vlMsgPackSampleValue(pack, iter, NULL));
}
 
static inline vl_float32_t vlMsgPackGetFloat32(vl_msgpack* pack, vl_msgpack_iter iter, vl_float32_t defaultValue){
    if(iter == VL_MSGPACK_ITER_INVALID)
        return defaultValue;
    if(vlMsgPackType(pack, iter) != VL_MSGPACK_FLOAT32)
        return defaultValue;
 
    return *((const vl_float32_t*) vlMsgPackSampleValue(pack, iter, NULL));
}
 
static inline vl_float64_t vlMsgPackGetFloat64(vl_msgpack* pack, vl_msgpack_iter iter, vl_float64_t defaultValue){
    if(iter == VL_MSGPACK_ITER_INVALID)
        return defaultValue;
    if(vlMsgPackType(pack, iter) != VL_MSGPACK_FLOAT64)
        return defaultValue;
 
    return *((const vl_float64_t*) vlMsgPackSampleValue(pack, iter, NULL));
}
 
#endif //VL_MSGPACK_H