junior.gj/SimpleJson
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add exception, gtest and some parse function

Browse Source
This commit is contained in:
Junior
2024-01-03 17:18:05 +08:00
parent d2a9a90e46
commit cd80c3b2a0
11 changed files with 403 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/json.cpp
+241 -24
View File
@@ -3,6 +3,7 @@
//
#include "json.h"
#include "exception.h"
namespace simpleJson {
@@ -149,7 +150,8 @@ namespace simpleJson {
setValueType(JSON_TYPE_LIST);
}
if (type != JSON_TYPE_LIST) {
throw std::runtime_error("JsonNode::set_list() error: type is not list");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_LIST, type);
}
try {
clear();
@@ -166,7 +168,7 @@ namespace simpleJson {
JsonNode &JsonNode::list_get(int index) {
if (type != JSON_TYPE_LIST) {
throw std::runtime_error("JsonNode::list_get() error: type is not list");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_LIST, type);
} else if (index < 0 || index >= children_size) {
throw std::runtime_error("JsonNode::list_get() error: index out of range");
} else {
@@ -180,7 +182,7 @@ namespace simpleJson {
void JsonNode::list_insert(int index, simpleJson::JsonNodePtr node) {
if (type != JSON_TYPE_LIST) {
throw std::runtime_error("JsonNode::list_insert() error: type is not list");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_LIST, type);
} else if (index < 0 || index > children_size) {
throw std::runtime_error("JsonNode::list_insert() error: index out of range");
} else {
@@ -204,7 +206,8 @@ namespace simpleJson {
void JsonNode::list_erase(int index) {
if (type != JSON_TYPE_LIST) {
throw std::runtime_error("JsonNode::list_erase() error: type is not list");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_LIST, type);
} else if (index < 0 || index >= children_size) {
throw std::runtime_error("JsonNode::list_erase() error: index out of range");
} else {
@@ -231,7 +234,7 @@ namespace simpleJson {
bool JsonNode::obj_has_item(const std::string &key) {
if (type != JSON_TYPE_OBJECT) {
throw std::runtime_error("JsonNode::obj_has_item() error: type is not object");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_OBJECT, type);
} else {
JsonNodePtr p = child_head;
while (p != nullptr) {
@@ -244,9 +247,9 @@ namespace simpleJson {
}
}
JsonNode& JsonNode::obj_get(const std::string &key) {
JsonNode &JsonNode::obj_get(const std::string &key) {
if (type != JSON_TYPE_OBJECT) {
throw std::runtime_error("JsonNode::obj_get() error: type is not object");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_OBJECT, type);
} else {
JsonNodePtr p = child_head;
while (p != nullptr) {
@@ -255,13 +258,13 @@ namespace simpleJson {
}
p = p->next;
}
throw std::runtime_error("JsonNode::obj_get() error: key \""+key+"\" not found");
throw std::runtime_error("JsonNode::obj_get() error: key \"" + key + "\" not found");
}
}
void JsonNode::obj_set(simpleJson::JsonNodePtr node) {
if (type != JSON_TYPE_OBJECT) {
throw std::runtime_error("JsonNode::obj_set() error: type is not object");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_OBJECT, type);
} else {
if (obj_has_item(node->key)) {
obj_get(node->key) = *node;
@@ -278,7 +281,7 @@ namespace simpleJson {
if (key.size() != 0 && _print_key) {
_dst_str += "\"" + key + "\":";
}
int dep = _one_line ? 0 : _tab_dep+1;
int dep = _one_line ? 0 : _tab_dep + 1;
switch (type) {
case JSON_TYPE_INT: {
_dst_str += std::to_string(value.int_value);
@@ -346,12 +349,12 @@ namespace simpleJson {
}
JsonNode& JsonNode::operator[](const std::string & key) {
JsonNode &JsonNode::operator[](const std::string &key) {
if (type == JSON_TYPE_NULL) {
setValueType(JSON_TYPE_OBJECT);
}
if (type != JSON_TYPE_OBJECT) {
throw std::runtime_error("JsonNode::operator[]() error: type is not object");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_OBJECT, type);
} else {
if (obj_has_item(key)) {
return obj_get(key);
@@ -363,12 +366,12 @@ namespace simpleJson {
}
}
JsonNode& JsonNode::operator[](int index) {
JsonNode &JsonNode::operator[](int index) {
if (type == JSON_TYPE_NULL) {
setValueType(JSON_TYPE_LIST);
}
if (type != JSON_TYPE_LIST) {
throw std::runtime_error("JsonNode::operator[]() error: type is not list");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_LIST, type);
} else {
if (index < 0 || index >= children_size) {
throw std::runtime_error("JsonNode::operator[]() error: index out of range");
@@ -382,7 +385,7 @@ namespace simpleJson {
if (type == JSON_TYPE_NULL) {
setValueType(JSON_TYPE_DOUBLE);
}
if (type == JSON_TYPE_DOUBLE) {
if (type == JSON_TYPE_DOUBLE) {
value.double_value = _value;
return _value;
} else if (type == JSON_TYPE_INT) {
@@ -392,7 +395,7 @@ namespace simpleJson {
value.bool_value = _value > 0;
return _value;
} else {
throw std::runtime_error("JsonNode::operator=(double) error: type is not number");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_INT, type);
}
}
@@ -411,7 +414,7 @@ namespace simpleJson {
return 0;
}
default: {
throw std::runtime_error("JsonNode::as_int() error: type is not number");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_INT, type);
}
}
}
@@ -431,7 +434,7 @@ namespace simpleJson {
return 0.0;
}
default: {
throw std::runtime_error("JsonNode::as_double() error: type is not number");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_DOUBLE, type);
}
}
}
@@ -454,12 +457,12 @@ namespace simpleJson {
return "NULL";
}
default: {
throw std::runtime_error("JsonNode::as_string() error: type is not string");
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_STRING, type);
}
}
}
std::vector<JsonNodePtr> JsonNode::as_vector() {
std::vector<JsonNodePtr> JsonNode::as_vector() {
std::vector<JsonNodePtr> vec;
JsonNodePtr p = child_head;
while (p != nullptr) {
@@ -470,7 +473,23 @@ namespace simpleJson {
}
void JsonNode::setValueType(simpleJson::JsonValueTypeEnum _type) {
type = _type;
type = _type;
}
bool JsonNode::as_bool() const {
switch (type) {
case JSON_TYPE_INT:
return static_cast<bool>(value.int_value);
case JSON_TYPE_DOUBLE:
return static_cast<bool>(value.double_value);
case JSON_TYPE_BOOL:
return value.bool_value;
case JSON_TYPE_NULL:
return false;
default:
throw JsonTypeError(INVALID_TYPE, __func__, JSON_TYPE_BOOL, type);
}
return false;
}
/*****************************************************************************************************************/
@@ -501,7 +520,7 @@ namespace simpleJson {
}
}
JsonReader::JsonReader(std::ifstream & _input_file_stream) {
JsonReader::JsonReader(std::ifstream &_input_file_stream) {
if (!_input_file_stream) {
throw std::runtime_error("JsonReader::JsonReader() error: input file stream is not valid");
}
@@ -535,7 +554,6 @@ namespace simpleJson {
if (eof) {
throw std::runtime_error("JsonReader::get_char() error: end of file");
} else {
curr_ptr++;
if (curr_ptr >= src_str_len) {
eof = 1;
return '\0';
@@ -582,7 +600,9 @@ namespace simpleJson {
}
void JsonReader::skip_space() {
while (curr_ptr < src_str_len && (src_str[curr_ptr] == ' ' || src_str[curr_ptr] == '\t' || src_str[curr_ptr] == '\n' || src_str[curr_ptr] == '\r')) {
while (curr_ptr < src_str_len &&
(src_str[curr_ptr] == ' ' || src_str[curr_ptr] == '\t' || src_str[curr_ptr] == '\n' ||
src_str[curr_ptr] == '\r')) {
get_char();
}
if (curr_ptr >= src_str_len) {
@@ -594,5 +614,202 @@ namespace simpleJson {
return eof;
}
/****************************************************************************************************************/
/**********************************************JsonParser********************************************************/
JsonParser::JsonParser() {
root = JsonNodePtr(new JsonNode(JSON_TYPE_OBJECT));
}
JsonParser::JsonParser(const std::string &_src_str) {
root = JsonNodePtr(new JsonNode(JSON_TYPE_OBJECT));
try {
JsonReader reader(_src_str);
parseValue(reader, root);
is_parse_success = true;
} catch (std::exception &e) {
std::cerr << e.what() << std::endl;
is_parse_success = false;
}
}
JsonParser::JsonParser(std::ifstream &_input_file_stream) {
root = JsonNodePtr(new JsonNode(JSON_TYPE_OBJECT));
try {
JsonReader reader(_input_file_stream);
parseValue(reader, root);
is_parse_success = true;
} catch (std::exception &e) {
std::cerr << e.what() << std::endl;
is_parse_success = false;
}
}
JsonNode &JsonParser::get_root() {
return *root;
}
bool JsonParser::is_success() const {
return is_parse_success;
}
bool JsonParser::fail() const {
return !is_parse_success;
}
void JsonParser::parseValue(simpleJson::JsonReader &reader, simpleJson::JsonNodePtr &node) {
reader.skip_space();
char ch = reader.curr_char();
if (ch == '{') {
parseObject(reader, node);
} else if (ch == '\"') {
parseString(reader, node);
} else if (ch == '[') {
parseList(reader, node);
} else if (ch == '-' || isdigit(ch)) {
parseNumber(reader, node);
} else {
if (reader.str_ahead(4) == "true") {
node->setValueType(JSON_TYPE_BOOL);
node->set_value(1);
reader.get_str(4);
} else if (reader.str_ahead(5) == "false") {
node->setValueType(JSON_TYPE_BOOL);
node->set_value(0);
reader.get_str(5);
} else if (reader.str_ahead(4) == "null" || reader.str_ahead(4) == "NULL") {
node->setValueType(JSON_TYPE_NULL);
reader.get_str(4);
} else {
throw JsonParseError(reader.get_curr_line(), reader.get_curr_col(), SYNTAX_ERROR);
}
}
}
void JsonParser::parseObject(simpleJson::JsonReader &reader, simpleJson::JsonNodePtr &node) {
node->setValueType(JSON_TYPE_OBJECT);
auto ch = reader.curr_char();
if (ch != '{') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
} else {
reader.get_char();
reader.skip_space();
ch = reader.curr_char();
}
while (ch != '}') {
if (ch != '\"') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
} else {
reader.get_char();
ch = reader.curr_char();
std::string key;
while (ch != '\"') {
key += reader.get_char();
ch = reader.curr_char();
}
reader.get_char();
reader.skip_space();
ch = reader.curr_char();
if (ch != ':') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
} else {
reader.get_char();
reader.skip_space();
ch = reader.curr_char();
JsonNodePtr child(new JsonNode(JSON_TYPE_NULL, key));
parseValue(reader, child);
node->push_back(child);
reader.skip_space();
ch = reader.curr_char();
if (ch == ',') {
reader.get_char();
reader.skip_space();
} else if (ch != '}') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
} else {
reader.get_char();
return;
}
}
}
ch = reader.curr_char();
}
reader.get_char();
}
void JsonParser::parseList(simpleJson::JsonReader &reader, simpleJson::JsonNodePtr &node) {
node->setValueType(JSON_TYPE_LIST);
char ch = reader.curr_char();
if (ch != '[') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
} else {
reader.get_char();
reader.skip_space();
ch = reader.curr_char();
}
while (ch != ']') {
JsonNodePtr child(new JsonNode(JSON_TYPE_NULL));
parseValue(reader, child);
node->push_back(child);
reader.skip_space();
ch = reader.curr_char();
if (ch == ',') {
reader.get_char();
reader.skip_space();
} else if (ch != ']') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
} else {
reader.get_char();
return;
}
ch = reader.curr_char();
}
reader.get_char();
}
void JsonParser::parseString(simpleJson::JsonReader &reader, simpleJson::JsonNodePtr &node) {
node->setValueType(JSON_TYPE_STRING);
std::string str;
char ch = reader.curr_char();
if (ch != '\"') {
throw JsonInvalidSym(reader.get_curr_line(), reader.get_curr_col(), ch);
}
reader.get_char();
ch = reader.curr_char();
while (ch != '\"') {
if (ch == '\\') {
reader.get_char();
ch = reader.curr_char();
if (ch == '\"' || ch == '\\' || ch == '/' || ch == '\b' || ch == '\f' || ch == '\n' || ch == '\r' ||
ch == '\t') {
str += ch;
} else if (ch == 'u') {
//unicode TODO
} else {
throw JsonInvalidEscapedSym(reader.get_curr_line(), reader.get_curr_col(), ch);
}
reader.get_char();
ch = reader.curr_char();
} else {
str += ch;
reader.get_char();
ch = reader.curr_char();
}
}
reader.get_char();
node->set_value(str);
}
void JsonParser::parseNumber(simpleJson::JsonReader &reader, simpleJson::JsonNodePtr &node) {}
/****************************************************************************************************************/
}