gp_json_reader.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2021-2022 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef GP_JSON_READER_H
#define GP_JSON_READER_H
 
#include <stdio.h>
#include <core/gp_compiler.h>
#include <utils/gp_json_common.h>
 
#define GP_JSON_READER_INIT(buf, buf_len) { \
        .max_depth = GP_JSON_RECURSION_MAX, \
        .err_print = GP_JSON_ERR_PRINT, \
        .err_print_priv = GP_JSON_ERR_PRINT_PRIV, \
        .json = buf, \
        .len = buf_len, \
}
 
struct gp_json_reader {
        const char *json;
        size_t len;
        size_t off;
        size_t sub_off;
        unsigned int depth;
        unsigned int max_depth;
 
        void (*err_print)(void *err_print_priv, const char *line);
        void *err_print_priv;
 
        char err[GP_JSON_ERR_MAX];
        char buf[];
};
 
struct gp_json_val {
        enum gp_json_type type;
 
        char *buf;
        size_t buf_size;
 
        size_t idx;
 
        union {
                int val_bool;
                long long val_int;
                const char *val_str;
        };
 
        double val_float;
 
        char id[GP_JSON_ID_MAX];
 
        char buf__[];
};
 
gp_json_val *gp_json_val_alloc(size_t buf_size);
 
void gp_json_val_free(gp_json_val *self);
 
static inline int gp_json_val_valid(struct gp_json_val *res)
{
        return !!res->type;
}
 
void gp_json_err(gp_json_reader *self, const char *fmt, ...)
               GP_FMT_PRINTF(2, 3);
 
void gp_json_err_print(gp_json_reader *self);
 
void gp_json_warn(gp_json_reader *self, const char *fmt, ...)
                  GP_FMT_PRINTF(2, 3);
 
static inline int gp_json_reader_err(gp_json_reader *self)
{
        return !!self->err[0];
}
 
enum gp_json_type gp_json_next_type(gp_json_reader *self);
 
enum gp_json_type gp_json_reader_start(gp_json_reader *self);
 
int gp_json_obj_first(gp_json_reader *self, struct gp_json_val *res);
 
int gp_json_obj_next(gp_json_reader *self, struct gp_json_val *res);
 
#define GP_JSON_OBJ_FOREACH(self, res) \
        for (gp_json_obj_first(self, res); gp_json_val_valid(res); gp_json_obj_next(self, res))
 
size_t gp_json_lookup(const void *arr, size_t memb_size, size_t list_len,
                      const char *key);
 
typedef struct gp_json_obj_attr {
        const char *key;
        enum gp_json_type type;
} gp_json_obj_attr;
 
typedef struct gp_json_obj {
        const gp_json_obj_attr *attrs;
        size_t attr_cnt;
} gp_json_obj;
 
static inline size_t gp_json_obj_lookup(const gp_json_obj *obj, const char *key)
{
        return gp_json_lookup(obj->attrs, sizeof(*obj->attrs), obj->attr_cnt, key);
}
 
#define GP_JSON_OBJ_ATTR(keyv, typev) \
        {.key = keyv, .type = typev}
 
#define GP_JSON_OBJ_ATTR_IDX(key_idx, keyv, typev) \
        [key_idx] = {.key = keyv, .type = typev}
 
int gp_json_obj_first_filter(gp_json_reader *self, struct gp_json_val *res,
                             const struct gp_json_obj *obj, const struct gp_json_obj *ign);
 
int gp_json_obj_next_filter(gp_json_reader *self, struct gp_json_val *res,
                            const struct gp_json_obj *obj, const struct gp_json_obj *ign);
 
#define GP_JSON_OBJ_FOREACH_FILTER(self, res, obj, ign) \
        for (gp_json_obj_first_filter(self, res, obj, ign); \
             gp_json_val_valid(res); \
             gp_json_obj_next_filter(self, res, obj, ign))
 
int gp_json_obj_skip(gp_json_reader *self);
 
int gp_json_arr_first(gp_json_reader *self, struct gp_json_val *res);
 
int gp_json_arr_next(gp_json_reader *self, struct gp_json_val *res);
 
#define GP_JSON_ARR_FOREACH(self, res) \
        for (gp_json_arr_first(self, res); gp_json_val_valid(res); gp_json_arr_next(self, res))
 
int gp_json_arr_skip(gp_json_reader *self);
 
typedef struct gp_json_reader_state {
        size_t off;
        unsigned int depth;
} gp_json_reader_state;
 
static inline gp_json_reader_state gp_json_reader_state_save(gp_json_reader *self)
{
        struct gp_json_reader_state ret = {
                .off = self->sub_off,
                .depth = self->depth,
        };
 
        return ret;
}
 
static inline void gp_json_reader_state_load(gp_json_reader *self, gp_json_reader_state state)
{
        self->off = state.off;
        self->sub_off = state.off;
        self->depth = state.depth;
}
 
static inline void gp_json_reader_reset(gp_json_reader *self)
{
        self->off = 0;
        self->sub_off = 0;
        self->depth = 0;
        self->err[0] = 0;
}
 
gp_json_reader *gp_json_reader_load(const char *path);
 
void gp_json_reader_free(gp_json_reader *self);
 
void gp_json_reader_finish(gp_json_reader *self);
 
static inline int gp_json_reader_consumed(gp_json_reader *self)
{
        return self->off >= self->len;
}
 
#endif /* GP_JSON_H */