vl_msgpack.h

Go to the documentation of this file.

 
#ifndef VL_MSGPACK_H
#define VL_MSGPACK_H
 
#include <string.h>
 
#include "vl_arena.h"
#include "vl_buffer.h"
#include "vl_hashtable.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;
 
VL_API void vlMsgPackInit(vl_msgpack* pack);
 
VL_API void vlMsgPackFree(vl_msgpack* pack);
 
VL_API vl_msgpack* vlMsgPackNew(void);
 
VL_API void vlMsgPackDelete(vl_msgpack* pack);
 
VL_API void vlMsgPackClear(vl_msgpack* pack);
 
VL_API vl_msgpack* vlMsgPackClone(vl_msgpack* src, vl_msgpack* dest);
 
VL_API vl_msgpack_iter vlMsgPackParent(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API vl_dsidx_t vlMsgPackTotalChildren(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API vl_msgpack_iter vlMsgPackFirstChild(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API vl_msgpack_iter vlMsgPackNextSibling(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API vl_msgpack_iter vlMsgPackPrevSibling(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API vl_msgpack_type vlMsgPackType(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API vl_int8_t vlMsgPackExtType(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API 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);
}
 
VL_API void vlMsgPackRemove(vl_msgpack* pack, vl_msgpack_iter iter);
 
VL_API 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_API vl_msgpack_iter vlMsgPackFindChildIndexed(vl_msgpack* pack, vl_msgpack_iter iter, vl_dsidx_t idx);
 
VL_API 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_API 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