356 lines
11 KiB
C++
356 lines
11 KiB
C++
#include "JSONNode.h"
|
|
|
|
#define IMPLEMENT_CTOR(type)\
|
|
JSONNode::JSONNode(const json_string & name_t, type value_t) json_nothrow : internal(internalJSONNode::newInternal()){\
|
|
internal -> Set(value_t);\
|
|
internal -> setname(name_t);\
|
|
LIBJSON_CTOR;\
|
|
}
|
|
IMPLEMENT_FOR_ALL_TYPES(IMPLEMENT_CTOR)
|
|
|
|
#ifndef JSON_LIBRARY
|
|
JSONNode::JSONNode(const json_string & name_t, const json_char * value_t) json_nothrow : internal(internalJSONNode::newInternal()){
|
|
internal -> Set(json_string(value_t));
|
|
internal -> setname(name_t);
|
|
LIBJSON_CTOR;
|
|
}
|
|
#endif
|
|
|
|
#if (defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY))
|
|
#include "JSONWorker.h"
|
|
JSONNode JSONNode::stringType(const json_string & str){
|
|
JSONNode res;
|
|
res.set_name(json_global(EMPTY_JSON_STRING));
|
|
#ifdef JSON_LESS_MEMORY
|
|
res = JSONWorker::FixString(str, res.internal, false);
|
|
#else
|
|
res = JSONWorker::FixString(str, res.internal -> _string_encoded);
|
|
#endif
|
|
return res;
|
|
}
|
|
|
|
void JSONNode::set_name_(const json_string & newname) json_nothrow {
|
|
#ifdef JSON_LESS_MEMORY
|
|
json_string _newname = JSONWorker::FixString(newname, internal, true);
|
|
#else
|
|
json_string _newname = JSONWorker::FixString(newname, internal -> _name_encoded);
|
|
#endif
|
|
set_name(_newname);
|
|
}
|
|
#endif
|
|
|
|
#ifdef JSON_CASTABLE
|
|
JSONNode JSONNode::as_node(void) const json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
if (type() == JSON_NODE){
|
|
return *this;
|
|
} else if (type() == JSON_ARRAY){
|
|
JSONNode res(duplicate());
|
|
res.internal -> _type = JSON_NODE;
|
|
return res;
|
|
}
|
|
#ifdef JSON_MUTEX_CALLBACKS
|
|
if (internal -> mylock != 0){
|
|
JSONNode res(JSON_NODE);
|
|
res.set_mutex(internal -> mylock);
|
|
return res;
|
|
}
|
|
#endif
|
|
return JSONNode(JSON_NODE);
|
|
}
|
|
|
|
JSONNode JSONNode::as_array(void) const json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
if (type() == JSON_ARRAY){
|
|
return *this;
|
|
} else if (type() == JSON_NODE){
|
|
JSONNode res(duplicate());
|
|
res.internal -> _type = JSON_ARRAY;
|
|
json_foreach(res.internal -> CHILDREN, runner){
|
|
(*runner) -> clear_name();
|
|
}
|
|
return res;
|
|
}
|
|
#ifdef JSON_MUTEX_CALLBACKS
|
|
if (internal -> mylock != 0){
|
|
JSONNode res(JSON_ARRAY);
|
|
res.set_mutex(internal -> mylock);
|
|
return res;
|
|
}
|
|
#endif
|
|
return JSONNode(JSON_ARRAY);
|
|
}
|
|
|
|
void JSONNode::cast(char newtype) json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
if (newtype == type()) return;
|
|
|
|
switch(newtype){
|
|
case JSON_NULL:
|
|
nullify();
|
|
return;
|
|
case JSON_STRING:
|
|
*this = as_string();
|
|
return;
|
|
case JSON_NUMBER:
|
|
*this = as_float();
|
|
return;
|
|
case JSON_BOOL:
|
|
*this = as_bool();
|
|
return;
|
|
case JSON_ARRAY:
|
|
*this = as_array();
|
|
return;
|
|
case JSON_NODE:
|
|
*this = as_node();
|
|
return;
|
|
}
|
|
JSON_FAIL(JSON_TEXT("cast to unknown type"));
|
|
}
|
|
#endif
|
|
|
|
//different just to supress the warning
|
|
#ifdef JSON_REF_COUNT
|
|
void JSONNode::merge(JSONNode & other) json_nothrow {
|
|
#else
|
|
void JSONNode::merge(JSONNode &) json_nothrow {
|
|
#endif
|
|
JSON_CHECK_INTERNAL();
|
|
#ifdef JSON_REF_COUNT
|
|
if (internal == other.internal) return;
|
|
JSON_ASSERT(*this == other, JSON_TEXT("merging two nodes that aren't equal"));
|
|
if (internal -> refcount < other.internal -> refcount){
|
|
*this = other;
|
|
} else {
|
|
other = *this;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef JSON_REF_COUNT
|
|
void JSONNode::merge(JSONNode * other) json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
if (internal == other -> internal) return;
|
|
*other = *this;
|
|
}
|
|
|
|
//different just to supress the warning
|
|
void JSONNode::merge(unsigned int num, ...) json_nothrow {
|
|
#else
|
|
void JSONNode::merge(unsigned int, ...) json_nothrow {
|
|
#endif
|
|
JSON_CHECK_INTERNAL();
|
|
#ifdef JSON_REF_COUNT
|
|
va_list args;
|
|
va_start(args, num);
|
|
for(unsigned int i = 0; i < num; ++i){
|
|
merge(va_arg(args, JSONNode*));
|
|
}
|
|
va_end(args);
|
|
#endif
|
|
}
|
|
|
|
JSONNode JSONNode::duplicate(void) const json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
JSONNode mycopy(*this);
|
|
#ifdef JSON_REF_COUNT
|
|
JSON_ASSERT(internal == mycopy.internal, JSON_TEXT("copy ctor failed to ref count correctly"));
|
|
mycopy.makeUniqueInternal();
|
|
#endif
|
|
JSON_ASSERT(internal != mycopy.internal, JSON_TEXT("makeUniqueInternal failed"));
|
|
return mycopy;
|
|
}
|
|
|
|
JSONNode & JSONNode::at(json_index_t pos) json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
if (json_unlikely(pos >= internal -> size())){
|
|
JSON_FAIL(JSON_TEXT("at() out of bounds"));
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
return (*this)[pos];
|
|
}
|
|
|
|
const JSONNode & JSONNode::at(json_index_t pos) const json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
if (json_unlikely(pos >= internal -> size())){
|
|
JSON_FAIL(JSON_TEXT("at() const out of bounds"));
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
return (*this)[pos];
|
|
}
|
|
|
|
JSONNode & JSONNode::operator[](json_index_t pos) json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(pos < internal -> size(), JSON_TEXT("[] out of bounds"));
|
|
makeUniqueInternal();
|
|
return *(internal -> at(pos));
|
|
}
|
|
|
|
const JSONNode & JSONNode::operator[](json_index_t pos) const json_nothrow {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(pos < internal -> size(), JSON_TEXT("[] const out of bounds"));
|
|
return *(internal -> at(pos));
|
|
}
|
|
|
|
JSONNode & JSONNode::at(const json_string & name_t) json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("at"));
|
|
makeUniqueInternal();
|
|
if (JSONNode ** res = internal -> at(name_t)){
|
|
return *(*res);
|
|
}
|
|
JSON_FAIL(json_string(JSON_TEXT("at could not find child by name: ")) + name_t);
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
|
|
const JSONNode & JSONNode::at(const json_string & name_t) const json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("at"));
|
|
if (JSONNode ** res = internal -> at(name_t)){
|
|
return *(*res);
|
|
}
|
|
JSON_FAIL(json_string(JSON_TEXT("at const could not find child by name: ")) + name_t);
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
|
|
#ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
|
|
JSONNode & JSONNode::at_nocase(const json_string & name_t) json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("at_nocase"));
|
|
makeUniqueInternal();
|
|
if (JSONNode ** res = internal -> at_nocase(name_t)){
|
|
return *(*res);
|
|
}
|
|
JSON_FAIL(json_string(JSON_TEXT("at_nocase could not find child by name: ")) + name_t);
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
|
|
const JSONNode & JSONNode::at_nocase(const json_string & name_t) const json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("at_nocase"));
|
|
if (JSONNode ** res = internal -> at_nocase(name_t)){
|
|
return *(*res);
|
|
}
|
|
JSON_FAIL(json_string(JSON_TEXT("at_nocase const could not find child by name: ")) + name_t);
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
#endif
|
|
|
|
#ifndef JSON_LIBRARY
|
|
struct auto_delete {
|
|
public:
|
|
auto_delete(JSONNode * node) json_nothrow : mynode(node){};
|
|
~auto_delete(void) json_nothrow { JSONNode::deleteJSONNode(mynode); };
|
|
JSONNode * mynode;
|
|
private:
|
|
auto_delete(const auto_delete &);
|
|
auto_delete & operator = (const auto_delete &);
|
|
};
|
|
#endif
|
|
|
|
JSONNode JSON_PTR_LIB JSONNode::pop_back(json_index_t pos) json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
if (json_unlikely(pos >= internal -> size())){
|
|
JSON_FAIL(JSON_TEXT("pop_back out of bounds"));
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
}
|
|
makeUniqueInternal();
|
|
#ifdef JSON_LIBRARY
|
|
return internal -> pop_back(pos);
|
|
#else
|
|
auto_delete temp(internal -> pop_back(pos));
|
|
return *temp.mynode;
|
|
#endif
|
|
}
|
|
|
|
JSONNode JSON_PTR_LIB JSONNode::pop_back(const json_string & name_t) json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("pop_back"));
|
|
#ifdef JSON_LIBRARY
|
|
return internal -> pop_back(name_t);
|
|
#else
|
|
if (JSONNode * res = internal -> pop_back(name_t)){
|
|
auto_delete temp(res);
|
|
return *(temp.mynode);
|
|
}
|
|
JSON_FAIL(json_string(JSON_TEXT("pop_back const could not find child by name: ")) + name_t);
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
#endif
|
|
}
|
|
|
|
#ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
|
|
JSONNode JSON_PTR_LIB JSONNode::pop_back_nocase(const json_string & name_t) json_throws(std::out_of_range) {
|
|
JSON_CHECK_INTERNAL();
|
|
JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("pop_back_no_case"));
|
|
#ifdef JSON_LIBRARY
|
|
return internal -> pop_back_nocase(name_t);
|
|
#else
|
|
if (JSONNode * res = internal -> pop_back_nocase(name_t)){
|
|
auto_delete temp(res);
|
|
return *(temp.mynode);
|
|
}
|
|
JSON_FAIL(json_string(JSON_TEXT("pop_back_nocase could not find child by name: ")) + name_t);
|
|
json_throw(std::out_of_range(json_global(EMPTY_STD_STRING)));
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifdef JSON_MEMORY_POOL
|
|
#include "JSONMemoryPool.h"
|
|
memory_pool<NODEPOOL> json_node_mempool;
|
|
#endif
|
|
|
|
void JSONNode::deleteJSONNode(JSONNode * ptr) json_nothrow {
|
|
#ifdef JSON_MEMORY_POOL
|
|
ptr -> ~JSONNode();
|
|
json_node_mempool.deallocate((void*)ptr);
|
|
#elif defined(JSON_MEMORY_CALLBACKS)
|
|
ptr -> ~JSONNode();
|
|
libjson_free<JSONNode>(ptr);
|
|
#else
|
|
delete ptr;
|
|
#endif
|
|
}
|
|
|
|
inline JSONNode * _newJSONNode(const JSONNode & orig) {
|
|
#ifdef JSON_MEMORY_POOL
|
|
return new((JSONNode*)json_node_mempool.allocate()) JSONNode(orig);
|
|
#elif defined(JSON_MEMORY_CALLBACKS)
|
|
return new(json_malloc<JSONNode>(1)) JSONNode(orig);
|
|
#else
|
|
return new JSONNode(orig);
|
|
#endif
|
|
}
|
|
|
|
JSONNode * JSONNode::newJSONNode(const JSONNode & orig JSON_MUTEX_COPY_DECL) {
|
|
#ifdef JSON_MUTEX_CALLBACKS
|
|
if (parentMutex != 0){
|
|
JSONNode * temp = _newJSONNode(orig);
|
|
temp -> set_mutex(parentMutex);
|
|
return temp;
|
|
}
|
|
#endif
|
|
return _newJSONNode(orig);
|
|
}
|
|
|
|
JSONNode * JSONNode::newJSONNode(internalJSONNode * internal_t) {
|
|
#ifdef JSON_MEMORY_POOL
|
|
return new((JSONNode*)json_node_mempool.allocate()) JSONNode(internal_t);
|
|
#elif defined(JSON_MEMORY_CALLBACKS)
|
|
return new(json_malloc<JSONNode>(1)) JSONNode(internal_t);
|
|
#else
|
|
return new JSONNode(internal_t);
|
|
#endif
|
|
}
|
|
|
|
JSONNode * JSONNode::newJSONNode_Shallow(const JSONNode & orig) {
|
|
#ifdef JSON_MEMORY_POOL
|
|
return new((JSONNode*)json_node_mempool.allocate()) JSONNode(true, const_cast<JSONNode &>(orig));
|
|
#elif defined(JSON_MEMORY_CALLBACKS)
|
|
return new(json_malloc<JSONNode>(1)) JSONNode(true, const_cast<JSONNode &>(orig));
|
|
#else
|
|
return new JSONNode(true, const_cast<JSONNode &>(orig));
|
|
#endif
|
|
}
|
|
|
|
|