gp_json_serdes.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2021-2023 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef GP_JSON_SERDES_H
#define GP_JSON_SERDES_H
 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>
 
#include <utils/gp_json_common.h>
 
enum json_serdes_type {
        GP_JSON_SERDES_STR,
        GP_JSON_SERDES_UINT,
        GP_JSON_SERDES_INT,
        GP_JSON_SERDES_FLOAT,
        GP_JSON_SERDES_BOOL,
 
        GP_JSON_SERDES_OPTIONAL = 0x80,
};
 
#define GP_JSON_SERDES_TYPE(type) ((type) & 0x0f)
 
struct gp_json_int_limits {
        int64_t min;
        uint64_t max;
};
 
struct gp_json_float_limits {
        float min;
        float max;
};
 
typedef struct gp_json_struct {
        const char *id;
        size_t offset;
 
        enum json_serdes_type type;
        size_t type_size;
 
        union {
                struct gp_json_int_limits lim_int;
                struct gp_json_float_limits lim_float;
                size_t str_max_size;
        };
} gp_json_struct;
 
#define GP_2(P1, P2, ...) P2
 
#define GP_JSON_SERDES_STR_CPY(struct, memb, flags, size, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_STR | flags, \
         .type_size = size}
 
#define GP_JSON_SERDES_STR_DUP(struct, memb, flags, max_size, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_STR | flags, \
         .str_max_size = max_size}
 
#define GP_JSON_SERDES_INT(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = sizeof(int), \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_UINT(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = sizeof(unsigned int), \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_LONG(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = sizeof(long), \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_ULONG(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = sizeof(unsigned long), \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_LLONG(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = sizeof(long long), \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_ULLONG(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = sizeof(unsigned long long), \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_INT8(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = 1, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_UINT8(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = 1, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_INT16(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = 2, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_UINT16(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = 2, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_INT32(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = 4, .lim_int = {min, max}}
 
#define GP_JSON_SERDES_UINT32(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = 4, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_INT64(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_INT | flags, \
         .type_size = 8, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_UINT64(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_UINT | flags, \
         .type_size = 8, \
         .lim_int = {min, max}}
 
#define GP_JSON_SERDES_FLOAT(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_FLOAT | flags, \
         .type_size = sizeof(float), \
         .lim_float = {min, max}}
 
#define GP_JSON_SERDES_DOUBLE(struct, memb, flags, min, max, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_FLOAT | flags, \
         .type_size = sizeof(double), \
         .lim_float = {min, max}}
 
#define GP_JSON_SERDES_BOOL(struct, memb, flags, ...) \
        {.id = GP_2(dummy, ##__VA_ARGS__, #memb), \
         .offset = offsetof(struct, memb), \
         .type = GP_JSON_SERDES_BOOL | flags}
 
int gp_json_read_struct(gp_json_reader *json, gp_json_val *val,
                        const gp_json_struct *desc, void *baseptr);
 
int gp_json_load_struct(const char *path,
                        const gp_json_struct *desc, void *baseptr);
 
int gp_json_write_struct(gp_json_writer *json, const gp_json_struct *desc,
                         const char *id, void *baseptr);
 
int gp_json_save_struct(const char *path,
                        const gp_json_struct *desc, void *baseptr);
 
#endif /* GP_JSON_SERDES_H */