478 lines
18 KiB
C++
478 lines
18 KiB
C++
#pragma once
|
|
#include <vector>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <map>
|
|
#include "base/define.h"
|
|
#include "base/conversion.h"
|
|
/* project version */
|
|
#define CJSON_VERSION_MAJOR 1
|
|
#define CJSON_VERSION_MINOR 7
|
|
#define CJSON_VERSION_PATCH 15
|
|
|
|
#include <stddef.h>
|
|
|
|
/* cJSON Types: */
|
|
#define cJSON_Invalid (0)
|
|
#define cJSON_False (1 << 0)
|
|
#define cJSON_True (1 << 1)
|
|
#define cJSON_NULL (1 << 2)
|
|
#define cJSON_Number (1 << 3)
|
|
#define cJSON_String (1 << 4)
|
|
#define cJSON_Array (1 << 5)
|
|
#define cJSON_Object (1 << 6)
|
|
#define cJSON_Raw (1 << 7) /* raw json */
|
|
|
|
#define cJSON_IsReference 256
|
|
#define cJSON_StringIsConst 512
|
|
|
|
/* The cJSON structure: */
|
|
typedef struct cJSON
|
|
{
|
|
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
|
|
struct cJSON* next;
|
|
struct cJSON* prev;
|
|
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
|
|
struct cJSON* child;
|
|
|
|
/* The type of the item, as above. */
|
|
int type;
|
|
|
|
/* The item's string, if type==cJSON_String and type == cJSON_Raw */
|
|
char* valuestring;
|
|
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
|
|
int valueint;
|
|
/* The item's number, if type==cJSON_Number */
|
|
double valuedouble;
|
|
|
|
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
|
|
char* string;
|
|
} cJSON;
|
|
|
|
typedef struct cJSON_Hooks
|
|
{
|
|
/* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
|
|
void* (*malloc_fn)(size_t sz);
|
|
void (*free_fn)(void* ptr);
|
|
} cJSON_Hooks;
|
|
|
|
typedef int cJSON_bool;
|
|
|
|
|
|
#define CJSON_NESTING_LIMIT 1000
|
|
|
|
/* Supply malloc, realloc and free functions to cJSON */
|
|
void cJSON_InitHooks(cJSON_Hooks* hooks);
|
|
|
|
/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
|
|
/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
|
|
cJSON* cJSON_Parse(const char* value);
|
|
cJSON* cJSON_ParseWithLength(const char* value, size_t buffer_length);
|
|
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
|
|
/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
|
|
cJSON* cJSON_ParseWithOpts(const char* value, const char** return_parse_end, cJSON_bool require_null_terminated);
|
|
cJSON* cJSON_ParseWithLengthOpts(const char* value, size_t buffer_length, const char** return_parse_end, cJSON_bool require_null_terminated);
|
|
|
|
/* Render a cJSON entity to text for transfer/storage. */
|
|
char* cJSON_Print(const cJSON* item);
|
|
/* Render a cJSON entity to text for transfer/storage without any formatting. */
|
|
char* cJSON_PrintUnformatted(const cJSON* item);
|
|
/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
|
|
char* cJSON_PrintBuffered(const cJSON* item, int prebuffer, cJSON_bool fmt);
|
|
/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
|
|
/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
|
|
cJSON_bool cJSON_PrintPreallocated(cJSON* item, char* buffer, const int length, const cJSON_bool format);
|
|
/* Delete a cJSON entity and all subentities. */
|
|
void cJSON_Delete(cJSON* item);
|
|
|
|
/* Returns the number of items in an array (or object). */
|
|
int cJSON_GetArraySize(const cJSON* array);
|
|
/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
|
|
cJSON* cJSON_GetArrayItem(const cJSON* array, int index);
|
|
/* Get item "string" from object. Case insensitive. */
|
|
cJSON* cJSON_GetObjectItem(const cJSON* const object, const char* const string);
|
|
cJSON* cJSON_GetObjectItemCaseSensitive(const cJSON* const object, const char* const string);
|
|
cJSON_bool cJSON_HasObjectItem(const cJSON* object, const char* string);
|
|
/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
|
|
const char* cJSON_GetErrorPtr(void);
|
|
|
|
/* Check item type and return its value */
|
|
char* cJSON_GetStringValue(const cJSON* const item);
|
|
double cJSON_GetNumberValue(const cJSON* const item);
|
|
|
|
/* These functions check the type of an item */
|
|
cJSON_bool cJSON_IsInvalid(const cJSON* const item);
|
|
cJSON_bool cJSON_IsFalse(const cJSON* const item);
|
|
cJSON_bool cJSON_IsTrue(const cJSON* const item);
|
|
cJSON_bool cJSON_IsBool(const cJSON* const item);
|
|
cJSON_bool cJSON_IsNull(const cJSON* const item);
|
|
cJSON_bool cJSON_IsNumber(const cJSON* const item);
|
|
cJSON_bool cJSON_IsString(const cJSON* const item);
|
|
cJSON_bool cJSON_IsArray(const cJSON* const item);
|
|
cJSON_bool cJSON_IsObject(const cJSON* const item);
|
|
cJSON_bool cJSON_IsRaw(const cJSON* const item);
|
|
|
|
/* These calls create a cJSON item of the appropriate type. */
|
|
cJSON* cJSON_CreateNull(void);
|
|
cJSON* cJSON_CreateTrue(void);
|
|
cJSON* cJSON_CreateFalse(void);
|
|
cJSON* cJSON_CreateBool(cJSON_bool boolean);
|
|
cJSON* cJSON_CreateNumber(double num);
|
|
cJSON* cJSON_CreateString(const char* string);
|
|
/* raw json */
|
|
cJSON* cJSON_CreateRaw(const char* raw);
|
|
cJSON* cJSON_CreateArray(void);
|
|
cJSON* cJSON_CreateObject(void);
|
|
|
|
/* Create a string where valuestring references a string so
|
|
* it will not be freed by cJSON_Delete */
|
|
cJSON* cJSON_CreateStringReference(const char* string);
|
|
/* Create an object/array that only references it's elements so
|
|
* they will not be freed by cJSON_Delete */
|
|
cJSON* cJSON_CreateObjectReference(const cJSON* child);
|
|
cJSON* cJSON_CreateArrayReference(const cJSON* child);
|
|
|
|
/* These utilities create an Array of count items.
|
|
* The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
|
|
cJSON* cJSON_CreateIntArray(const int* numbers, int count);
|
|
cJSON* cJSON_CreateFloatArray(const float* numbers, int count);
|
|
cJSON* cJSON_CreateDoubleArray(const double* numbers, int count);
|
|
cJSON* cJSON_CreateStringArray(const char* const* strings, int count);
|
|
|
|
/* Append item to the specified array/object. */
|
|
cJSON_bool cJSON_AddItemToArray(cJSON* array, cJSON* item);
|
|
cJSON_bool cJSON_AddItemToObject(cJSON* object, const char* string, cJSON* item);
|
|
/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
|
|
* WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
|
|
* writing to `item->string` */
|
|
cJSON_bool cJSON_AddItemToObjectCS(cJSON* object, const char* string, cJSON* item);
|
|
/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
|
|
cJSON_bool cJSON_AddItemReferenceToArray(cJSON* array, cJSON* item);
|
|
cJSON_bool cJSON_AddItemReferenceToObject(cJSON* object, const char* string, cJSON* item);
|
|
|
|
/* Remove/Detach items from Arrays/Objects. */
|
|
cJSON* cJSON_DetachItemViaPointer(cJSON* parent, cJSON* const item);
|
|
cJSON* cJSON_DetachItemFromArray(cJSON* array, int which);
|
|
void cJSON_DeleteItemFromArray(cJSON* array, int which);
|
|
cJSON* cJSON_DetachItemFromObject(cJSON* object, const char* string);
|
|
cJSON* cJSON_DetachItemFromObjectCaseSensitive(cJSON* object, const char* string);
|
|
void cJSON_DeleteItemFromObject(cJSON* object, const char* string);
|
|
void cJSON_DeleteItemFromObjectCaseSensitive(cJSON* object, const char* string);
|
|
|
|
/* Update array items. */
|
|
cJSON_bool cJSON_InsertItemInArray(cJSON* array, int which, cJSON* newitem); /* Shifts pre-existing items to the right. */
|
|
cJSON_bool cJSON_ReplaceItemViaPointer(cJSON* const parent, cJSON* const item, cJSON* replacement);
|
|
cJSON_bool cJSON_ReplaceItemInArray(cJSON* array, int which, cJSON* newitem);
|
|
cJSON_bool cJSON_ReplaceItemInObject(cJSON* object, const char* string, cJSON* newitem);
|
|
cJSON_bool cJSON_ReplaceItemInObjectCaseSensitive(cJSON* object, const char* string, cJSON* newitem);
|
|
|
|
/* Duplicate a cJSON item */
|
|
cJSON* cJSON_Duplicate(const cJSON* item, cJSON_bool recurse);
|
|
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
|
|
* need to be released. With recurse!=0, it will duplicate any children connected to the item.
|
|
* The item->next and ->prev pointers are always zero on return from Duplicate. */
|
|
/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
|
|
* case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
|
|
cJSON_bool cJSON_Compare(const cJSON* const a, const cJSON* const b, const cJSON_bool case_sensitive);
|
|
|
|
/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
|
|
* The input pointer json cannot point to a read-only address area, such as a string constant,
|
|
* but should point to a readable and writable address area. */
|
|
void cJSON_Minify(char* json);
|
|
|
|
/* Helper functions for creating and adding items to an object at the same time.
|
|
* They return the added item or NULL on failure. */
|
|
cJSON* cJSON_AddNullToObject_(cJSON* const object, const char* const name);
|
|
cJSON* cJSON_AddTrueToObject_(cJSON* const object, const char* const name);
|
|
cJSON* cJSON_AddFalseToObject_(cJSON* const object, const char* const name);
|
|
cJSON* cJSON_AddBoolToObject(cJSON* const object, const char* const name, const cJSON_bool boolean);
|
|
cJSON* cJSON_AddNumberToObject_(cJSON* const object, const char* const name, const double number);
|
|
cJSON* cJSON_AddStringToObject_(cJSON* const object, const char* const name, const char* const string);
|
|
cJSON* cJSON_AddRawToObject(cJSON* const object, const char* const name, const char* const raw);
|
|
cJSON* cJSON_AddObjectToObject(cJSON* const object, const char* const name);
|
|
cJSON* cJSON_AddArrayToObject(cJSON* const object, const char* const name);
|
|
|
|
#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
|
|
double cJSON_SetNumberHelper(cJSON* object, double number);
|
|
#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
|
|
char* cJSON_SetValuestring(cJSON* object, const char* valuestring);
|
|
#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
|
|
void* cJSON_malloc(size_t size);
|
|
void cJSON_free(void* object);
|
|
|
|
|
|
|
|
namespace ylib
|
|
{
|
|
class json
|
|
{
|
|
public:
|
|
enum type
|
|
{
|
|
null,
|
|
obj,
|
|
empty,
|
|
array,
|
|
boolean,
|
|
number,
|
|
string
|
|
};
|
|
public:
|
|
json();
|
|
json(const ylib::json& value);
|
|
json(cJSON* json,const std::string& name);
|
|
|
|
|
|
|
|
json(const std::vector<uint32>& value);
|
|
json(const std::vector<int32>& value);
|
|
json(const std::vector<uint64>& value);
|
|
json(const std::vector<int64>& value);
|
|
json(const std::vector<const char*>& value);
|
|
json(const std::vector<std::string>& value);
|
|
json(const std::vector<bool>& value);
|
|
json(const std::vector<double>& value);
|
|
json(const std::vector<float>& value);
|
|
json(const std::vector<ylib::json>& value);
|
|
|
|
//json(const std::initializer_list<ylib::json>& value);
|
|
//json(std::map<const char*, ylib::json> value);
|
|
|
|
json(const uint32& value);
|
|
json(const int32& value);
|
|
json(const uint64& value);
|
|
json(const int64& value);
|
|
json(const std::string& value);
|
|
json(const bool& value);
|
|
json(const double& value);
|
|
json(const float& value);
|
|
json(const char* value);
|
|
|
|
|
|
~json() ;
|
|
|
|
bool parse(const std::string& value);
|
|
void path(const std::string& path);
|
|
void safe(bool safe);
|
|
bool safe();
|
|
|
|
static ylib::json from(const std::string& value);
|
|
|
|
|
|
uint32 size() const;
|
|
void resize(uint32 size);
|
|
bool is_empty() const;
|
|
bool is_null() const;
|
|
bool is_obj() const;
|
|
bool is_array() const;
|
|
bool is_bool() const;
|
|
bool is_number() const;
|
|
bool is_string() const;
|
|
bool exist(const std::string& name) const;
|
|
|
|
void erase(const std::string& key);
|
|
void erase(uint32 index);
|
|
std::vector<std::string> keys() const;
|
|
|
|
const std::string& to_string(bool format = false) const;
|
|
ylib::json& operator[](const std::string name);
|
|
const ylib::json& operator[](const std::string name) const;
|
|
ylib::json& operator[](const size_t idx);
|
|
const ylib::json& operator[](const size_t idx) const;
|
|
|
|
//
|
|
void operator=(const std::vector<uint32>& value);
|
|
void operator=(const std::vector<int32>& value);
|
|
void operator=(const std::vector<uint64>& value);
|
|
void operator=(const std::vector<int64>& value);
|
|
void operator=(const std::vector<const char*>& value);
|
|
void operator=(const std::vector<std::string>& value);
|
|
void operator=(const std::vector<bool>& value);
|
|
void operator=(const std::vector<double>& value);
|
|
void operator=(const std::vector<float>& value);
|
|
void operator=(const std::vector<ylib::json>& value);
|
|
#ifndef MSVC_2010
|
|
void operator=(std::initializer_list<ylib::json> value);
|
|
#endif
|
|
void operator=(std::map<const char*, ylib::json> value);
|
|
|
|
|
|
|
|
void operator=(uint32 value);
|
|
void operator=(int32 value);
|
|
void operator=(uint64 value);
|
|
void operator=(int64 value);
|
|
void operator=(std::string value);
|
|
void operator=(const bool value);
|
|
void operator=(double value);
|
|
void operator=(float value);
|
|
void operator=(const char* value);
|
|
void operator=(ylib::json::type value);
|
|
void operator=(const ylib::json& value);
|
|
|
|
void push_back(uint32 value);
|
|
void push_back(int32 value);
|
|
void push_back(uint64 value);
|
|
void push_back(int64 value);
|
|
void push_back(std::string value);
|
|
void push_back(const bool value);
|
|
void push_back(double value);
|
|
void push_back(float value);
|
|
void push_back(const char* value);
|
|
void push_back(const ylib::json& value);
|
|
void clear();
|
|
|
|
|
|
template<typename T_TO>
|
|
T_TO to(bool check = false) const
|
|
{
|
|
if (check)
|
|
{
|
|
if (is_empty())
|
|
{
|
|
|
|
//trw_str("JSON is empty !!! Name:"+m_name);
|
|
}
|
|
}
|
|
#define RETURN_T(PARAM) return *((T_TO*)&PARAM)
|
|
#define CASE_T(TYPE) std::is_same<TYPE,T_TO>::value
|
|
if (CASE_T(std::vector<std::string>))
|
|
{
|
|
std::vector<std::string> result;
|
|
if (is_array() == false)
|
|
RETURN_T(result);
|
|
for (uint32 i = 0;i < size();i++)
|
|
result.push_back(this->operator[](i).to<std::string>());
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(std::vector<ylib::json>))
|
|
{
|
|
std::vector<ylib::json> result;
|
|
if (is_array() == false)
|
|
RETURN_T(result);
|
|
for (uint32 i = 0;i < size();i++)
|
|
result.push_back(this->operator[](i));
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(std::vector<int>) || CASE_T(std::vector<unsigned int>) || CASE_T(std::vector<long>))
|
|
{
|
|
std::vector<uint32> result;
|
|
if (is_array() == false)
|
|
RETURN_T(result);
|
|
for (uint32 i = 0;i < size();i++)
|
|
result.push_back(this->operator[](i).to<int>());
|
|
RETURN_T(result);
|
|
}
|
|
|
|
else if (CASE_T(std::vector<double>))
|
|
{
|
|
std::vector<double> result;
|
|
if (is_array() == false)
|
|
RETURN_T(result);
|
|
for (uint32 i = 0;i < size();i++)
|
|
result.push_back(this->operator[](i).to<double>());
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(std::vector<long long>) || CASE_T(std::vector<unsigned long long>))
|
|
{
|
|
std::vector<unsigned long long> result;
|
|
if (is_array() == false)
|
|
RETURN_T(result);
|
|
for (uint32 i = 0;i < size();i++)
|
|
result.push_back(this->operator[](i).to<unsigned long long>());
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(std::vector<float>))
|
|
{
|
|
std::vector<float> result;
|
|
if (is_array() == false)
|
|
RETURN_T(result);
|
|
for (uint32 i = 0;i < size();i++)
|
|
result.push_back(this->operator[](i).to<float>());
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(int) || CASE_T(unsigned int) || CASE_T(long))
|
|
{
|
|
static int result = 0;
|
|
if (m_number)
|
|
result = (int)this->m_value_double;
|
|
else
|
|
result = ylib::stoi(m_value_string);
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(short) || CASE_T(unsigned short))
|
|
{
|
|
static short result = 0;
|
|
if (m_number)
|
|
result = (short)this->m_value_double;
|
|
else
|
|
result = (short)ylib::stoi(m_value_string);
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(std::string))
|
|
{
|
|
RETURN_T(this->m_value_string);
|
|
}
|
|
else if (CASE_T(double))
|
|
{
|
|
RETURN_T(this->m_value_double);
|
|
}
|
|
else if (CASE_T(long long) || CASE_T(unsigned long long))
|
|
{
|
|
static uint64 result = 0;
|
|
|
|
if (m_number)
|
|
result = (int)this->m_value_double;
|
|
else
|
|
{
|
|
result = ylib::stoull(m_value_string);
|
|
}
|
|
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(float))
|
|
{
|
|
static float result = (float)this->m_value_double;
|
|
RETURN_T(result);
|
|
}
|
|
else if (CASE_T(bool))
|
|
{
|
|
RETURN_T(this->m_value_bool);
|
|
}
|
|
else
|
|
{
|
|
throw ylib::exception("not exception");
|
|
}
|
|
return T_TO();
|
|
}
|
|
|
|
private:
|
|
void init(cJSON* item);
|
|
void erase();
|
|
cJSON* arrangement() const;
|
|
bool is_newobj();
|
|
void clear_type();
|
|
bool __parse(const char* value,uint32 length);
|
|
private:
|
|
std::map<std::string, json*> m_objs;
|
|
std::vector<json*> m_arrs;
|
|
|
|
std::string m_name;
|
|
|
|
std::string m_value_string;
|
|
bool m_safe = false;
|
|
double m_value_double = 0.0f;
|
|
bool m_value_bool = false;
|
|
|
|
bool m_empty = false;
|
|
bool m_bool = false;
|
|
bool m_array = false;
|
|
bool m_obj = false;
|
|
bool m_string = false;
|
|
bool m_number = false;
|
|
bool m_null = false;
|
|
std::string m_jsonstring;
|
|
};
|
|
}
|