LuChiChick/DLT_Splitter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented the basic elements of JSON files, including Json_Pair, Json_Arry, Json_Object, and Json_Value. Additionally, some syntactic sugar has been implemented for ease of use, allowing for rapid construction of JSON elements using {} initialization.

Browse Source
This commit is contained in:
LuChiChick 2026-04-10 14:11:41 +08:00
parent 4da02ddb60
commit 057438652a
2 changed files with 461 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
Inc/Json_Utilities.hpp Normal file
View File

@ -0,0 +1,156 @@
#ifndef __JSON_UTILITIES_HPP__
#define __JSON_UTILITIES_HPP__
extern "C"
{
#include "stdio.h"
#include "stdlib.h"
#include "stdint.h"
}
#include "vector"
#include "string"
class Json_Pair; // Json 键值对
class Json_Arry; // Json 数组 元素必须是值
class Json_Object; // Json 对象 对象内必须是键值对序列
class Json_Value; // Json 值（可以是数组、对象、字符串、浮点数值和整数值、逻辑值、NULL）
// Json 数组
class Json_Arry
{
private:
// 元素列表
std::vector<Json_Value> private_element_list;
public:
// 默认构造
Json_Arry() = default;
// 列表构造
Json_Arry(std::initializer_list<Json_Value> init_list) : private_element_list(init_list) {};
Json_Arry(std::vector<Json_Value> init_list) : private_element_list(init_list) {};
// 深拷贝
Json_Arry &operator=(const Json_Arry &another);
// 获取元素大小
size_t size(void);
// 数组索引重载
Json_Value operator[](size_t index);
// 是否为空
bool isNull(void);
};
// Json 值定义
class Json_Value
{
public:
// 类型枚举
typedef enum
{
TYPE_NULL, // 空值
TYPE_STR, // 字符串
TYPE_ARRY, // 数组
TYPE_OBJ, // 对象
TYPE_NUM_INTEGER, // 整数常数
TYPE_NUM_FLOAT, // 浮点常数
TYPE_BOOLEAN, // 布尔逻辑值
} Type;
protected:
Type private_type = TYPE_NULL; // 类型枚举
void *p_mem = nullptr; // 数据内存
public:
// 只读引用
const Type &type = this->private_type;
// 默认构造
Json_Value() = default;
// 值构造
Json_Value(std::string str);
Json_Value(const char *str) : Json_Value(std::string(str)) {};
Json_Value(Json_Arry arry);
Json_Value(std::initializer_list<Json_Value> init_list) : Json_Value(Json_Arry(init_list)) {};
Json_Value(Json_Object object);
Json_Value(int64_t num_integer);
Json_Value(int num_integer) : Json_Value((int64_t)num_integer) {};
Json_Value(double num_float);
Json_Value(bool boolean);
// 浅拷贝构造
Json_Value(const Json_Value &temp);
// 深拷贝
Json_Value &operator=(const Json_Value &another);
// 析构函数
~Json_Value();
// 获取值
std::string asString(void);
Json_Arry asArry(void);
Json_Object asObject(void);
int64_t asInteger(void);
double asFloat(void);
bool asBoolean(void);
// 是否为空
bool isNull(void);
};
// Json 键值对定义
class Json_Pair
{
private:
bool Null_Flag = true; // 空判定
std::string private_key_str; // 键
Json_Value private_value; // 值
public:
// 只读引用
std::string &key = this->private_key_str;
Json_Value &value = this->private_value;
// 默认构造
Json_Pair() : Null_Flag(true) {};
// 必要构造
Json_Pair(std::string key, Json_Value value) : Null_Flag(false), private_key_str(key), private_value(value) {};
// 浅拷贝构造
Json_Pair(const Json_Pair &temp);
// 深拷贝
Json_Pair &operator=(const Json_Pair &another);
// 空判定
bool isNull();
};
// Json 对象
class Json_Object
{
private:
// 元素列表
std::vector<Json_Pair> private_element_list;
public:
// 默认构造
Json_Object() = default;
// 列表构造
Json_Object(std::initializer_list<Json_Pair> init_list) : private_element_list(init_list) {};
Json_Object(std::vector<Json_Pair> init_list) : private_element_list(init_list) {};
// 深拷贝
Json_Object &operator=(const Json_Object &another);
// 获取元素大小
size_t size(void);
// 数组索引重载
Json_Pair operator[](size_t index);
// 由Key 查找值
Json_Value get(std::string key);
// 是否为空
bool isNull(void);
};
#endif

305
Src/Json_Utilities.cpp Normal file
View File

@ -0,0 +1,305 @@
#include "Json_Utilities.hpp"
// std::string 构造
Json_Value::Json_Value(std::string str) : private_type(TYPE_STR), p_mem(malloc(sizeof(str)))
{
if (p_mem != nullptr)
new (p_mem) std::string(str);
else
this->private_type = TYPE_NULL;
}
// Json_Arry 构造
Json_Value::Json_Value(Json_Arry arry) : private_type(TYPE_ARRY), p_mem(malloc(sizeof(arry)))
{
if (p_mem != nullptr)
new (p_mem) Json_Arry(arry);
else
this->private_type = TYPE_NULL;
}
// Json_Object 构造
Json_Value::Json_Value(Json_Object object) : private_type(TYPE_OBJ), p_mem(malloc(sizeof(object)))
{
if (p_mem != nullptr)
new (p_mem) Json_Object(object);
else
this->private_type = TYPE_NULL;
}
// 整数值 构造
Json_Value::Json_Value(int64_t num_integer) : private_type(TYPE_NUM_INTEGER), p_mem(malloc(sizeof(num_integer)))
{
if (p_mem != nullptr)
*(decltype(num_integer) *)p_mem = num_integer;
else
this->private_type = TYPE_NULL;
}
// 浮点值 构造
Json_Value::Json_Value(double num_float) : private_type(TYPE_NUM_FLOAT), p_mem(malloc(sizeof(num_float)))
{
if (p_mem != nullptr)
*(decltype(num_float) *)p_mem = num_float;
else
this->private_type = TYPE_NULL;
}
// Boolean 逻辑值构造
Json_Value::Json_Value(bool boolean) : private_type(TYPE_BOOLEAN), p_mem(malloc(sizeof(boolean)))
{
if (p_mem != nullptr)
*(decltype(boolean) *)p_mem = boolean;
else
this->private_type = TYPE_NULL;
}
// 浅拷贝构造
Json_Value::Json_Value(const Json_Value &temp) : private_type(TYPE_NULL), p_mem(nullptr)
{
// 执行深拷贝
*this = temp;
}
// 深拷贝
Json_Value &Json_Value::operator=(const Json_Value &another)
{
if (this != &another)
{
// 先析构释放内存
this->~Json_Value();
// 重新赋值
this->private_type = another.type;
switch (another.type)
{
case TYPE_STR:
this->p_mem = malloc(sizeof(std::string));
if (this->p_mem != nullptr)
new (this->p_mem) std::string(*((std::string *)another.p_mem));
break;
case TYPE_ARRY:
this->p_mem = malloc(sizeof(Json_Arry));
if (this->p_mem != nullptr)
new (this->p_mem) Json_Arry(*((Json_Arry *)another.p_mem));
break;
case TYPE_OBJ:
this->p_mem = malloc(sizeof(Json_Object));
if (this->p_mem != nullptr)
new (this->p_mem) Json_Object(*((Json_Object *)another.p_mem));
break;
case TYPE_NUM_INTEGER:
this->p_mem = malloc(sizeof(int64_t));
if (this->p_mem != nullptr)
*((int64_t *)this->p_mem) = *((int64_t *)another.p_mem);
break;
case TYPE_NUM_FLOAT:
this->p_mem = malloc(sizeof(double));
if (this->p_mem != nullptr)
*((double *)this->p_mem) = *((double *)another.p_mem);
break;
case TYPE_BOOLEAN:
this->p_mem = malloc(sizeof(bool));
if (this->p_mem != nullptr)
*((bool *)this->p_mem) = *((bool *)another.p_mem);
break;
default:
this->p_mem = nullptr;
}
}
return *this;
}
// 析构
Json_Value::~Json_Value()
{
this->private_type = TYPE_NULL;
if (this->p_mem != nullptr)
{
// 对象析构
switch (this->type)
{
case TYPE_STR:
((std::string *)p_mem)->~basic_string();
break;
case TYPE_ARRY:
((Json_Arry *)p_mem)->~Json_Arry();
break;
case TYPE_OBJ:
((Json_Object *)p_mem)->~Json_Object();
break;
default:
break;
};
// 释放内存
free(p_mem);
}
}
// 作为直接值获取
std::string Json_Value::asString(void)
{
if (this->type == TYPE_STR)
return *(std::string *)this->p_mem;
else
return std::string("");
}
// 作为 Json_Arry 获取
Json_Arry Json_Value::asArry(void)
{
if (this->type == TYPE_ARRY)
return *(Json_Arry *)this->p_mem;
else
return Json_Arry();
}
// 作为 Json_Object 获取
Json_Object Json_Value::asObject(void)
{
if (this->type == TYPE_OBJ)
return *(Json_Object *)this->p_mem;
else
return Json_Object();
}
// 作为 int64 获取
int64_t Json_Value::asInteger(void)
{
if (this->type == TYPE_NUM_INTEGER)
return *(int64_t *)this->p_mem;
else
return 0;
}
// 作为 double 获取
double Json_Value::asFloat(void)
{
if (this->type == TYPE_NUM_FLOAT)
return *(double *)this->p_mem;
else
return 0;
}
// 作为 Boolean 逻辑值获取
bool Json_Value::asBoolean(void)
{
if (this->type == TYPE_BOOLEAN)
return *(bool *)this->p_mem;
else
return 0;
}
// 是否为空
bool Json_Value::isNull(void)
{
return (this->private_type == TYPE_NULL);
}
// =================================================================================================
// 浅拷贝构造
Json_Pair::Json_Pair(const Json_Pair &temp)
{
*this = temp;
}
// 深拷贝
Json_Pair &Json_Pair::operator=(const Json_Pair &another)
{
if (this != &another)
{
this->Null_Flag = another.Null_Flag;
this->private_key_str = another.private_key_str;
this->private_value = another.private_value;
}
return *this;
}
// 空判定
bool Json_Pair::isNull()
{
return this->Null_Flag;
}
// =================================================================================================
// 深拷贝
Json_Arry &Json_Arry::operator=(const Json_Arry &another)
{
if (this != &another)
{
this->private_element_list = another.private_element_list;
}
return *this;
}
// 获取元素大小
size_t Json_Arry::size(void)
{
return this->private_element_list.size();
}
// 数组索引重载
Json_Value Json_Arry::operator[](size_t index)
{
if (index < this->private_element_list.size())
return this->private_element_list[index];
else
return Json_Value();
}
// 是否为空
bool Json_Arry::isNull(void)
{
return (this->private_element_list.size() == 0);
}
// =================================================================================================
// 深拷贝
Json_Object &Json_Object::operator=(const Json_Object &another)
{
if (this != &another)
{
this->private_element_list = another.private_element_list;
}
return *this;
}
// 获取元素大小
size_t Json_Object::size(void)
{
return this->private_element_list.size();
}
// 数组索引重载
Json_Pair Json_Object::operator[](size_t index)
{
if (index < this->private_element_list.size())
return this->private_element_list[index];
else
return Json_Pair();
}
// 由Key 查找值
Json_Value Json_Object::get(std::string key)
{
for (auto pair : this->private_element_list)
if (pair.key == key)
return pair.value;
return Json_Value();
}
// 是否为空
bool Json_Object::isNull(void)
{
return (this->private_element_list.size() == 0);
}