#include <json.hpp>

类 acl::json 继承关系图:

acl::json 的协作图:

Public 成员函数
	json (const char data=NULL, dbuf_guard dbuf=NULL)

	json (const json_node &node, dbuf_guard *dbuf=NULL)

	~json (void)

json &	part_word (bool on)

const char *	update (const char *data)

bool	finish (void)

void	reset (void)

json_node *	getFirstElementByTagName (const char *tag) const

json_node *	operator[] (const char *tag) const

const std::vector< json_node * > &	getElementsByTagName (const char *tag) const

const std::vector< json_node * > &	getElementsByTags (const char *tags) const

json_node *	getFirstElementByTags (const char *tags) const

ACL_JSON *	get_json (void) const

json_node &	create_node (const char tag, const char value)

json_node &	create_node (const char *tag, long long int value)

json_node &	create_double (const char *tag, double value)

json_node &	create_node (const char *tag, bool value)

json_node &	create_null (const char *tag)

json_node &	create_array_text (const char *text)

json_node &	create_array_number (long long int value)

json_node &	create_array_double (double value)

json_node &	create_array_bool (bool value)

json_node &	create_array_null (void)

json_node &	create_node (bool as_array=false)

json_node &	create_array (void)

json_node &	create_node (const char tag, json_node node)

json_node &	create_node (const char *tag, json_node &node)

json_node &	duplicate_node (const json_node *node)

json_node &	duplicate_node (const json_node &node)

json_node &	get_root (void)

json_node *	first_node (void)

json_node *	next_node (void)

void	build_json (string &out, bool add_space=false) const

const string &	to_string (string *out=NULL, bool add_space=false) const

dbuf_guard *	get_dbuf (void) const

virtual int	push_pop (const char in, size_t len, string out, size_t max=0)

virtual int	pop_end (string *out, size_t max=0)

virtual void	clear (void)

Public 成员函数继承自 acl::pipe_stream
	pipe_stream ()

virtual	~pipe_stream ()

Public 成员函数继承自 acl::dbuf_obj
	dbuf_obj (dbuf_guard *guard=NULL)

virtual	~dbuf_obj ()

int	pos () const

dbuf_guard *	get_guard () const

额外继承的成员函数
Protected 成员函数继承自 acl::acl::noncopyable
	noncopyable ()

	~noncopyable ()

详细描述

在文件 json.hpp 第 427 行定义.

构造及析构函数说明

◆ json() [1/2]

acl::json::json	(	const char *	data = `NULL`,
		dbuf_guard *	dbuf = `NULL`
	)

构造函数，可用于解析 json 字符串或生成 json 对象

参数

data	{const char*} json 格式的字符串，可以是完整的 json 字符串，也可以是部分的 json 字符串，也可以是空指针，无论如何，用户依然可以用部分或完整的 json 字符串调用 update 函数，在调用 update 过程中解析 json；其实，当构造函数的的 data 参数非空时，它也会调用 update
dbuf	{dbuf_guard*} 非空时将做为内存池管理对象，否则内部会自动创建一个内存池管理对象

◆ json() [2/2]

acl::json::json	(	const json_node &	node,
		dbuf_guard *	dbuf = `NULL`
	)

根据一个 json 对象中的一个 json 节点构造一个新的 json 对象

参数

node	{const json_node&} 源 json 对象中的一个 json 节点
dbuf	{dbuf_guard*} 非空时将做为内存池管理对象，否则内部会自动创建一个内存池管理对象

◆ ~json()

acl::json::~json ( void )

成员函数说明

◆ build_json()

void acl::json::build_json	(	string &	out,
		bool	add_space = `false`
	)		const

将 json 对象树转成字符串

参数

out	{string&} 存储转换结果的缓冲区
add_space	{bool} 创建 json 时是否自动在分隔符两边添加空格

◆ clear()

virtual void acl::json::clear ( void )

virtual

重载 acl::pipe_stream .

◆ create_array()

json_node& acl::json::create_array ( void )

◆ create_array_bool()

json_node& acl::json::create_array_bool ( bool value )

创建一个 json_node 叶节点布尔对象按 json 规范，该节点只能加入至数组对象中

参数

value {bool} 布尔值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_array_double()

json_node& acl::json::create_array_double ( double value )

创建一个 json_node 叶节点数值对象按 json 规范，该节点只能加入至数组对象中

参数

value {double} 值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_array_null()

json_node& acl::json::create_array_null ( void )

创建一个 json_node 叶节点 null 对象按 json 规范，该节点只能加入至数组对象中

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_array_number()

json_node& acl::json::create_array_number ( long long int value )

创建一个 json_node 叶节点数值对象按 json 规范，该节点只能加入至数组对象中

参数

value {acl_int64} 数值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_array_text()

json_node& acl::json::create_array_text ( const char * text )

创建一个 json_node 叶节点字符串对象，该节点对象的格式为："string" 按 json 规范，该节点只能加入至数组对象中

参数

text	{const char*} 文本字符串

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_double()

json_node& acl::json::create_double	(	const char *	tag,
		double	value
	)

创建一个 json_node 叶节点对象，该节点对象的格式为： "tag_name": tag_value

参数

tag	{const char*} 标签名
value	{double} 标签值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_node() [1/6]

json_node& acl::json::create_node	(	const char *	tag,
		const char *	value
	)

创建一个 json_node 叶节点对象，该节点对象的格式为： "tag_name": "tag_value"

参数

tag	{const char*} 标签名
value	{const char*} 标签值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_node() [2/6]

json_node& acl::json::create_node	(	const char *	tag,
		long long int	value
	)

创建一个 json_node 叶节点对象，该节点对象的格式为： "tag_name": tag_value

参数

tag	{const char*} 标签名
value	{int64} 标签值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_node() [3/6]

json_node& acl::json::create_node	(	const char *	tag,
		bool	value
	)

创建一个 json_node 叶节点对象，该节点对象的格式为： "tag_name": true|false

参数

tag	{const char*} 标签名
value	{bool} 标签值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_node() [4/6]

json_node& acl::json::create_node ( bool as_array = false )

创建一个 json_node 节点容器对象，该对象没有标签, 该节点对象的格式为："{}" 或数组对象 "[]"

参数

as_array {bool} 是否数组对象

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_node() [5/6]

json_node& acl::json::create_node	(	const char *	tag,
		json_node *	node
	)

创建一个 json_node 节点对象，该节点对象的格式为：tag_name: {} 或 tag_name: []

参数

tag	{const char*} 标签名
node	{json_node*} json 节点对象作为标签值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_node() [6/6]

json_node& acl::json::create_node	(	const char *	tag,
		json_node &	node
	)

创建一个 json_node 节点对象，该节点对象的格式为：tag_name: {} 或 tag_name: []

参数

tag	{const char*} 标签名
node	{json_node&} json 节点对象作为标签值

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ create_null()

json_node& acl::json::create_null ( const char * tag )

创建一个 json_node null 叶节点对象，该节点对象的格式为： "tag_name": null

参数

tag	{const char*} 标签名

返回: {json_node&} 新产生的 json_node 对象不需要用户手工释放，因为在 json 对象被释放时这些节点会自动被释放，当然用户也可以在不用时调用 reset 来释放这些 json_node 节点对象

◆ duplicate_node() [1/2]

json_node& acl::json::duplicate_node ( const json_node * node )

将一个 json 对象中的一个 json 节点复制至任一 json 对象中的一个新 json 节点中并返回该新的 json 节点

参数

node	{json_node*} 源 json 对象的一个 json 节点

返回: {json_node&} 当前目标 json 对象中新创建的 json 节点

◆ duplicate_node() [2/2]

json_node& acl::json::duplicate_node ( const json_node & node )

将一个 json 对象中的一个 json 节点复制至任一 json 对象中的一个新 json 节点中并返回该新的 json 节点

参数

node	{json_node&} 源 json 对象的一个 json 节点

返回: {json_node&} 当前目标 json 对象中新创建的 json 节点

◆ finish()

bool acl::json::finish ( void )

判断是否解析完毕

返回: {bool}

被这些函数引用 acl::deserialize().

这是这个函数的调用关系图:

◆ first_node()

json_node* acl::json::first_node ( void )

开始遍历该 json 对象并获得第一个节点

返回: {json_node*} 返回空表示该 json 对象为空节点注：返回的节点对象用户不能手工释放，因为该对象被内部库自动释放

◆ get_dbuf()

dbuf_guard* acl::json::get_dbuf ( void ) const

inline

获得内存池对象指针

返回: {dbuf_guard*}

在文件 json.hpp 第 763 行定义.

                                          {
                 return dbuf_;
         }

◆ get_json()

ACL_JSON* acl::json::get_json ( void ) const

取得 acl 库中的 ACL_JSON 对象

返回: {ACL_JSON*} 该值不可能为空，注意用户可以修改该对象的值，但不可以释放该对象

◆ get_root()

json_node& acl::json::get_root ( void )

获得根节点对象

返回: {json_node&}

被这些函数引用 acl::deserialize().

这是这个函数的调用关系图:

◆ getElementsByTagName()

const std::vector<json_node*>& acl::json::getElementsByTagName ( const char * tag ) const

从 json 对象中取得某个标签名的所有节点集合

参数

tag	{const char*} 标签名(不区分大小写)

返回: {const std::vector<json_node*>&} 返回结果集的对象引用，如果查询结果为空，则该集合为空，即：empty() == true 注：返回的 json_node 节点可以修改，但不能删除节点，内部有自动删除机制，当调用方法 clear/getElementsByTagName/getElementsByTags 后，节点不能再被引用，因为节点的内存被自动释放

◆ getElementsByTags()

const std::vector<json_node*>& acl::json::getElementsByTags ( const char * tags ) const

从 json 对象中获得所有的与给定多级标签名相同的 json 节点的集合

参数

tags	{const char*} 多级标签名，由 '/' 分隔各级标签名，如针对 json 数据： { 'root': [ 'first': { 'second': { 'third': 'test1' } }, 'first': { 'second': { 'third': 'test2' } }, 'first': { 'second': { 'third': 'test3' } } ] } 可以通过多级标签名：root/first/second/third 一次性查出所有符合条件的节点

返回: {const std::vector<json_node*>&} 符合条件的 json 节点集合, 如果查询结果为空，则该集合为空，即：empty() == true 注：返回的 json_node 节点可以修改，但不能删除节点，内部有自动删除机制，当调用方法 clear/getElementsByTagName/getElementsByTags 后，节点不能再被引用，因为节点的内存被自动释放

◆ getFirstElementByTagName()

json_node* acl::json::getFirstElementByTagName ( const char * tag ) const

从 json 对象中取得某个标签名的第一个节点

参数

tag	{const char*} 标签名(不区分大小写)

返回: {json_node*} 返回 json 节点对象，不存在则返回 NULL 注：返回的 json_node 节点可以修改，但不能删除节点，内部有自动删除机制，当调用方法 clear/getElementsByTagName/getElementsByTags 后，节点不能再被引用，因为节点的内存被自动释放

◆ getFirstElementByTags()

json_node* acl::json::getFirstElementByTags ( const char * tags ) const

从 json 对象中获得所有的与给定多级标签名相同的 json 节点的集合

参数

tags	{const char*} 多级标签名，由 '/' 分隔各级标签名，如针对 json 数据： { 'root': [ 'first': { 'second': { 'third': 'test1' } }, 'first': { 'second': { 'third': 'test2' } }, 'first': { 'second': { 'third': 'test3' } } ] } 可以通过多级标签名：root/first/second/third 一次性查出所有符合条件的节点

返回: {json_node*} 返回 NULL 表示不存在

◆ next_node()

json_node* acl::json::next_node ( void )

遍历该 json 对象的下一个 json 节点

返回: {json_node*} 返回空表示遍历完毕注：返回的节点对象用户不能手工释放，因为该对象被内部库自动释放

◆ operator[]()

json_node* acl::json::operator[] ( const char * tag ) const

重载运算符，直接获得对应标签名的第一个节点

参数

tag	{const char*} 标签名(不区分大小写)

返回: {json_node*} 返回 json 节点对象，不存在则返回 NULL 注：返回的 json_node 节点可以修改，但不能删除节点，内部有自动删除机制，当调用方法 clear/getElementsByTagName/getElementsByTags 后，节点不能再被引用，因为节点的内存被自动释放

◆ part_word()

json& acl::json::part_word ( bool on )

设置是否在解析时自动处理半个汉字的情形

参数

on {bool}

返回: {json&}

◆ pop_end()

virtual int acl::json::pop_end	(	string *	out,
		size_t	max = `0`
	)

virtual

实现了 acl::pipe_stream.

◆ push_pop()

virtual int acl::json::push_pop	(	const char *	in,
		size_t	len,
		string *	out,
		size_t	max = `0`
	)

virtual

实现了 acl::pipe_stream.

◆ reset()

void acl::json::reset ( void )

重置 json 解析器状态，该 json 对象可以用来对多个 json 数据进行解析，在反复使用本 json 解析器前，需要调用本函数重置内部 json 解析器状态，清除上一次的解析结果

◆ to_string()

const string& acl::json::to_string	(	string *	out = `NULL`,
		bool	add_space = `false`
	)		const

将 json 对象树转换成 json 字符串

参数

out	{string*} 非空时，则使用此缓冲区，否则使用内部缓冲区
add_space	{bool} 创建 json 时是否自动在分隔符两边添加空格

返回: {const string&}

被这些函数引用 acl::deserialize().

这是这个函数的调用关系图:

◆ update()

const char* acl::json::update ( const char * data )

以流式方式循环调用本函数添加 json 数据，也可以一次性添加完整的 json 数据，如果是重复使用该 json 解析器解析多个 json 对象，则应该在解析下一个 json 对象前调用 reset() 方法来清除上一次的解析结果

参数

data	{const char*} json 数据

返回: {const char*} 当解析结束后，该返回值表示剩余数据的指针地址

该类的文档由以下文件生成:

include/acl_cpp/stdlib/json.hpp

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ json() [1/2]

◆ json() [2/2]

◆ ~json()

成员函数说明

◆ build_json()

◆ clear()

◆ create_array()

◆ create_array_bool()

◆ create_array_double()

◆ create_array_null()

◆ create_array_number()

◆ create_array_text()

◆ create_double()

◆ create_node() [1/6]

◆ create_node() [2/6]

◆ create_node() [3/6]

◆ create_node() [4/6]

◆ create_node() [5/6]

◆ create_node() [6/6]

◆ create_null()

◆ duplicate_node() [1/2]

◆ duplicate_node() [2/2]

◆ finish()

◆ first_node()

◆ get_dbuf()

◆ get_json()

◆ get_root()

◆ getElementsByTagName()

◆ getElementsByTags()

◆ getFirstElementByTagName()

◆ getFirstElementByTags()

◆ next_node()

◆ operator[]()

◆ part_word()

◆ pop_end()

◆ push_pop()

◆ reset()

◆ to_string()

◆ update()