CJSON的封装API

为了更方便使用C的JSON库，对其进行了一层封装。

H文件：

#ifndef __JSONHELPER__
#define __JSONHELPER__

#ifdef __cplusplus
extern "C"
{
#endif


#define JSON_NAME_MAX_SIZE  128

enum
{
    JSON_OK = 0,
    JSON_ERROR,
    JSON_ERR_NO_SUCH_NODE,
    JSON_ERR_INVALID_NODE,
    JSON_ERR_NO_SUCH_ARRAY,
    JSON_ERR_INVALID_ARRAY_INDEX,
        JSON_ERR_UNMATCH_TYPE    
};

#define JSON_ERROR_STRING "Okay" 
    "Error" 
    "No Such Node" 
    "Invalid Node" 
    "No Such Array" 
    "Invalid Array Index" 
    "Unmatch Type" 


const char *jsonNodeType(void *json);
const char *jsonErrorString(int ret);

void *jsonParse(const char *text);
void jsonDelete(void *json);
void jsonDumpError(const char *text);
void jsonDump(void *json);

char *jsonToString(void *json, int format);
char *jsonToBuffer(void *json, int format, char *buffer, int len);

int jsonTestNumber(void *json);
int jsonTestString(void *json);
int jsonTestArray(void *json);
int jsonTestObject(void *json);
int jsonTestBool(void *json);

void *jsonGetNode(void *json, const char *node, int *ret);
int jsonGetString(void *json, const char *node, char *buf, int len);
int jsonGetInt(void *json, const char *node, int *value);
int jsonGetBool(void *json, const char *node, int *value);
int jsonGetUint64(void *json, const char *node, unsigned long long *value);
int jsonGetArraySize(void *json);
void *jsonGetArrayItem(void *json, int item);
int *jsonGetIntArray(void *json, const char *node, int *size);

int jsonMatchString(void *json, const char *node, char *value);
int jsonMatchInt(void *json, const char *node, int value);
int jsonMatchBool(void *json, const char *node, int value);
int jsonMatchUint64(void *json, const char *node, unsigned long long value);

int jsonSetString(void *json, const char *node, const char *str);
int jsonSetInt(void *json, const char *node, int value);
int jsonSetBool(void *json, const char *node, int value);
int jsonSetUint64(void *json, const char *node, unsigned long long value);

void *jsonDuplicate(void *json, int withChild);

#define jsonNewRoot() jsonNewOject(NULL, NULL)
void *jsonNewOject(void *json, const char *name);
void *jsonNewArray(void *json, const char *name);
void *jsonArrayAddItem(void *array);

void *jsonAttach(void *json, const char *name, void *obj);

void *jsonAddBool(void *json, const char *name, int b);
void *jsonAddInt(void *json, const char *name, int v);
void *jsonAddDouble(void *json, const char *name, double v);
void *jsonAddUint64(void *json, const char *name, unsigned long long v);
void *jsonAddString(void *json, const char *name, const char *str);
void *jsonAddIntArray(void *json, const char *name, const int *numbers,int count);
void *jsonAddStringArray(void *json, const char *name, const char **str, int count);

#ifdef __cplusplus
}
#endif

#endif /* __JSONHELPER__ */

C文件：

/*
 @File: jsonHelper.c
 @Description: json helper functions
 @Date: 2018-04-27
 @Author: Liu Chuansen (179712066@qq.com)
 
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "jsonHelper.h"
#include "cJSON.h"

static const char *cJsonType(int type)
{
    const char *p = "FalseTrueNULLNumberStringArrayObject";
    int i = 0;

    if (type == 0)
    {
        return p;
    }
    
    while(*p)
    {
        p ++;
        if (*p == '')
        {
            i ++;
            p ++;
            if (*p && (i == type))
            {
                return p;
            }
        }
    }

    return "[Unknown]";
}

const char *jsonNodeType(void *json)
{
    return cJsonType(((cJSON *)json)->type);
}

const char *jsonErrorString(int ret)
{
    const char *p = JSON_ERROR_STRING;
    int i = 0;

    if (ret == 0)
    {
        return p;
    }
    
    while(*p)
    {
        p ++;
        if (*p == '')
        {
            i ++;
            p ++;
            if (*p && (i == ret))
            {
                return p;
            }
        }
    }

    return "[Unknown]";
}


void *jsonParse(const char *text)
{
    return cJSON_Parse(text);
}

void jsonDelete(void *json)
{
    return cJSON_Delete(json);
}

/* 
        @input: text, origin text pass to jsonParse
        @desc: only call this function when jsonParse() failed
*/
void jsonDumpError(const char *text)
{
        static char buffer[128];
        int len = strlen(text);
        const char *p = cJSON_GetErrorPtr();

    printf("------------json error dump------------
"); 
    
        if (p && (p < text + len))
        {
                const char *pre = text;
                int preLen = 16;
                int offset = 0;

                if ((p - text) > 16)
                {
                        pre = p - 16;
                }
                else {
                        preLen = p - text;
                }

                if (preLen > 0)
                {
                        strncpy(buffer, pre, preLen);
                        strcpy(buffer + preLen, "\_/");
                        offset = preLen + 3;
                }

                strncpy(buffer + offset, p, sizeof(buffer) - offset - 1);
                buffer[sizeof(buffer) - 1] = 0;

        printf("%s
", buffer);        
        }
    else 
    {
        printf("***Unable to find error text
");
    }

    printf("=======================================
");    
}


void jsonDump(void *json)
{
    printf("---------------json dump---------------
");

    char *d = cJSON_Print(json);
    printf("%s
", d ? d : "(null)");    
    printf("=======================================
");

    if (d)
    {
        free(d);
    }
}

char *jsonToString(void *json, int format)
{
    return format ? cJSON_Print(json) : cJSON_PrintUnformatted(json);
}

char *jsonToBuffer(void *json, int format, char *buffer, int len)
{
    if (!buffer || !len)
    {
        return "Buffer is not valid";
    }

    return cJSON_PrintToBuffer(json, buffer, len, format);    
}


int jsonTestNumber(void *json)
{
    if (json == NULL) return 0;
    return (((cJSON *)json)->type == cJSON_Number) ? 1 : 0;    
}

int jsonTestString(void *json)
{
    if (json == NULL) return 0;
    return (((cJSON *)json)->type == cJSON_String) ? 1 : 0;      
}

int jsonTestArray(void *json)
{
    if (json == NULL) return 0;
    return (((cJSON *)json)->type == cJSON_Array) ? 1 : 0;    
}

int jsonTestObject(void *json)
{
    if (json == NULL) return 0;
    return (((cJSON *)json)->type == cJSON_Object) ? 1 : 0;      
}

int jsonTestBool(void *json)
{
    cJSON *j = json;
    if (j == NULL) return 0;

    if ((j->type == cJSON_False) || (j->type == cJSON_True)) 
    {
        return 1;
    }

    if ((j->type == cJSON_Number) && ((j->valueint == 0) || (j->valueint == 1))) 
    {
        return 1;
    }
    
   return 0;      
}

/* 
    @function: jsonGetNode
    ---
        @json: json parent node
        @node: node path, such as "sys.info[0].root"
        @ret: return status
        ---
        @return the node handle of destination node
*/

void *jsonGetNode(void *json, const char *node, int *ret)
{
    cJSON *s;
    const char *subItem = NULL;
    const char *p;
    char *pe;
    char item[JSON_NAME_MAX_SIZE + 1];    
    int len, index = -1;

    if ((node == NULL) || (*node == ''))
    {
        *ret = JSON_ERR_INVALID_NODE;
        return NULL;
    }

    /* split first node name */
    p = strchr(node, '.');

    if (p)
    {
        len = p - node;
        subItem = p + 1;         
    }
    else 
    {
        len = strlen(node);
    }
    
    if (!len || (len > sizeof(item) - 1))
    {
        *ret = JSON_ERR_INVALID_NODE;
        return NULL;
    }
    
    strncpy(item, node, len);
    item[len] = '';        
 
    /* get array if it is */
    pe = strchr(item, '[');
    if (pe)
    {        
        *pe = ''; 
        index = strtoul(pe + 1, NULL, 10);
    }

    s = cJSON_GetObjectItem(json, item);
    
    if (s && (index >= 0))
    {

        if (s->type != cJSON_Array)
        {
            *ret = JSON_ERR_NO_SUCH_ARRAY;
            return NULL;
        }
    
        if (index >= cJSON_GetArraySize(s))
        {
            *ret = JSON_ERR_INVALID_ARRAY_INDEX;
            return NULL;
        }
    
        s = cJSON_GetArrayItem(s, index);
    }

    if (s == NULL)
    {
        *ret = JSON_ERR_NO_SUCH_NODE;
        return NULL;
    }
    
    if (subItem)
    {
        return jsonGetNode(s, subItem, ret);
    }
    else 
    {
        *ret = JSON_OK;
        return s;
    }
}

int jsonGetString(void *json, const char *node, char *buf, int len)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestString(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    if (buf && len)
    {
        strncpy(buf, d->valuestring, len - 1);
        buf[len - 1] = '';
    }

    return JSON_OK;
}

int jsonGetInt(void *json, const char *node, int *value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestNumber(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    if (value)
    {
                *value = d->valueint;
    }

    return JSON_OK;
}

int jsonGetBool(void *json, const char *node, int *value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestBool(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    if (value)
    {
        if (d->type == cJSON_True)
        {
            *value = 1;
        }
        else if (d->type == cJSON_Number)
        {
            *value = d->valueint ? 1 : 0;
        }
        else
        {
            *value = 0;
        }
    }

    return JSON_OK;
}


int jsonGetUint64(void *json, const char *node, unsigned long long *value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestNumber(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    if (value)
    {
                *value = d->valueuint64;
    }

    return JSON_OK;
}

/* need to free */
int *jsonGetIntArray(void *json, const char *node, int *size)
{
    int ret = JSON_OK;
    int num;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;
    int *intArray = NULL;
    int i;

    if (ret != JSON_OK) return ret;

    if (!jsonTestArray(d))
    {
        return NULL;
    }    

    num = cJSON_GetArraySize(d);

    if (num > 0)
    {        
        intArray = malloc(sizeof(num) * sizeof(int));

        for (i = 0; i < num; i ++)
        {
            cJSON *s = cJSON_GetArrayItem(d, i);
            if (s->type != cJSON_Number)
            {
                free(intArray);
                return NULL;
            }
            intArray[i] = s->valueint;
        }
    }

    if (size)
    {
        *size = num;
    }

    return intArray;
}




int jsonGetArraySize(void *json)
{
    if (!jsonTestArray(json))
    {
        return 0;
    }

    return cJSON_GetArraySize(json);
}

void *jsonGetArrayItem(void *json, int item)
{
    if (!jsonTestArray(json))
    {
        return NULL;
    }

    return cJSON_GetArrayItem(json, item);
}

int jsonMatchString(void *json, const char *node, char *value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return 0;

    if (!jsonTestString(d))
    {
        return 0;
    }

    if (value)
    {
        return !strcmp(value, d->valuestring) ? 1 : 0;
    }

    return 0;
}

int jsonMatchInt(void *json, const char *node, int value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return 0;

    if (!jsonTestNumber(d))
    {
        return 0;
    }

    return (value == d->valueint) ? 1 : 0;
}

int jsonMatchBool(void *json, const char *node, int value)
{
    int ret = JSON_OK, bv;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return 0;

    if (!jsonTestBool(d))
    {
        return 0;
    }

    if (d->type == cJSON_True)
    {
        bv = 1;
    }
    else if (d->type == cJSON_Number)
    {
        bv = d->valueint ? 1 : 0;
    }
    else
    {
        bv = 0;
    }

    if (value > 1)
    {
        value = 1;
    }

    return (bv == value) ? 1 : 0;
}


int jsonMatchUint64(void *json, const char *node, unsigned long long value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return 0;

    if (!jsonTestNumber(d))
    {
        return 0;
    }

    return (value == d->valueuint64) ? 1 : 0;
}

/* it is not safe function */
int jsonSetString(void *json, const char *node, const char *str)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestString(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    if (str && str[0])
    {
        if (!(d->type & cJSON_IsReference) && d->valuestring)
        {
            free(d->valuestring);
        }

        d->valuestring = strdup(str);
    }

    return JSON_OK;
}

int jsonSetInt(void *json, const char *node, int value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestNumber(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    d->valueint = value;
    d->valuedouble = (double)value;
    d->valueuint64 = 0;

    return JSON_OK;
}

int jsonSetBool(void *json, const char *node, int value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestBool(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }

    if ((d->type == cJSON_True) || (d->type == cJSON_False))
    {
        d->type = value ? cJSON_True : cJSON_False;
    }
    else if (d->type == cJSON_Number)
    {
        d->valueint = value ? 1 : 0;
        d->valuedouble = (double)d->valueint;
        d->valueuint64 = 0;
    }

    return JSON_OK;
}


int jsonSetUint64(void *json, const char *node, unsigned long long value)
{
    int ret = JSON_OK;
    cJSON *d = node ? jsonGetNode(json, node, &ret) : json;

    if (ret != JSON_OK) return ret;

    if (!jsonTestNumber(d))
    {
        return JSON_ERR_UNMATCH_TYPE;
    }
    
    d->valueuint64 = value;

    return JSON_OK;
}

void *jsonDuplicate(void *json, int withChild)
{
    return cJSON_Duplicate(json, withChild);
}

void *jsonNewOject(void *json, const char *name)
{
        cJSON *j = cJSON_CreateObject();
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }
        return j;
}

void *jsonNewArray(void *json, const char *name)
{
        cJSON *j = cJSON_CreateArray();
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }
        return j;
}

void *jsonArrayAddItem(void *array)
{
        cJSON *j = cJSON_CreateObject();
        if (array)
        {
                cJSON_AddItemToArray(array, j);
        }
        return j;
}

void *jsonAttach(void *json, const char *name, void *obj)
{
    cJSON_AddItemToObject(json, name, obj);

        return obj;
}


void *jsonAddBool(void *json, const char *name, int b)
{
        cJSON *j = cJSON_CreateBool(b);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}

void *jsonAddInt(void *json, const char *name, int v)
{
        cJSON *j = cJSON_CreateNumber(v);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}

void *jsonAddDouble(void *json, const char *name, double v)
{
        cJSON *j = cJSON_CreateNumber(v);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}


void *jsonAddUint64(void *json, const char *name, unsigned long long v)
{
        cJSON *j = cJSON_CreateUint64(v);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}

void *jsonAddString(void *json, const char *name, const char *str)
{
        cJSON *j = cJSON_CreateString(str);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}

void *jsonAddIntArray(void *json, const char *name, const int *numbers,int count)
{
        cJSON *j = cJSON_CreateIntArray(numbers, count);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}

void *jsonAddStringArray(void *json, const char *name, const char **str, int count)
{
        cJSON *j = cJSON_CreateStringArray(str, count);
        if (json && name)
        {
                cJSON_AddItemToObject(json, name, j);
        }

        return j;
}

后续将提供使用示例。