JSONNode Class Reference

#include <JSONNode.h>

Classes
struct	const_iterator
struct	iterator
struct	reverse_const_iterator
struct	reverse_iterator

Public Types
typedef iterator	json_iterator
typedef iterator	json_iterator

Public Member Functions
	JSONNode (char mytype=JSON_NODE) json_nothrow json_hot
	JSONNode (const JSONNode &orig) json_nothrow json_hot
	~JSONNode (void) json_nothrow json_hot
json_index_t	size (void) const json_nothrow json_read_priority
bool	empty (void) const json_nothrow json_read_priority
void	clear (void) json_nothrow json_cold
unsigned char	type (void) const json_nothrow json_read_priority
json_string	name (void) const json_nothrow json_read_priority
void	set_name (const json_string &newname) json_nothrow json_write_priority
void	set_comment (const json_string &comment) json_nothrow
json_string	get_comment (void) const json_nothrow
void	preparse (void) json_nothrow json_read_priority
json_string	as_string (void) const json_nothrow json_read_priority
json_int_t	as_int (void) const json_nothrow json_read_priority
json_number	as_float (void) const json_nothrow json_read_priority
bool	as_bool (void) const json_nothrow json_read_priority
JSONNode	as_node (void) const json_nothrow json_read_priority
JSONNode	as_array (void) const json_nothrow json_read_priority
void	cast (char newtype) json_nothrow
std::string	as_binary (void) const json_nothrow json_cold
void	set_binary (const unsigned char *bin, size_t bytes) json_nothrow json_cold
const JSONNode &	operator[] (json_index_t pos) const json_nothrow
const JSONNode &	operator[] (const json_string &name_t) const json_nothrow
void	push_back (const JSONNode &node) json_nothrow
void	reserve (json_index_t siz) json_nothrow
void	nullify (void) json_nothrow
void	swap (JSONNode &other) json_nothrow
void	merge (JSONNode &other) json_nothrow json_cold
void	merge (unsigned int num,...) json_nothrow json_cold
JSONNode	duplicate (void) const json_nothrow
const_iterator	begin (void) const json_nothrow
const_iterator	end (void) const json_nothrow
reverse_const_iterator	rbegin (void) const json_nothrow
reverse_const_iterator	rend (void) const json_nothrow
reverse_iterator	rbegin (void) json_nothrow
reverse_iterator	rend (void) json_nothrow
const_iterator	find (const json_string &name_t) const json_nothrow
const_iterator	find_nocase (const json_string &name_t) const json_nothrow
reverse_iterator	erase (reverse_iterator pos) json_nothrow
reverse_iterator	erase (reverse_iterator start, const reverse_iterator &end) json_nothrow
iterator	insert (iterator pos, const JSONNode &x) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const JSONNode &x) json_nothrow
iterator	insert (iterator pos, const reverse_iterator &_start, const reverse_iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const iterator &_start, const iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const reverse_iterator &_start, const reverse_iterator &_end) json_nothrow
json_iterator	insert (json_iterator pos, const const_iterator &_start, const const_iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const const_iterator &_start, const const_iterator &_end) json_nothrow
json_iterator	insert (json_iterator pos, const reverse_const_iterator &_start, const reverse_const_iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const reverse_const_iterator &_start, const reverse_const_iterator &_end) json_nothrow
json_iterator	begin (void) json_nothrow
json_iterator	end (void) json_nothrow
json_iterator	find (const json_string &name_t) json_nothrow
json_iterator	find_nocase (const json_string &name_t) json_nothrow
json_iterator	erase (json_iterator pos) json_nothrow
json_iterator	erase (json_iterator start, const json_iterator &end) json_nothrow
json_iterator	insert (json_iterator pos, const json_iterator &_start, const json_iterator &_end) json_nothrow
json_string	write (size_t approxsize=DEFAULT_APPROX_SIZE) const json_nothrow json_write_priority
json_string	write_formatted (size_t approxsize=DEFAULT_APPROX_SIZE_FORMATTED) const json_nothrow json_write_priority
	JSONNode (const json_string &unparsed) json_nothrow
	JSONNode (internalJSONNode *internal_t) json_nothrow
	JSONNode (bool, JSONNode &orig) json_nothrow json_hot
void	decRef (void) json_nothrow json_hot
void	makeUniqueInternal (void) json_nothrow
void	merge (JSONNode *other) json_nothrow json_cold
json_iterator	insertFRR (json_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
reverse_iterator	insertRRR (reverse_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
reverse_iterator	insertRFF (reverse_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
json_iterator	insertFFF (json_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
void	clear_name (void) json_nothrow
	JSONNode (char mytype=JSON_NODE) json_nothrow json_hot
	JSONNode (const JSONNode &orig) json_nothrow json_hot
	~JSONNode (void) json_nothrow json_hot
json_index_t	size (void) const json_nothrow json_read_priority
bool	empty (void) const json_nothrow json_read_priority
void	clear (void) json_nothrow json_cold
unsigned char	type (void) const json_nothrow json_read_priority
json_string	name (void) const json_nothrow json_read_priority
void	set_name (const json_string &newname) json_nothrow json_write_priority
void	set_comment (const json_string &comment) json_nothrow
json_string	get_comment (void) const json_nothrow
void	preparse (void) json_nothrow json_read_priority
json_string	as_string (void) const json_nothrow json_read_priority
json_int_t	as_int (void) const json_nothrow json_read_priority
json_number	as_float (void) const json_nothrow json_read_priority
bool	as_bool (void) const json_nothrow json_read_priority
JSONNode	as_node (void) const json_nothrow json_read_priority
JSONNode	as_array (void) const json_nothrow json_read_priority
void	cast (char newtype) json_nothrow
std::string	as_binary (void) const json_nothrow json_cold
void	set_binary (const unsigned char *bin, size_t bytes) json_nothrow json_cold
const JSONNode &	operator[] (json_index_t pos) const json_nothrow
const JSONNode &	operator[] (const json_string &name_t) const json_nothrow
void	push_back (const JSONNode &node) json_nothrow
void	reserve (json_index_t siz) json_nothrow
void	nullify (void) json_nothrow
void	swap (JSONNode &other) json_nothrow
void	merge (JSONNode &other) json_nothrow json_cold
void	merge (unsigned int num,...) json_nothrow json_cold
JSONNode	duplicate (void) const json_nothrow
const_iterator	begin (void) const json_nothrow
const_iterator	end (void) const json_nothrow
reverse_const_iterator	rbegin (void) const json_nothrow
reverse_const_iterator	rend (void) const json_nothrow
reverse_iterator	rbegin (void) json_nothrow
reverse_iterator	rend (void) json_nothrow
const_iterator	find (const json_string &name_t) const json_nothrow
const_iterator	find_nocase (const json_string &name_t) const json_nothrow
reverse_iterator	erase (reverse_iterator pos) json_nothrow
reverse_iterator	erase (reverse_iterator start, const reverse_iterator &end) json_nothrow
iterator	insert (iterator pos, const JSONNode &x) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const JSONNode &x) json_nothrow
iterator	insert (iterator pos, const reverse_iterator &_start, const reverse_iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const iterator &_start, const iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const reverse_iterator &_start, const reverse_iterator &_end) json_nothrow
json_iterator	insert (json_iterator pos, const const_iterator &_start, const const_iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const const_iterator &_start, const const_iterator &_end) json_nothrow
json_iterator	insert (json_iterator pos, const reverse_const_iterator &_start, const reverse_const_iterator &_end) json_nothrow
reverse_iterator	insert (reverse_iterator pos, const reverse_const_iterator &_start, const reverse_const_iterator &_end) json_nothrow
json_iterator	begin (void) json_nothrow
json_iterator	end (void) json_nothrow
json_iterator	find (const json_string &name_t) json_nothrow
json_iterator	find_nocase (const json_string &name_t) json_nothrow
json_iterator	erase (json_iterator pos) json_nothrow
json_iterator	erase (json_iterator start, const json_iterator &end) json_nothrow
json_iterator	insert (json_iterator pos, const json_iterator &_start, const json_iterator &_end) json_nothrow
json_string	write (size_t approxsize=DEFAULT_APPROX_SIZE) const json_nothrow json_write_priority
json_string	write_formatted (size_t approxsize=DEFAULT_APPROX_SIZE_FORMATTED) const json_nothrow json_write_priority
	JSONNode (const json_string &unparsed) json_nothrow
	JSONNode (internalJSONNode *internal_t) json_nothrow
	JSONNode (bool, JSONNode &orig) json_nothrow json_hot
void	decRef (void) json_nothrow json_hot
void	makeUniqueInternal (void) json_nothrow
void	merge (JSONNode *other) json_nothrow json_cold
json_iterator	insertFRR (json_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
reverse_iterator	insertRRR (reverse_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
reverse_iterator	insertRFF (reverse_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
json_iterator	insertFFF (json_iterator pos, JSONNode **const _start, JSONNode **const _end) json_nothrow
void	clear_name (void) json_nothrow

Static Public Member Functions
static void	deleteJSONNode (JSONNode *ptr) json_nothrow json_hot
static JSONNode *	newJSONNode_Shallow (const JSONNode &orig) json_hot
static JSON_PRIVATE JSONNode *	newJSONNode (const JSONNode &orig JSON_MUTEX_COPY_DECL2) json_hot
static JSONNode *	newJSONNode (internalJSONNode *internal_t) json_hot
static void	deleteJSONNode (JSONNode *ptr) json_nothrow json_hot
static JSONNode *	newJSONNode_Shallow (const JSONNode &orig) json_hot
static JSON_PRIVATE JSONNode *	newJSONNode (const JSONNode &orig JSON_MUTEX_COPY_DECL2) json_hot
static JSONNode *	newJSONNode (internalJSONNode *internal_t) json_hot

Public Attributes
JSONNode &at(json_index_t pos) json_throws(std const JSONNode &at(json_index_t pos) const json_throws(std JSONNode &	operator[] (json_index_t pos) json_nothrow
JSONNode &at(const json_string &name_t) json_throws(std const JSONNode &at(const json_string &name_t) const json_throws(std JSONNode &at_nocase(const json_string &name_t) json_throws(std const JSONNode &at_nocase(const json_string &name_t) const json_throws(std JSONNode &	operator[] (const json_string &name_t) json_nothrow
JSONNode JSON_PTR_LIB pop_back(json_index_t pos) json_throws(std JSONNode JSON_PTR_LIB pop_back(const json_string &name_t) json_throws(std JSONNode JSON_PTR_LIB pop_back_nocase(const json_string &name_t) json_throws(std JSONNode &	operator= (const JSONNode &) json_nothrow
internalJSONNode *	internal

Friends
class	JSONWorker
class	internalJSONNode

Member Typedef Documentation

typedef iterator JSONNode::json_iterator

typedef iterator JSONNode::json_iterator

Constructor & Destructor Documentation

JSONNode::JSONNode ( char  mytype = JSON_NODE )

inlineexplicit

References incAllocCount, JSON_ARRAY, JSON_ASSERT, JSON_BOOL, JSON_NODE, JSON_NULL, JSON_NUMBER, JSON_STRING, and JSON_TEXT.

Referenced by _newJSONNode(), as_array(), as_node(), newJSONNode(), and newJSONNode_Shallow().

                                                  : internal(internalJSONNode::newInternal(mytype)){
    JSON_ASSERT((mytype == JSON_NULL) ||
          (mytype == JSON_STRING) ||
          (mytype == JSON_NUMBER) ||
          (mytype == JSON_BOOL) ||
          (mytype == JSON_ARRAY) ||
          (mytype == JSON_NODE), JSON_TEXT("Not a proper JSON type"));
    incAllocCount();
}

Here is the caller graph for this function:

JSONNode::JSONNode ( const JSONNode &  orig )

inline

References incAllocCount.

                                                            : internal(orig.internal -> incRef()){
    incAllocCount();
}

JSONNode::~JSONNode ( void  )

inline

References decAllocCount, and decRef().

Referenced by deleteJSONNode().

                                           {
    if (internal != 0) decRef();
    decAllocCount();
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSONNode::JSONNode ( const json_string &  unparsed )

inline

References incAllocCount.

                                                          : internal(internalJSONNode::newInternal(unparsed)){ //root, specialized because it can only be array or node
        incAllocCount();
      }

JSONNode::JSONNode ( internalJSONNode *  internal_t )

inline

References incAllocCount.

                                                         : internal(internal_t){ //do not increment anything, this is only used in one case and it's already taken care of
      incAllocCount();
    }

JSONNode::JSONNode ( bool  , JSONNode &  orig  )

inline

References incAllocCount.

                                                            : internal(orig.internal){
    orig.internal = 0;
    incAllocCount();
}

JSONNode::JSONNode ( char  mytype = JSON_NODE )

explicit

JSONNode::JSONNode

(

const JSONNode &

orig

)

JSONNode::~JSONNode

(

void

)

JSONNode::JSONNode ( const json_string &  unparsed )

inline

References incAllocCount.

                                                          : internal(internalJSONNode::newInternal(unparsed)){ //root, specialized because it can only be array or node
        incAllocCount();
      }

JSONNode::JSONNode ( internalJSONNode *  internal_t )

inline

References incAllocCount.

                                                         : internal(internal_t){ //do not increment anything, this is only used in one case and it's already taken care of
      incAllocCount();
    }

JSONNode::JSONNode	(	bool	,
		JSONNode &	orig
	)

Member Function Documentation

JSONNode JSONNode::as_array

(

void

)

const

References CHILDREN, clear_name(), duplicate(), internal, JSON_ARRAY, JSON_CHECK_INTERNAL, json_foreach, JSON_NODE, JSONNode(), and type().

Referenced by getIntFromArray(), ImageTest::GetString(), ImageTest::ParseFailures(), SFRplusTest::ParseOverlay(), and BlemishTest::ParseResults().

                                                       {
      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);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

JSONNode JSONNode::as_array

(

void

)

const

std::string JSONNode::as_binary ( void  ) const

inline

References as_string(), JSON_ASSERT_SAFE, JSON_CHECK_INTERNAL, JSONBase64::json_decode64(), json_global, JSON_STRING, JSON_TEXT, and type().

                                                                {
      JSON_ASSERT_SAFE(type() == JSON_STRING, JSON_TEXT("using as_binary for a non-string type"), return json_global(EMPTY_STD_STRING););
      JSON_CHECK_INTERNAL();
      return JSONBase64::json_decode64(as_string());
    }

Here is the call graph for this function:

std::string JSONNode::as_binary

(

void

)

const

bool JSONNode::as_bool

(

void

)

const

bool JSONNode::as_bool ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by ImageTest::ParseFailures(), and BlemishTest::ParseResults().

                                                         {
      JSON_CHECK_INTERNAL();
      return static_cast<bool>(*internal);
    }

Here is the caller graph for this function:

json_number JSONNode::as_float

(

void

)

const

json_number JSONNode::as_float ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by getFloatArray(), and SFRplusTest::ParseOverlay().

                                                                 {
      JSON_CHECK_INTERNAL();
      return static_cast<json_number>(*internal);
    }

Here is the caller graph for this function:

json_int_t JSONNode::as_int

(

void

)

const

json_int_t JSONNode::as_int ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by getIntFromArray(), and sumArrayInt().

                                                              {
      JSON_CHECK_INTERNAL();
      return static_cast<json_int_t>(*internal);
    }

Here is the caller graph for this function:

JSONNode JSONNode::as_node

(

void

)

const

JSONNode JSONNode::as_node

(

void

)

const

References duplicate(), internal, JSON_ARRAY, JSON_CHECK_INTERNAL, JSON_NODE, JSONNode(), and type().

                                                      {
      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);
    }

Here is the call graph for this function:

json_string JSONNode::as_string ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by as_binary(), and ImageTest::GetString().

                                                                  {
      JSON_CHECK_INTERNAL();
      return static_cast<json_string>(*internal);
    }

Here is the caller graph for this function:

json_string JSONNode::as_string

(

void

)

const

const_iterator JSONNode::begin

(

void

)

const

JSONNode::const_iterator JSONNode::begin ( void  ) const

inline

References JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and type().

Referenced by begin(), and rend().

                                                                           {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("begin"));
        return JSONNode::const_iterator(internal -> begin());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

JSONNode::json_iterator JSONNode::begin ( void  )

inline

References begin(), JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, makeUniqueInternal(), and type().

                                                                  {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("begin"));
      makeUniqueInternal();
      return json_iterator(internal -> begin());
    }

Here is the call graph for this function:

json_iterator JSONNode::begin

(

void

)

void JSONNode::cast

(

char

newtype

)

References JSON_ARRAY, JSON_BOOL, JSON_CHECK_INTERNAL, JSON_FAIL, JSON_NODE, JSON_NULL, JSON_NUMBER, JSON_STRING, and JSON_TEXT.

                                                 {
      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"));
    }

void JSONNode::cast

(

char

newtype

)

void JSONNode::clear

(

void

)

void JSONNode::clear ( void  )

inline

References CHILDREN, empty(), JSON_CHECK_INTERNAL, and makeUniqueInternal().

                                             {
    JSON_CHECK_INTERNAL();
    if (!empty()){
      makeUniqueInternal();
      internal -> CHILDREN -> clear();
    }
}

Here is the call graph for this function:

void JSONNode::clear_name ( void  )

inline

References JSON_CHECK_INTERNAL, and makeUniqueInternal().

Referenced by as_array().

                                             {
       JSON_CHECK_INTERNAL();
       makeUniqueInternal();
       internal -> clearname();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void JSONNode::clear_name ( void  )

inline

References JSON_CHECK_INTERNAL, and makeUniqueInternal().

                                             {
       JSON_CHECK_INTERNAL();
       makeUniqueInternal();
       internal -> clearname();
   }

Here is the call graph for this function:

void JSONNode::decRef ( void  )

inline

References internalJSONNode::deleteInternal(), internalJSONNode::hasNoReferences(), and JSON_CHECK_INTERNAL.

Referenced by ~JSONNode().

                                              { //decrements internal's counter, deletes it if needed
    JSON_CHECK_INTERNAL();
    #ifdef JSON_REF_COUNT
      internal -> decRef();
      if (internal -> hasNoReferences()){
        internalJSONNode::deleteInternal(internal);
      }
    #else
      internalJSONNode::deleteInternal(internal);
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void JSONNode::decRef

(

void

)

void JSONNode::deleteJSONNode ( JSONNode *  ptr )

static

References ~JSONNode().

Referenced by jsonChildren::deleteAll(), and auto_delete::~auto_delete().

                                                         {
   #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
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void JSONNode::deleteJSONNode ( JSONNode *  ptr )

static

JSONNode JSONNode::duplicate

(

void

)

const

JSONNode JSONNode::duplicate

(

void

)

const

References internal, JSON_ASSERT, JSON_CHECK_INTERNAL, JSON_TEXT, and makeUniqueInternal().

Referenced by as_array(), and as_node().

                                                    {
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool JSONNode::empty

(

void

)

const

bool JSONNode::empty ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by clear().

                                                   {
    JSON_CHECK_INTERNAL();
    return internal -> empty();
}

Here is the caller graph for this function:

const_iterator JSONNode::end

(

void

)

const

JSONNode::const_iterator JSONNode::end ( void  ) const

inline

References JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and type().

Referenced by end(), and rbegin().

                                                                         {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("end"));
        return JSONNode::const_iterator(internal -> end());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

JSONNode::json_iterator JSONNode::end ( void  )

inline

References end(), JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, makeUniqueInternal(), and type().

                                                                {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("end"));
      makeUniqueInternal();
      return json_iterator(internal -> end());
    }

Here is the call graph for this function:

json_iterator JSONNode::end

(

void

)

JSONNode::reverse_iterator JSONNode::erase

(

reverse_iterator

pos

)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, JSON_NODE, and JSON_TEXT.

                                                                              {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
      JSON_ASSERT_UNIQUE("erase 2");
      JSON_ASSERT_SAFE(pos < rend(), JSON_TEXT("erase out of range"), return rend(););
      JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("erase out of range"), return rbegin(););
      deleteJSONNode(*(pos.it));
      internal -> CHILDREN -> erase(pos.it);
      return (empty()) ? rend() : pos + 1;
    }

reverse_iterator JSONNode::erase

(

reverse_iterator

pos

)

JSONNode::reverse_iterator JSONNode::erase	(	reverse_iterator	start,
		const reverse_iterator &	end
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, JSON_NODE, and JSON_TEXT.

                                                                                                                {
      if (_start == _end) return _start;
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
      JSON_ASSERT_UNIQUE("erase 4");
      JSON_ASSERT_SAFE(_start <= rend(), JSON_TEXT("erase out of lo range"), return rend(););
      JSON_ASSERT_SAFE(_end <= rend(), JSON_TEXT("erase out of hi range"), return rend(););
      JSON_ASSERT_SAFE(_start >= rbegin(), JSON_TEXT("erase out of lo range"), return rbegin(););
      JSON_ASSERT_SAFE(_end >= rbegin(), JSON_TEXT("erase out of hi range"), return rbegin(););
      for (JSONNode ** pos = _start.it; pos > _end.it; --pos){
        deleteJSONNode(*pos);
      }
      const json_index_t num = (json_index_t)(_start.it - _end.it);
      internal -> CHILDREN -> erase(_end.it + 1, num, _start.it);
      return (empty()) ? rend() : _start + num;
    }

reverse_iterator JSONNode::erase	(	reverse_iterator	start,
		const reverse_iterator &	end
	)

JSONNode::json_iterator JSONNode::erase

(

json_iterator

pos

)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, json_iterator_ptr, JSON_NODE, and JSON_TEXT.

                                                                    {
    JSON_CHECK_INTERNAL();
    JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
    JSON_ASSERT_UNIQUE("erase 1");
    JSON_ASSERT_SAFE(pos < end(), JSON_TEXT("erase out of range"), return end(););
    JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("erase out of range"), return begin(););
    deleteJSONNode(*(json_iterator_ptr(pos)));
    internal -> CHILDREN -> erase(json_iterator_ptr(pos));
    return (empty()) ? end() : pos;
}

json_iterator JSONNode::erase

(

json_iterator

pos

)

json_iterator JSONNode::erase	(	json_iterator	start,
		const json_iterator &	end
	)

JSONNode::json_iterator JSONNode::erase	(	json_iterator	start,
		const json_iterator &	end
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, json_iterator_ptr, JSON_NODE, and JSON_TEXT.

                                                                                                   {
    if (_start == _end) return _start;
    JSON_CHECK_INTERNAL();
    JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
    JSON_ASSERT_UNIQUE("erase 3");
    JSON_ASSERT_SAFE(_start <= end(), JSON_TEXT("erase out of lo range"), return end(););
    JSON_ASSERT_SAFE(_end <= end(), JSON_TEXT("erase out of hi range"), return end(););
    JSON_ASSERT_SAFE(_start >= begin(), JSON_TEXT("erase out of lo range"), return begin(););
    JSON_ASSERT_SAFE(_end >= begin(), JSON_TEXT("erase out of hi range"), return begin(););
    for (JSONNode ** pos = json_iterator_ptr(_start); pos < json_iterator_ptr(_end); ++pos){
      deleteJSONNode(*pos);
    }

    internal -> CHILDREN -> erase(json_iterator_ptr(_start), (json_index_t)(json_iterator_ptr(_end) - json_iterator_ptr(_start)));
    return (empty()) ? end() : _start;
}

JSONNode::const_iterator JSONNode::find

(

const json_string &

name_t

)

const

References JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, and JSON_TEXT.

                                                                                       {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find"));
      if (JSONNode ** res = internal -> at(name_t)){
        return JSONNode::const_iterator(res);
      }
      return JSONNode::const_iterator(internal -> end());
    }

const_iterator JSONNode::find

(

const json_string &

name_t

)

const

JSONNode::json_iterator JSONNode::find

(

const json_string &

name_t

)

References JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and ptr_to_json_iterator.

                                                                            {
    JSON_CHECK_INTERNAL();
    JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find"));
    makeUniqueInternal();
    if (JSONNode ** res = internal -> at(name_t)){
      return ptr_to_json_iterator(res);
    }
    return end();
}

json_iterator JSONNode::find

(

const json_string &

name_t

)

JSONNode::const_iterator JSONNode::find_nocase

(

const json_string &

name_t

)

const

References JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, and JSON_TEXT.

                                                                                                {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find_nocase"));
        if (JSONNode ** res = internal -> at_nocase(name_t)){
          return JSONNode::const_iterator(res);
        }
        return JSONNode::const_iterator(internal -> end());
      }

const_iterator JSONNode::find_nocase

(

const json_string &

name_t

)

const

json_iterator JSONNode::find_nocase

(

const json_string &

name_t

)

JSONNode::json_iterator JSONNode::find_nocase

(

const json_string &

name_t

)

References JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and ptr_to_json_iterator.

                                                                                       {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find_nocase"));
      makeUniqueInternal();
      if (JSONNode ** res = internal -> at_nocase(name_t)){
        return ptr_to_json_iterator(res);
      }
      return end();
    }

json_string JSONNode::get_comment

(

void

)

const

json_string JSONNode::get_comment ( void  ) const

inline

References internalJSONNode::getcomment(), and JSON_CHECK_INTERNAL.

                                                                    {
      JSON_CHECK_INTERNAL();
      return internal -> getcomment();
    }

Here is the call graph for this function:

JSONNode::json_iterator JSONNode::insert	(	iterator	pos,
		const JSONNode &	x
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, json_iterator_ptr, JSON_NODE, JSON_TEXT, and x.

                                                                                         {
#endif
    JSON_CHECK_INTERNAL();
    JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insert"));
    JSON_ASSERT_UNIQUE("insert 1");
    if (json_iterator_ptr(pos) >= internal -> CHILDREN -> end()){
      internal -> push_back(x);
      return end() - 1;
    }
    JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("insert out of lo range"), return begin(););
    #ifdef JSON_LIBRARY
      internal -> CHILDREN -> insert(json_iterator_ptr(pos), x);
    #else
      internal -> CHILDREN -> insert(json_iterator_ptr(pos), newJSONNode(x));
    #endif
    return pos;
}

iterator JSONNode::insert	(	iterator	pos,
		const JSONNode &	x
	)

JSONNode::reverse_iterator JSONNode::insert	(	reverse_iterator	pos,
		const JSONNode &	x
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and x.

                                                                                                   {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insert"));
      JSON_ASSERT_UNIQUE("insert 1");
      if (pos.it < internal -> CHILDREN -> begin()){
        internal -> push_front(x);
        return rend() - 1;
      }
      JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("insert out of range"), return rbegin(););
      internal -> CHILDREN -> insert(++pos.it, newJSONNode(x), true);
      return pos;
    }

reverse_iterator JSONNode::insert	(	reverse_iterator	pos,
		const JSONNode &	x
	)

iterator JSONNode::insert	(	iterator	pos,
		const reverse_iterator &	_start,
		const reverse_iterator &	_end
	)

JSONNode::iterator JSONNode::insert ( iterator  pos, const reverse_iterator &  _start, const reverse_iterator &  _end  )

inline

                                                                                                                                        {
        return insertFRR(pos, _start.it, _end.it);
      }

JSONNode::reverse_iterator JSONNode::insert ( reverse_iterator  pos, const iterator &  _start, const iterator &  _end  )

inline

                                                                                                                                        {
        return insertRFF(pos, _start.it, _end.it);
      }

reverse_iterator JSONNode::insert	(	reverse_iterator	pos,
		const iterator &	_start,
		const iterator &	_end
	)

JSONNode::reverse_iterator JSONNode::insert ( reverse_iterator  pos, const reverse_iterator &  _start, const reverse_iterator &  _end  )

inline

                                                                                                                                                        {
        return insertRRR(pos, _start.it, _end.it);
      }

reverse_iterator JSONNode::insert	(	reverse_iterator	pos,
		const reverse_iterator &	_start,
		const reverse_iterator &	_end
	)

JSONNode::iterator JSONNode::insert ( json_iterator  pos, const const_iterator &  _start, const const_iterator &  _end  )

inline

                                                                                                                                         {
        return insertFFF(pos, _start.it, _end.it);
      }

json_iterator JSONNode::insert	(	json_iterator	pos,
		const const_iterator &	_start,
		const const_iterator &	_end
	)

JSONNode::reverse_iterator JSONNode::insert ( reverse_iterator  pos, const const_iterator &  _start, const const_iterator &  _end  )

inline

                                                                                                                                                    {
        return insertRFF(pos, _start.it, _end.it);
      }

reverse_iterator JSONNode::insert	(	reverse_iterator	pos,
		const const_iterator &	_start,
		const const_iterator &	_end
	)

JSONNode::iterator JSONNode::insert ( json_iterator  pos, const reverse_const_iterator &  _start, const reverse_const_iterator &  _end  )

inline

                                                                                                                                                         {
        return insertFRR(pos, _start.it, _end.it);
      }

json_iterator JSONNode::insert	(	json_iterator	pos,
		const reverse_const_iterator &	_start,
		const reverse_const_iterator &	_end
	)

reverse_iterator JSONNode::insert	(	reverse_iterator	pos,
		const reverse_const_iterator &	_start,
		const reverse_const_iterator &	_end
	)

JSONNode::reverse_iterator JSONNode::insert ( reverse_iterator  pos, const reverse_const_iterator &  _start, const reverse_const_iterator &  _end  )

inline

                                                                                                                                                                    {
        return insertRRR(pos, _start.it, _end.it);
      }

JSONNode::json_iterator JSONNode::insert ( json_iterator  pos, const json_iterator &  _start, const json_iterator &  _end  )

inline

References json_iterator_ptr.

                                                                                                                                          {
      return insertFFF(pos, json_iterator_ptr(_start), json_iterator_ptr(_end));
    }

json_iterator JSONNode::insert	(	json_iterator	pos,
		const json_iterator &	_start,
		const json_iterator &	_end
	)

json_iterator JSONNode::insertFFF	(	json_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

JSONNode::json_iterator JSONNode::insertFFF	(	json_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, json_iterator_ptr, JSON_MUTEX_COPY2, JSON_NODE, JSON_TEXT, and json_auto< T >::ptr.

                                                                                                                          {
    JSON_CHECK_INTERNAL();
    JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertFFF"));
    JSON_ASSERT_UNIQUE("insertFFF");
    JSON_ASSERT_SAFE(pos <= end(), JSON_TEXT("insert out of high range"), return end(););
    JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("insert out of low range"), return begin(););
    const json_index_t num = (json_index_t)(_end - _start);
    json_auto<JSONNode *> mem(num);
    JSONNode ** runner = mem.ptr;
    for (JSONNode ** po = _start; po < _end; ++po){
      *runner++ = newJSONNode(*(*po)  JSON_MUTEX_COPY2);
    }
    internal -> CHILDREN -> insert(json_iterator_ptr(pos), mem.ptr, num);
    return pos;
}

json_iterator JSONNode::insertFRR	(	json_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

JSONNode::iterator JSONNode::insertFRR	(	json_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, JSON_MUTEX_COPY2, JSON_NODE, JSON_TEXT, and json_auto< T >::ptr.

                                                                                                                         {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertFRR"));
      JSON_ASSERT_UNIQUE("insert FRR");
      JSON_ASSERT_SAFE(pos <= end(), JSON_TEXT("insert out of range"), return end(););
      JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("insert out of range"), return begin(););
      const json_index_t num = (json_index_t)(_start - _end);
      json_auto<JSONNode *> mem(num);
      JSONNode ** runner = mem.ptr;
      for (JSONNode ** po = _start; po > _end; --po){
        *runner++ = newJSONNode(*(*po)    JSON_MUTEX_COPY2);
      }
      internal -> CHILDREN -> insert(pos.it, mem.ptr, num);
      return pos;
    }

reverse_iterator JSONNode::insertRFF	(	reverse_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

JSONNode::reverse_iterator JSONNode::insertRFF	(	reverse_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, JSON_MUTEX_COPY2, JSON_NODE, JSON_TEXT, and json_auto< T >::ptr.

                                                                                                                                    {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertRFF"));
      JSON_ASSERT_UNIQUE("insert RFF");
      JSON_ASSERT_SAFE(pos <= rend(), JSON_TEXT("insert out of range"), return rend(););
      JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("insert out of range"), return rbegin(););
      const json_index_t num = (json_index_t)(_end - _start);
      json_auto<JSONNode *> mem(num);
      JSONNode ** runner = mem.ptr + num;
      for (JSONNode ** po = _start; po < _end; ++po){  //fill it backwards
        *(--runner) = newJSONNode(*(*po)    JSON_MUTEX_COPY2);
      }
      internal -> CHILDREN -> insert(++pos.it, mem.ptr, num);
      return pos - num + 1;
    }

JSONNode::reverse_iterator JSONNode::insertRRR	(	reverse_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

References CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_ASSERT_SAFE, JSON_ASSERT_UNIQUE, JSON_CHECK_INTERNAL, json_global, JSON_MUTEX_COPY2, JSON_NODE, JSON_TEXT, and json_auto< T >::ptr.

                                                                                                                                    {
      JSON_CHECK_INTERNAL();
      JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertRRR"));
      JSON_ASSERT_UNIQUE("insert RRR");
      JSON_ASSERT_SAFE(pos <= rend(), JSON_TEXT("insert out of range"), return rend(););
      JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("insert out of range"), return rbegin(););
      const json_index_t num = (json_index_t)(_start - _end);
      json_auto<JSONNode *> mem(num);
      JSONNode ** runner = mem.ptr;
      for (JSONNode ** po = _start; po > _end; --po){
        *runner++ = newJSONNode(*(*po)    JSON_MUTEX_COPY2);
      }
      internal -> CHILDREN -> insert(++pos.it, mem.ptr, num);
      return pos - num + 1;
    }

reverse_iterator JSONNode::insertRRR	(	reverse_iterator	pos,
		JSONNode **const	_start,
		JSONNode **const	_end
	)

void JSONNode::makeUniqueInternal

(

void

)

void JSONNode::makeUniqueInternal ( void  )

inline

References JSON_CHECK_INTERNAL, and internalJSONNode::makeUnique().

Referenced by begin(), clear(), clear_name(), duplicate(), end(), nullify(), rbegin(), and rend().

                                                          { //makes internal it's own
      JSON_CHECK_INTERNAL();
      internal = internal -> makeUnique();  //might return itself or a new one that's exactly the same
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void JSONNode::merge

(

JSONNode &

other

)

void JSONNode::merge

(

JSONNode &

other

)

References JSON_ASSERT, JSON_CHECK_INTERNAL, json_nothrow, and JSON_TEXT.

Referenced by merge().

                                                  {
#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
}

Here is the caller graph for this function:

void JSONNode::merge	(	unsigned int	num,
			...
	)

void JSONNode::merge	(	unsigned int	num,
			...
	)

References JSON_CHECK_INTERNAL, json_nothrow, and merge().

                                                           {
#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
}

Here is the call graph for this function:

void JSONNode::merge

(

JSONNode *

other

)

void JSONNode::merge

(

JSONNode *

other

)

References JSON_CHECK_INTERNAL.

                                                      {
      JSON_CHECK_INTERNAL();
      if (internal == other -> internal) return;
      *other = *this;
    }

json_string JSONNode::name ( void  ) const

inline

References JSON_CHECK_INTERNAL.

                                                         {
    JSON_CHECK_INTERNAL();
    return internal -> name();
}

json_string JSONNode::name

(

void

)

const

JSONNode * JSONNode::newJSONNode ( const JSONNode &orig  JSON_MUTEX_COPY_DECL2 )

static

References _newJSONNode().

Referenced by internalJSONNode::internalJSONNode(), internalJSONNode::push_back(), and internalJSONNode::push_front().

                                                                              {
   #ifdef JSON_MUTEX_CALLBACKS
      if (parentMutex != 0){
         JSONNode * temp = _newJSONNode(orig);
         temp -> set_mutex(parentMutex);
         return temp;
      }
   #endif
   return _newJSONNode(orig);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static JSON_PRIVATE JSONNode* JSONNode::newJSONNode ( const JSONNode &orig  JSON_MUTEX_COPY_DECL2 )

static

static JSONNode* JSONNode::newJSONNode ( internalJSONNode *  internal_t )

static

JSONNode * JSONNode::newJSONNode ( internalJSONNode *  internal_t )

static

References JSONNode().

                                                              {
   #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
}

Here is the call graph for this function:

JSONNode * JSONNode::newJSONNode_Shallow ( const JSONNode &  orig )

static

References JSONNode().

                                                              {
   #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
}

Here is the call graph for this function:

static JSONNode* JSONNode::newJSONNode_Shallow ( const JSONNode &  orig )

static

void JSONNode::nullify

(

void

)

void JSONNode::nullify ( void  )

inline

References JSON_CHECK_INTERNAL, makeUniqueInternal(), and internalJSONNode::Nullify().

                                               {
    JSON_CHECK_INTERNAL();
    makeUniqueInternal();
    internal -> Nullify();
}

Here is the call graph for this function:

const JSONNode& JSONNode::operator[]

(

json_index_t

pos

)

const

const JSONNode& JSONNode::operator[]

(

json_index_t

pos

)

const

const JSONNode& JSONNode::operator[]

(

const json_string &

name_t

)

const

const JSONNode& JSONNode::operator[]

(

const json_string &

name_t

)

const

void JSONNode::preparse

(

void

)

void JSONNode::preparse ( void  )

inline

References JSON_CHECK_INTERNAL.

                                                    {
      JSON_CHECK_INTERNAL();
      internal -> preparse();
    }

void JSONNode::push_back

(

const JSONNode &

node

)

void JSONNode::push_back ( const JSONNode &  node )

inline

References JSON_CHECK_INTERNAL, and internalJSONNode::push_back().

Referenced by prepareTestSettings().

                                                                  {
#endif
    JSON_CHECK_INTERNAL();
    makeUniqueInternal();
    internal -> push_back(child);
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSONNode::reverse_const_iterator JSONNode::rbegin ( void  ) const

inline

References end(), JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and type().

                                                                                    {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("rbegin"));
        return JSONNode::reverse_const_iterator(internal -> end() - 1);
      }

Here is the call graph for this function:

reverse_const_iterator JSONNode::rbegin

(

void

)

const

reverse_iterator JSONNode::rbegin

(

void

)

JSONNode::reverse_iterator JSONNode::rbegin ( void  )

inline

References end(), JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, makeUniqueInternal(), and type().

                                                                        {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("rbegin"));
        makeUniqueInternal();
        return JSONNode::reverse_iterator(internal -> end() - 1);
      }

Here is the call graph for this function:

reverse_const_iterator JSONNode::rend

(

void

)

const

JSONNode::reverse_const_iterator JSONNode::rend ( void  ) const

inline

References begin(), JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, and type().

                                                                                  {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("rend"));
        return JSONNode::reverse_const_iterator(internal -> begin() - 1);
      }

Here is the call graph for this function:

JSONNode::reverse_iterator JSONNode::rend ( void  )

inline

References begin(), JSON_ARRAY, JSON_ASSERT, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, makeUniqueInternal(), and type().

                                                                      {
        JSON_CHECK_INTERNAL();
        JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("rend"));
        makeUniqueInternal();
        return JSONNode::reverse_iterator(internal -> begin() - 1);
      }

Here is the call graph for this function:

reverse_iterator JSONNode::rend

(

void

)

void JSONNode::reserve ( json_index_t  siz )

inline

References internalJSONNode::reserve().

                                                          {
    makeUniqueInternal();
    internal -> reserve(siz);
}

Here is the call graph for this function:

void JSONNode::reserve

(

json_index_t

siz

)

void JSONNode::set_binary	(	const unsigned char *	bin,
		size_t	bytes
	)

void JSONNode::set_binary ( const unsigned char *  bin, size_t  bytes  )

inline

References JSON_CHECK_INTERNAL, and JSONBase64::json_encode64().

                                                                                        {
      JSON_CHECK_INTERNAL();
      *this = JSONBase64::json_encode64(bin, bytes);
    }

Here is the call graph for this function:

void JSONNode::set_comment ( const json_string &  comment )

inline

References JSON_CHECK_INTERNAL, and internalJSONNode::setcomment().

                                                                             {
      JSON_CHECK_INTERNAL();
      makeUniqueInternal();
      internal -> setcomment(newname);
    }

Here is the call graph for this function:

void JSONNode::set_comment

(

const json_string &

comment

)

void JSONNode::set_name

(

const json_string &

newname

)

void JSONNode::set_name ( const json_string &  newname )

inline

References JSON_CHECK_INTERNAL, and internalJSONNode::setname().

Referenced by prepareTestSettings().

                                                                      {
    JSON_CHECK_INTERNAL();
    makeUniqueInternal();
    internal -> setname(newname);
}

Here is the call graph for this function:

Here is the caller graph for this function:

json_index_t JSONNode::size

(

void

)

const

json_index_t JSONNode::size ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by BlemishTest::ParseResults().

                                                          {
    JSON_CHECK_INTERNAL();
    return internal -> size();
}

Here is the caller graph for this function:

void JSONNode::swap

(

JSONNode &

other

)

void JSONNode::swap ( JSONNode &  other )

inline

References JSON_CHECK_INTERNAL.

                                                        {
    JSON_CHECK_INTERNAL();
    internalJSONNode * temp = other.internal;
    other.internal = internal;
    internal = temp;
    JSON_CHECK_INTERNAL();
}

unsigned char JSONNode::type ( void  ) const

inline

References JSON_CHECK_INTERNAL.

Referenced by as_array(), as_binary(), as_node(), begin(), end(), rbegin(), and rend().

                                                           {
    JSON_CHECK_INTERNAL();
    return internal -> type();
}

Here is the caller graph for this function:

unsigned char JSONNode::type

(

void

)

const

json_string JSONNode::write

(

size_t

approxsize = DEFAULT_APPROX_SIZE

)

const

json_string JSONNode::write ( size_t  approxsize = DEFAULT_APPROX_SIZE ) const

inline

References JSON_ARRAY, JSON_ASSERT_SAFE, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, internalJSONNode::type(), and internalJSONNode::Write().

                                                                           {
       JSON_CHECK_INTERNAL();
       JSON_ASSERT_SAFE(type() == JSON_NODE || type() == JSON_ARRAY, JSON_TEXT("Writing a non-writable node"), return json_global(EMPTY_JSON_STRING););
      json_string result;
      result.reserve(approxsize);
      internal -> Write(0xFFFFFFFF, true, result);
      return result;
    }

Here is the call graph for this function:

json_string JSONNode::write_formatted

(

size_t

approxsize = DEFAULT_APPROX_SIZE_FORMATTED

)

const

json_string JSONNode::write_formatted ( size_t  approxsize = DEFAULT_APPROX_SIZE_FORMATTED ) const

inline

References JSON_ARRAY, JSON_ASSERT_SAFE, JSON_CHECK_INTERNAL, json_global, JSON_NODE, JSON_TEXT, internalJSONNode::type(), and internalJSONNode::Write().

Referenced by prepareTestSettings().

                                                                                     {
       JSON_CHECK_INTERNAL();
       JSON_ASSERT_SAFE(type() == JSON_NODE || type() == JSON_ARRAY, JSON_TEXT("Writing a non-writable node"), return json_global(EMPTY_JSON_STRING););
      json_string result;
      result.reserve(approxsize);
      internal -> Write(0, true, result);
      return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

internalJSONNode

friend

JSONWorker

friend

Member Data Documentation

internalJSONNode * JSONNode::internal

mutable

Referenced by as_array(), as_node(), and duplicate().

JSONNode & JSONNode::operator=

inline

const JSONNode & JSONNode::operator[]

inline

JSONNode& at (const json_string & name_t) json_throws(std const JSONNode& at (const json_string & name_t) const json_throws(std JSONNode& at_nocase (const json_string & name_t) json_throws(std const JSONNode& at_nocase (const json_string & name_t) const json_throws(std JSONNode& JSONNode::operator[](const json_string &name_t) json_nothrow

---

The documentation for this class was generated from the following files:

• Documentation/Operator-Console/JSON/JSONNode.h
• Documentation/Operator-Console/JSON/JSONIterators.cpp
• Documentation/Operator-Console/JSON/JSONNode.cpp