yapb.h

Go to the documentation of this file.

#pragma once
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdalign.h>







typedef enum {
    YAPB_INT8   = 0x00, 
    YAPB_INT16  = 0x01, 
    YAPB_INT32  = 0x02, 
    YAPB_INT64  = 0x03, 
    YAPB_FLOAT  = 0x04, 
    YAPB_DOUBLE = 0x05, 
    // 0x06-0x0D reserved for future types
    YAPB_BLOB       = 0x0E, 
    YAPB_NESTED_PKT = 0x0F, 
} YAPB_Type_t;

#define YAPB_MODE_WRITE 0
#define YAPB_MODE_READ  1

#define YAPB_HEADER_SIZE 4

typedef enum {
    YAPB_ERR_NO_MORE_ELEMENTS = -7, 
    YAPB_ERR_INVALID_PACKET   = -6, 
    YAPB_ERR_TYPE_MISMATCH    = -5, 
    YAPB_ERR_INVALID_MODE     = -4, 
    YAPB_ERR_BUFFER_TOO_SMALL = -3, 
    YAPB_ERR_NULL_PTR         = -2, 
    YAPB_ERR_UNKNOWN          = -1, 
    YAPB_OK                   = 0,  
    YAPB_STS_COMPLETE         = 1,  
} YAPB_Result_t;

#define YAPB_PACKET_SIZE 48

typedef struct YAPB_Packet {
    alignas(max_align_t) unsigned char _opaque[YAPB_PACKET_SIZE];
} YAPB_Packet_t;

typedef struct YAPB_Element {
    YAPB_Type_t type; 
    union {
        int8_t   i8;     
        int16_t  i16;    
        int32_t  i32;    
        int64_t  i64;    
        float    f;      
        double   d;      
        struct { const uint8_t *data; uint16_t len; } blob; 
        YAPB_Packet_t nested; 
    } val; 
} YAPB_Element_t;

YAPB_Result_t YAPB_initialize(YAPB_Packet_t *pkt, uint8_t *buffer, size_t size);

YAPB_Result_t YAPB_finalize(YAPB_Packet_t *pkt, size_t *out_len);

YAPB_Result_t YAPB_load(YAPB_Packet_t *pkt, const uint8_t *data, size_t size);

YAPB_Result_t YAPB_push_i8(YAPB_Packet_t *pkt, const int8_t *val);

YAPB_Result_t YAPB_push_i16(YAPB_Packet_t *pkt, const int16_t *val);

YAPB_Result_t YAPB_push_i32(YAPB_Packet_t *pkt, const int32_t *val);

YAPB_Result_t YAPB_push_i64(YAPB_Packet_t *pkt, const int64_t *val);

YAPB_Result_t YAPB_push_float(YAPB_Packet_t *pkt, const float *val);

YAPB_Result_t YAPB_push_double(YAPB_Packet_t *pkt, const double *val);

YAPB_Result_t YAPB_push_blob(YAPB_Packet_t *pkt, const uint8_t *data, uint16_t len);

YAPB_Result_t YAPB_push_nested(YAPB_Packet_t *pkt, const YAPB_Packet_t *nested);

static inline YAPB_Result_t YAPB_push_u8(YAPB_Packet_t *pkt, const uint8_t *val) {
    return YAPB_push_i8(pkt, (const int8_t *)val);
}
static inline YAPB_Result_t YAPB_push_u16(YAPB_Packet_t *pkt, const uint16_t *val) {
    return YAPB_push_i16(pkt, (const int16_t *)val);
}
static inline YAPB_Result_t YAPB_push_u32(YAPB_Packet_t *pkt, const uint32_t *val) {
    return YAPB_push_i32(pkt, (const int32_t *)val);
}
static inline YAPB_Result_t YAPB_push_u64(YAPB_Packet_t *pkt, const uint64_t *val) {
    return YAPB_push_i64(pkt, (const int64_t *)val);
}

YAPB_Result_t YAPB_pop_next(YAPB_Packet_t *pkt, YAPB_Element_t *out);

YAPB_Result_t YAPB_pop_i8(YAPB_Packet_t *pkt, int8_t *out);

YAPB_Result_t YAPB_pop_i16(YAPB_Packet_t *pkt, int16_t *out);

YAPB_Result_t YAPB_pop_i32(YAPB_Packet_t *pkt, int32_t *out);

YAPB_Result_t YAPB_pop_i64(YAPB_Packet_t *pkt, int64_t *out);

YAPB_Result_t YAPB_pop_float(YAPB_Packet_t *pkt, float *out);

YAPB_Result_t YAPB_pop_double(YAPB_Packet_t *pkt, double *out);

YAPB_Result_t YAPB_pop_blob(YAPB_Packet_t *pkt, const uint8_t **data, uint16_t *len);

YAPB_Result_t YAPB_pop_nested(YAPB_Packet_t *pkt, YAPB_Packet_t *out);

static inline YAPB_Result_t YAPB_pop_u8(YAPB_Packet_t *pkt, uint8_t *out) {
    return YAPB_pop_i8(pkt, (int8_t *)out);
}
static inline YAPB_Result_t YAPB_pop_u16(YAPB_Packet_t *pkt, uint16_t *out) {
    return YAPB_pop_i16(pkt, (int16_t *)out);
}
static inline YAPB_Result_t YAPB_pop_u32(YAPB_Packet_t *pkt, uint32_t *out) {
    return YAPB_pop_i32(pkt, (int32_t *)out);
}
static inline YAPB_Result_t YAPB_pop_u64(YAPB_Packet_t *pkt, uint64_t *out) {
    return YAPB_pop_i64(pkt, (int64_t *)out);
}

YAPB_Result_t YAPB_get_error(const YAPB_Packet_t *pkt);

YAPB_Result_t YAPB_get_elem_count(const YAPB_Packet_t *pkt, uint16_t *out_count);

const char *YAPB_Result_str(YAPB_Result_t result);

const uint8_t *YAPB_get_buffer(const YAPB_Packet_t *pkt, size_t *out_len);

bool YAPB_check_complete(const uint8_t *data, size_t len);