json.h

Go to the documentation of this file.

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef UCX_JSON_H
#define UCX_JSON_H
 
#include "common.h"
#include "allocator.h"
#include "string.h"
#include "buffer.h"
#include "array_list.h"
#include "map.h"

enum cx_json_token_type {
    CX_JSON_NO_TOKEN,
    CX_JSON_TOKEN_ERROR,
    CX_JSON_TOKEN_BEGIN_ARRAY,
    CX_JSON_TOKEN_BEGIN_OBJECT,
    CX_JSON_TOKEN_END_ARRAY,
    CX_JSON_TOKEN_END_OBJECT,
    CX_JSON_TOKEN_NAME_SEPARATOR,
    CX_JSON_TOKEN_VALUE_SEPARATOR,
    CX_JSON_TOKEN_STRING,
    CX_JSON_TOKEN_INTEGER,
    CX_JSON_TOKEN_NUMBER,
    CX_JSON_TOKEN_LITERAL,
    CX_JSON_TOKEN_SPACE
};

enum cx_json_value_type {
    CX_JSON_NOTHING, // this allows us to always return non-NULL values
    CX_JSON_UNINITIALIZED,
    CX_JSON_OBJECT,
    CX_JSON_ARRAY,
    CX_JSON_STRING,
    CX_JSON_INTEGER,
    CX_JSON_NUMBER,
    CX_JSON_LITERAL
};

enum cx_json_literal {
    CX_JSON_NULL,
    CX_JSON_TRUE,
    CX_JSON_FALSE
};

typedef enum cx_json_token_type CxJsonTokenType;
typedef enum cx_json_value_type CxJsonValueType;

typedef struct cx_json_s CxJson;

typedef struct cx_json_token_s CxJsonToken;

typedef struct cx_json_value_s CxJsonValue;

typedef CxMap* CxJsonObject;
typedef struct cx_mutstr_s CxJsonString;
typedef int64_t CxJsonInteger;
typedef double CxJsonNumber;
typedef enum cx_json_literal CxJsonLiteral;

struct cx_json_value_s {
    const CxAllocator *allocator;
    CxJsonValueType type;
    union {
        CX_ARRAY(CxJsonValue*, array);
        CxJsonObject object;
        CxJsonString string;
        CxJsonInteger integer;
        CxJsonNumber number;
        CxJsonLiteral literal;
    };
};

struct cx_json_token_s {
    CxJsonTokenType tokentype;
    bool allocated;
    cxmutstr content;
};

struct cx_json_s {
    const CxAllocator *allocator;

    CxBuffer buffer;

    CxJsonValue *parsed;

    cxmutstr uncompleted_member_name;

    cxmutstr uncompleted_content;

    CxJsonTokenType uncompleted_tokentype;

    CX_ARRAY(int, states);

    CX_ARRAY(CxJsonValue*, vbuf);

    int states_internal[8];

    CxJsonValue* vbuf_internal[8];
};

enum cx_json_status {
    CX_JSON_NO_ERROR,
    CX_JSON_NO_DATA,
    CX_JSON_INCOMPLETE_DATA,
    CX_JSON_OK,
    CX_JSON_NULL_DATA,
    CX_JSON_BUFFER_ALLOC_FAILED,
    CX_JSON_VALUE_ALLOC_FAILED,
    CX_JSON_FORMAT_ERROR_NUMBER,
    CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN
};

typedef enum cx_json_status CxJsonStatus;

struct cx_json_writer_s {
    bool pretty;
    uint8_t frac_max_digits;
    bool indent_space;
    uint8_t indent;
    bool escape_slash;
};

typedef struct cx_json_writer_s CxJsonWriter;

CX_EXTERN CX_NODISCARD
CxJsonWriter cxJsonWriterCompact(void);

CX_EXTERN CX_NODISCARD
CxJsonWriter cxJsonWriterPretty(bool use_spaces);

CX_EXTERN CX_NONNULL_ARG(1, 2, 3)
int cxJsonWrite(void* target, const CxJsonValue* value,
        cx_write_func wfunc, const CxJsonWriter* settings);
 

CX_EXTERN CX_NONNULL_ARG(2) CX_NODISCARD
cxmutstr cxJsonToString(const CxAllocator *allocator, CxJsonValue *value);

CX_EXTERN CX_NONNULL_ARG(2) CX_NODISCARD
cxmutstr cxJsonToPrettyString(const CxAllocator *allocator, CxJsonValue *value);

CX_EXTERN CX_NONNULL_ARG(1)
void cxJsonInit(CxJson *json, const CxAllocator *allocator);

CX_EXTERN CX_NONNULL
void cxJsonDestroy(CxJson *json);

CX_EXTERN CX_NONNULL
void cxJsonReset(CxJson *json);

CX_EXTERN CX_NONNULL_ARG(1) CX_ACCESS_R(2, 3)
int cxJsonFilln(CxJson *json, const char *buf, size_t len);
 

CX_NONNULL CX_INLINE
int cx_json_fill(CxJson *json, cxstring str) {
    return cxJsonFilln(json, str.ptr, str.length);
}

#define cxJsonFill(json, str) cx_json_fill(json, cx_strcast(str))
 

CX_EXTERN CX_NONNULL_ARG(3) CX_ACCESS_W(3)
CxJsonStatus cx_json_from_string(const CxAllocator *allocator,
            cxstring str, CxJsonValue **value);

#define cxJsonFromString(allocator, str, value) \
        cx_json_from_string(allocator, cx_strcast(str), value)

CX_EXTERN
void cxJsonValueFree(CxJsonValue *value);

CX_EXTERN CX_NODISCARD CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cxJsonCreateObj(const CxAllocator* allocator);

CX_EXTERN CX_NODISCARD CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cxJsonCreateArr(const CxAllocator* allocator, size_t capacity);

CX_EXTERN CX_NODISCARD CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cxJsonCreateNumber(const CxAllocator* allocator, double num);

CX_EXTERN CX_NODISCARD CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cxJsonCreateInteger(const CxAllocator* allocator, int64_t num);

CX_EXTERN CX_NODISCARD CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_create_string(const CxAllocator* allocator, cxstring str);

#define cxJsonCreateString(allocator, str) cx_json_create_string(allocator, cx_strcast(str))

CX_EXTERN CX_NODISCARD CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cxJsonCreateLiteral(const CxAllocator* allocator, CxJsonLiteral lit);

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
int cxJsonArrAddNumbers(CxJsonValue* arr, const double* num, size_t count);

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
int cxJsonArrAddIntegers(CxJsonValue* arr, const int64_t* num, size_t count);

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
int cxJsonArrAddStrings(CxJsonValue* arr, const char* const* str, size_t count);

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
int cxJsonArrAddCxStrings(CxJsonValue* arr, const cxstring* str, size_t count);

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
int cxJsonArrAddLiterals(CxJsonValue* arr, const CxJsonLiteral* lit, size_t count);

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
int cxJsonArrAddValues(CxJsonValue* arr, CxJsonValue* const* val, size_t count);

CX_EXTERN CX_NONNULL
int cx_json_obj_put(CxJsonValue* obj, cxstring name, CxJsonValue* child);

#define cxJsonObjPut(obj, name, child) cx_json_obj_put(obj, cx_strcast(name), child)

CX_EXTERN CX_NONNULL CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_obj_put_obj(CxJsonValue* obj, cxstring name);

#define cxJsonObjPutObj(obj, name) cx_json_obj_put_obj(obj, cx_strcast(name))

CX_EXTERN CX_NONNULL CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_obj_put_arr(CxJsonValue* obj, cxstring name, size_t capacity);

#define cxJsonObjPutArr(obj, name, capacity) cx_json_obj_put_arr(obj, cx_strcast(name), capacity)

CX_EXTERN CX_NONNULL CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_obj_put_number(CxJsonValue* obj, cxstring name, double num);

#define cxJsonObjPutNumber(obj, name, num) cx_json_obj_put_number(obj, cx_strcast(name), num)

CX_EXTERN CX_NONNULL CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_obj_put_integer(CxJsonValue* obj, cxstring name, int64_t num);

#define cxJsonObjPutInteger(obj, name, num) cx_json_obj_put_integer(obj, cx_strcast(name), num)

CX_EXTERN CX_NONNULL CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_obj_put_string(CxJsonValue* obj, cxstring name, cxstring str);

#define cxJsonObjPutString(obj, name, str) cx_json_obj_put_string(obj, cx_strcast(name), cx_strcast(str))

CX_EXTERN CX_NONNULL CX_MALLOC CX_DEALLOC(cxJsonValueFree, 1)
CxJsonValue* cx_json_obj_put_literal(CxJsonValue* obj, cxstring name, CxJsonLiteral lit);

#define cxJsonObjPutLiteral(obj, name, lit) cx_json_obj_put_literal(obj, cx_strcast(name), lit)

CX_EXTERN CX_NONNULL CX_ACCESS_W(2)
CxJsonStatus cxJsonNext(CxJson *json, CxJsonValue **value);

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsObject(const CxJsonValue *value) {
    return value->type == CX_JSON_OBJECT;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsArray(const CxJsonValue *value) {
    return value->type == CX_JSON_ARRAY;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsString(const CxJsonValue *value) {
    return value->type == CX_JSON_STRING;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsNumber(const CxJsonValue *value) {
    return value->type == CX_JSON_NUMBER || value->type == CX_JSON_INTEGER;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsInteger(const CxJsonValue *value) {
    return value->type == CX_JSON_INTEGER;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsLiteral(const CxJsonValue *value) {
    return value->type == CX_JSON_LITERAL;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsBool(const CxJsonValue *value) {
    return cxJsonIsLiteral(value) && value->literal != CX_JSON_NULL;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsTrue(const CxJsonValue *value) {
    return cxJsonIsLiteral(value) && value->literal == CX_JSON_TRUE;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsFalse(const CxJsonValue *value) {
    return cxJsonIsLiteral(value) && value->literal == CX_JSON_FALSE;
}

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonIsNull(const CxJsonValue *value) {
    return cxJsonIsLiteral(value) && value->literal == CX_JSON_NULL;
}

CX_EXTERN CX_NONNULL CX_RETURNS_NONNULL CX_NODISCARD
char *cxJsonAsString(const CxJsonValue *value);

CX_EXTERN CX_NONNULL CX_NODISCARD
cxstring cxJsonAsCxString(const CxJsonValue *value);

CX_EXTERN CX_NONNULL CX_NODISCARD
cxmutstr cxJsonAsCxMutStr(const CxJsonValue *value);

CX_EXTERN CX_NONNULL CX_NODISCARD
double cxJsonAsDouble(const CxJsonValue *value);

CX_EXTERN CX_NONNULL CX_NODISCARD
int64_t cxJsonAsInteger(const CxJsonValue *value);

CX_NONNULL CX_NODISCARD CX_INLINE
bool cxJsonAsBool(const CxJsonValue *value) {
    return value->literal == CX_JSON_TRUE;
}

CX_NONNULL CX_NODISCARD CX_INLINE
size_t cxJsonArrSize(const CxJsonValue *value) {
    return value->array.size;
}

CX_EXTERN CX_NONNULL CX_RETURNS_NONNULL CX_NODISCARD
CxJsonValue *cxJsonArrGet(const CxJsonValue *value, size_t index);

CX_EXTERN CX_NONNULL
CxJsonValue *cxJsonArrRemove(CxJsonValue *value, size_t index);

CX_EXTERN CX_NONNULL CX_NODISCARD
CxIterator cxJsonArrIter(const CxJsonValue *value);

CX_NONNULL CX_INLINE
size_t cxJsonObjSize(const CxJsonValue *value) {
    return cxCollectionSize(value->object);
}

CX_EXTERN CX_NONNULL CX_NODISCARD
CxMapIterator cxJsonObjIter(const CxJsonValue *value);

CX_EXTERN CX_NONNULL CX_RETURNS_NONNULL CX_NODISCARD
CxJsonValue *cx_json_obj_get(const CxJsonValue *value, cxstring name);

#define cxJsonObjGet(value, name) cx_json_obj_get(value, cx_strcast(name))

CX_EXTERN CX_NONNULL
CxJsonValue *cx_json_obj_remove(CxJsonValue *value, cxstring name);

#define cxJsonObjRemove(value, name) cx_json_obj_remove(value, cx_strcast(name))

CX_EXTERN CX_NODISCARD
int cxJsonCompare(const CxJsonValue *json, const CxJsonValue *other);
 

CX_EXTERN CX_NODISCARD
CxJsonValue* cxJsonClone(const CxJsonValue* value,
        const CxAllocator* allocator);

CX_EXTERN CX_NODISCARD
CxJsonValue* cx_json_clone_func(
        CxJsonValue* target, const CxJsonValue* source,
        const CxAllocator* allocator, void *data);

#define cxJsonCloneFunc  ((cx_clone_func) cx_json_clone_func)
 
#endif /* UCX_JSON_H */