internalJSONNode Class Reference

#include <internalJSONNode.h>

Classes
union	value_union_t

Public Member Functions
	internalJSONNode (char mytype=JSON_NULL) json_nothrow json_hot
	internalJSONNode (const json_string &unparsed) json_nothrow json_hot
	internalJSONNode (const json_string &name_t, const json_string &value_t) json_nothrow json_read_priority
	internalJSONNode (const internalJSONNode &orig) json_nothrow json_hot
internalJSONNode &	operator= (const internalJSONNode &) json_nothrow json_hot
	~internalJSONNode (void) json_nothrow json_hot
json_index_t	size (void) const json_nothrow json_read_priority
bool	empty (void) const json_nothrow
unsigned char	type (void) const json_nothrow json_read_priority
json_string	name (void) const json_nothrow json_read_priority
void	setname (const json_string &newname) json_nothrow json_write_priority
void	setcomment (const json_string &comment) json_nothrow
json_string	getcomment (void) const json_nothrow
void	preparse (void) json_nothrow
void	push_back (const JSONNode &node) json_nothrow
void	reserve (json_index_t siz) json_nothrow
void	push_front (const JSONNode &node) json_nothrow
JSONNode *	pop_back (json_index_t pos) json_nothrow
JSONNode *	pop_back (const json_string &name_t) json_nothrow
JSONNode *	pop_back_nocase (const json_string &name_t) json_nothrow
JSONNode *	at (json_index_t pos) json_nothrow
JSONNode **	at (const json_string &name_t) json_nothrow
JSONNode **	at_nocase (const json_string &name_t) json_nothrow
void	Set (const json_string &val) json_nothrow json_write_priority
void	Set (long double val) json_nothrow json_write_priority
void	Set (float val) json_nothrow json_write_priority
void	Set (double val) json_nothrow json_write_priority
	operator long double () const json_nothrow
	operator float () const json_nothrow
	operator double () const json_nothrow
	operator json_string () const json_nothrow
	operator bool () const json_nothrow
void	Set (bool val) json_nothrow
bool	IsEqualTo (const json_string &val) const json_nothrow
bool	IsEqualTo (bool val) const json_nothrow
bool	IsEqualTo (const internalJSONNode *val) const json_nothrow
template<typename T >
bool	IsEqualToNum (T val) const json_nothrow
internalJSONNode *	incRef (void) json_nothrow
void	decRef (void) json_nothrow json_hot
bool	hasNoReferences (void) json_nothrow json_hot
internalJSONNode *	makeUnique (void) json_nothrow json_hot
JSONNode **	begin (void) const json_nothrow
JSONNode **	end (void) const json_nothrow
bool	Fetched (void) const json_nothrow json_hot
void	WriteName (bool formatted, bool arrayChild, json_string &output) const json_nothrow json_write_priority
void	WriteChildren (unsigned int indent, json_string &output) const json_nothrow json_write_priority
void	WriteComment (unsigned int indent, json_string &output) const json_nothrow json_write_priority
void	Write (unsigned int indent, bool arrayChild, json_string &output) const json_nothrow json_write_priority
bool	isContainer (void) const json_nothrow
bool	isNotContainer (void) const json_nothrow
void	Nullify (void) const json_nothrow
void	SetFetched (bool val) const json_nothrow json_hot
void	Fetch (void) const json_nothrow json_hot
void	FetchString (void) const json_nothrow json_read_priority
void	FetchNode (void) const json_nothrow json_read_priority
void	FetchArray (void) const json_nothrow json_read_priority
void	FetchNumber (void) const json_nothrow json_read_priority
void	clearname (void) json_nothrow
unsigned char _type	BITS (3)
bool _name_encoded	BITS (1)
bool _string_encoded	BITS (1)
size_t refcount	PACKED (20)
bool fetched	BITS (1)
	internalJSONNode (char mytype=JSON_NULL) json_nothrow json_hot
	internalJSONNode (const json_string &unparsed) json_nothrow json_hot
	internalJSONNode (const json_string &name_t, const json_string &value_t) json_nothrow json_read_priority
	internalJSONNode (const internalJSONNode &orig) json_nothrow json_hot
internalJSONNode &	operator= (const internalJSONNode &) json_nothrow json_hot
	~internalJSONNode (void) json_nothrow json_hot
json_index_t	size (void) const json_nothrow json_read_priority
bool	empty (void) const json_nothrow
unsigned char	type (void) const json_nothrow json_read_priority
json_string	name (void) const json_nothrow json_read_priority
void	setname (const json_string &newname) json_nothrow json_write_priority
void	setcomment (const json_string &comment) json_nothrow
json_string	getcomment (void) const json_nothrow
void	preparse (void) json_nothrow
void	push_back (const JSONNode &node) json_nothrow
void	reserve (json_index_t siz) json_nothrow
void	push_front (const JSONNode &node) json_nothrow
JSONNode *	pop_back (json_index_t pos) json_nothrow
JSONNode *	pop_back (const json_string &name_t) json_nothrow
JSONNode *	pop_back_nocase (const json_string &name_t) json_nothrow
JSONNode *	at (json_index_t pos) json_nothrow
JSONNode **	at (const json_string &name_t) json_nothrow
JSONNode **	at_nocase (const json_string &name_t) json_nothrow
void	Set (const json_string &val) json_nothrow json_write_priority
void	Set (long double val) json_nothrow json_write_priority
void	Set (float val) json_nothrow json_write_priority
void	Set (double val) json_nothrow json_write_priority
	operator long double () const json_nothrow
	operator float () const json_nothrow
	operator double () const json_nothrow
	operator json_string () const json_nothrow
	operator bool () const json_nothrow
void	Set (bool val) json_nothrow
bool	IsEqualTo (const json_string &val) const json_nothrow
bool	IsEqualTo (bool val) const json_nothrow
bool	IsEqualTo (const internalJSONNode *val) const json_nothrow
template<typename T >
bool	IsEqualToNum (T val) const json_nothrow
internalJSONNode *	incRef (void) json_nothrow
void	decRef (void) json_nothrow json_hot
bool	hasNoReferences (void) json_nothrow json_hot
internalJSONNode *	makeUnique (void) json_nothrow json_hot
JSONNode **	begin (void) const json_nothrow
JSONNode **	end (void) const json_nothrow
bool	Fetched (void) const json_nothrow json_hot
void	WriteName (bool formatted, bool arrayChild, json_string &output) const json_nothrow json_write_priority
void	WriteChildren (unsigned int indent, json_string &output) const json_nothrow json_write_priority
void	WriteComment (unsigned int indent, json_string &output) const json_nothrow json_write_priority
void	Write (unsigned int indent, bool arrayChild, json_string &output) const json_nothrow json_write_priority
bool	isContainer (void) const json_nothrow
bool	isNotContainer (void) const json_nothrow
void	Nullify (void) const json_nothrow
void	SetFetched (bool val) const json_nothrow json_hot
void	Fetch (void) const json_nothrow json_hot
void	FetchString (void) const json_nothrow json_read_priority
void	FetchNode (void) const json_nothrow json_read_priority
void	FetchArray (void) const json_nothrow json_read_priority
void	FetchNumber (void) const json_nothrow json_read_priority
void	clearname (void) json_nothrow
unsigned char _type	BITS (3)
bool _name_encoded	BITS (1)
bool _string_encoded	BITS (1)
size_t refcount	PACKED (20)
bool fetched	BITS (1)

Static Public Member Functions
static internalJSONNode *	newInternal (char mytype=JSON_NULL) json_hot
static internalJSONNode *	newInternal (const json_string &unparsed) json_hot
static internalJSONNode *	newInternal (const json_string &name_t, const json_string &value_t) json_hot
static internalJSONNode *	newInternal (const internalJSONNode &orig) json_hot
static void	deleteInternal (internalJSONNode *ptr) json_nothrow json_hot
static bool	AreEqualNoCase (const json_char *ch_one, const json_char *ch_two) json_nothrow json_read_priority
static internalJSONNode *	newInternal (char mytype=JSON_NULL) json_hot
static internalJSONNode *	newInternal (const json_string &unparsed) json_hot
static internalJSONNode *	newInternal (const json_string &name_t, const json_string &value_t) json_hot
static internalJSONNode *	newInternal (const internalJSONNode &orig) json_hot
static void	deleteInternal (internalJSONNode *ptr) json_nothrow json_hot
static bool	AreEqualNoCase (const json_char *ch_one, const json_char *ch_two) json_nothrow json_read_priority

Public Attributes
json_string	_name
json_string	_string
value_union_t	_value
json_string	_comment
jsonChildren *	CHILDREN

Constructor & Destructor Documentation

internalJSONNode::internalJSONNode ( char  mytype = JSON_NULL )

inline

References CHILDREN, incinternalAllocCount, and jsonChildren::newChildren().

Referenced by newInternal().

                                                                  : _type(mytype), _name(), _name_encoded(), _string(), _string_encoded(), _value()
    initializeMutex(0)
    initializeRefCount(1)
    initializeFetch(true)
    initializeComment(json_global(EMPTY_JSON_STRING))
    initializeChildren((_type == JSON_NODE || _type == JSON_ARRAY) ? jsonChildren::newChildren() : 0){

    incinternalAllocCount();

    #ifdef JSON_LESS_MEMORY
      //if not less memory, its in the initialization list
      if (isContainer()){
        CHILDREN = jsonChildren::newChildren();
      }
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

internalJSONNode::internalJSONNode

(

const json_string &

unparsed

)

References CHILDREN, incinternalAllocCount, JSON_ARRAY, JSON_FAIL_SAFE, JSON_NODE, JSON_TEXT, and jsonChildren::newChildren().

                                                                            : _type(), _name(),_name_encoded(false), _string(unparsed), _string_encoded(), _value()
    initializeMutex(0)
    initializeRefCount(1)
    initializeFetch(false)
    initializeComment(json_global(EMPTY_JSON_STRING))
    initializeChildren(0){

    incinternalAllocCount();
    switch (unparsed[0]){
      case JSON_TEXT('{'):  //node
        _type = JSON_NODE;
        CHILDREN = jsonChildren::newChildren();
        #ifdef JSON_PREPARSE
          FetchNode();
        #endif
        break;
      case JSON_TEXT('['):  //array
        _type = JSON_ARRAY;
        CHILDREN = jsonChildren::newChildren();
        #ifdef JSON_PREPARSE
          FetchArray();
        #endif
        break;
      default:
        JSON_FAIL_SAFE(JSON_TEXT("root not starting with either { or ["), Nullify(););
        break;
    }
}

Here is the call graph for this function:

internalJSONNode::internalJSONNode	(	const json_string &	name_t,
		const json_string &	value_t
	)

References CHILDREN, incinternalAllocCount, JSON_ARRAY, JSON_ASSERT_SAFE, JSON_BOOL, json_char, json_global, JSON_NODE, JSON_NULL, JSON_NUMBER, JSON_STRING, JSON_TEXT, json_unlikely, LETTERCASE, jsonChildren::newChildren(), and SetFetchedFalseOrDo.

                                                                                                       : _type(), _name_encoded(), _name(JSONWorker::FixString(name_t, NAME_ENCODED)), _string(), _string_encoded(), _value()
    initializeMutex(0)
    initializeRefCount(1)
    initializeFetch(false)
    initializeComment(json_global(EMPTY_JSON_STRING))
    initializeChildren(0){

    incinternalAllocCount();

    #ifdef JSON_STRICT
      JSON_ASSERT_SAFE(!value_t.empty(), JSON_TEXT("empty node"), Nullify(); return;);
    #else
      if (json_unlikely(value_t.empty())){
        _type = JSON_NULL;
        SetFetched(true);
        return;
      }
    #endif

    _string = value_t;

    const json_char firstchar = value_t[0];
    #if defined JSON_DEBUG || defined JSON_SAFE
      const json_char lastchar = value_t[value_t.length() - 1];
    #endif

    switch (firstchar){
        case JSON_TEXT('\"'):  //a json_string literal, still escaped and with leading and trailing quotes
            JSON_ASSERT_SAFE(lastchar == JSON_TEXT('\"'), JSON_TEXT("Unterminated quote"), Nullify(); return;);
            _type = JSON_STRING;
        SetFetchedFalseOrDo(FetchString());
            break;
        case JSON_TEXT('{'):  //a child node, or set of children
            JSON_ASSERT_SAFE(lastchar == JSON_TEXT('}'), JSON_TEXT("Missing }"), Nullify(); return;);
            _type = JSON_NODE;
        CHILDREN = jsonChildren::newChildren();
        SetFetchedFalseOrDo(FetchNode());
            break;
        case JSON_TEXT('['):  //an array
            JSON_ASSERT_SAFE(lastchar == JSON_TEXT(']'), JSON_TEXT("Missing ]"), Nullify(); return;);
            _type = JSON_ARRAY;
        CHILDREN = jsonChildren::newChildren();
        SetFetchedFalseOrDo(FetchArray());
            break;
        LETTERCASE('t', 'T'):
            JSON_ASSERT_SAFE(value_t == json_global(CONST_TRUE), json_string(json_global(ERROR_UNKNOWN_LITERAL) + value_t).c_str(), Nullify(); return;);
            _value._bool = true;
            _type = JSON_BOOL;
        SetFetched(true);
            break;
        LETTERCASE('f', 'F'):
            JSON_ASSERT_SAFE(value_t == json_global(CONST_FALSE), json_string(json_global(ERROR_UNKNOWN_LITERAL) + value_t).c_str(), Nullify(); return;);
            _value._bool = false;
            _type = JSON_BOOL;
        SetFetched(true);
            break;
        LETTERCASE('n', 'N'):
            JSON_ASSERT_SAFE(value_t == json_global(CONST_NULL), json_string(json_global(ERROR_UNKNOWN_LITERAL) + value_t).c_str(), Nullify(); return;);
            _type = JSON_NULL;
        SetFetched(true);
            break;
        default:
            JSON_ASSERT_SAFE(NumberToString::isNumeric(value_t), json_string(json_global(ERROR_UNKNOWN_LITERAL) + value_t).c_str(), Nullify(); return;);
        _type = JSON_NUMBER;
        SetFetchedFalseOrDo(FetchNumber());
            break;
    }
}

Here is the call graph for this function:

internalJSONNode::internalJSONNode

(

const internalJSONNode &

orig

)

References CHILDREN, incinternalAllocCount, json_foreach, json_likely, jsonChildren::newChildren(), and JSONNode::newJSONNode().

                                                                             :
    _type(orig._type), _name(orig._name), _name_encoded(orig._name_encoded),
    _string(orig._string), _string_encoded(orig._string_encoded), _value(orig._value)
    initializeMutex(0)
    initializeRefCount(1)
    initializeFetch(orig.fetched)
    initializeComment(orig._comment)
    initializeChildren(0){


    incinternalAllocCount();
    if (isContainer()){
      CHILDREN = jsonChildren::newChildren();
      if (json_likely(!orig.CHILDREN -> empty())){
        CHILDREN -> reserve(orig.CHILDREN -> size());
        json_foreach(orig.CHILDREN, myrunner){
          CHILDREN -> push_back(JSONNode::newJSONNode((*myrunner) -> duplicate()));
        }
      }
    }
    #ifdef JSON_MUTEX_CALLBACKS
      _set_mutex(orig.mylock, false);
    #endif
}

Here is the call graph for this function:

internalJSONNode::~internalJSONNode

(

void

)

References decinternalAllocCount, and DELETE_CHILDREN.

                                                     {
    decinternalAllocCount();
    #ifdef JSON_MUTEX_CALLBACKS
      _unset_mutex();
    #endif
    DELETE_CHILDREN();
}

internalJSONNode::internalJSONNode

(

char

mytype = JSON_NULL

)

internalJSONNode::internalJSONNode

(

const json_string &

unparsed

)

internalJSONNode::internalJSONNode	(	const json_string &	name_t,
		const json_string &	value_t
	)

internalJSONNode::internalJSONNode

(

const internalJSONNode &

orig

)

internalJSONNode::~internalJSONNode

(

void

)

Member Function Documentation

bool internalJSONNode::AreEqualNoCase ( const json_char *  ch_one, const json_char *  ch_two  )

static

References json_char.

                                                                                                         {
      while (*ch_one){  //only need to check one, if the other one terminates early, the check will cause it to fail
        const json_char c_one = *ch_one;
        const json_char c_two = *ch_two;
        if (c_one != c_two){
          if ((c_two > 64) && (c_two < 91)){  //A - Z
            if (c_one != (json_char)(c_two + 32)) return false;
          } else if ((c_two > 96) && (c_two < 123)){  //a - z
            if (c_one != (json_char)(c_two - 32)) return false;
          } else { //not a letter, so return false
            return false;
          }
        }
        ++ch_one;
        ++ch_two;

      }
      return *ch_two == '\0';  //this one has to be null terminated too, or else json_string two is longer, hence, not equal
    }

static bool internalJSONNode::AreEqualNoCase ( const json_char *  ch_one, const json_char *  ch_two  )

static

JSONNode* internalJSONNode::at

(

json_index_t

pos

)

JSONNode * internalJSONNode::at ( json_index_t  pos )

inline

References CHILDREN, JSON_ASSERT_SAFE, and JSON_TEXT.

                                                                    {
    JSON_ASSERT_SAFE(isContainer(), JSON_TEXT("calling at on non-container type"), return 0;);
    Fetch();
    return (*CHILDREN)[pos];
}

JSONNode ** internalJSONNode::at

(

const json_string &

name_t

)

References CHILDREN, JSON_ASSERT, JSON_ASSERT_SAFE, json_foreach, json_global, JSON_TEXT, and json_unlikely.

                                                                        {
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("at"), return 0;);
    Fetch();
    json_foreach(CHILDREN, myrunner){
      JSON_ASSERT(*myrunner != NULL, json_global(ERROR_NULL_IN_CHILDREN));
      if (json_unlikely((*myrunner) -> name() == name_t)) return myrunner;
    }
    return 0;
}

JSONNode** internalJSONNode::at

(

const json_string &

name_t

)

JSONNode ** internalJSONNode::at_nocase

(

const json_string &

name_t

)

References CHILDREN, JSON_ASSERT, JSON_ASSERT_SAFE, json_foreach, json_global, JSON_TEXT, and json_unlikely.

                                                                                   {
      JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("at_nocase"), return 0;);
      Fetch();
      json_foreach(CHILDREN, myrunner){
        JSON_ASSERT(*myrunner, json_global(ERROR_NULL_IN_CHILDREN));
        if (json_unlikely(AreEqualNoCase((*myrunner) -> name().c_str(), name_t.c_str()))) return myrunner;
      }
      return 0;
    }

JSONNode** internalJSONNode::at_nocase

(

const json_string &

name_t

)

JSONNode ** internalJSONNode::begin ( void  ) const

inline

References CHILDREN, Fetch(), isContainer(), JSON_ASSERT_SAFE, json_global, and JSON_TEXT.

                                                                  {
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("begin"), return 0;);
    Fetch();
    return CHILDREN -> begin();
}

Here is the call graph for this function:

JSONNode** internalJSONNode::begin

(

void

)

const

unsigned char _type internalJSONNode::BITS ( 3  )

mutable

unsigned char _type internalJSONNode::BITS ( 3  )

mutable

bool _name_encoded internalJSONNode::BITS ( 1  )

mutable

bool _name_encoded internalJSONNode::BITS ( 1  )

mutable

bool _string_encoded internalJSONNode::BITS ( 1  )

mutable

bool _string_encoded internalJSONNode::BITS ( 1  )

mutable

bool fetched internalJSONNode::BITS ( 1  )

mutable

bool fetched internalJSONNode::BITS ( 1  )

mutable

void internalJSONNode::clearname ( void  )

inline

References _name, and clearString().

                                             {
      clearString(_name);
    }

Here is the call graph for this function:

void internalJSONNode::clearname ( void  )

inline

References _name, and clearString().

                                             {
      clearString(_name);
    }

Here is the call graph for this function:

void internalJSONNode::decRef ( void  )

inline

References JSON_ASSERT, and JSON_TEXT.

Referenced by makeUnique().

                                                          {
      JSON_ASSERT(refcount != 0, JSON_TEXT("decRef on a 0 refcount internal"));
      --refcount;
    }

Here is the caller graph for this function:

void internalJSONNode::decRef

(

void

)

static void internalJSONNode::deleteInternal ( internalJSONNode *  ptr )

static

void internalJSONNode::deleteInternal ( internalJSONNode *  ptr )

static

Referenced by JSONNode::decRef().

                                                                         {
   #ifdef JSON_MEMORY_POOL
      ptr -> ~internalJSONNode();
      json_internal_mempool.deallocate((void*)ptr);
   #elif defined(JSON_MEMORY_CALLBACKS)
      ptr -> ~internalJSONNode();
      libjson_free<internalJSONNode>(ptr);
   #else
      delete ptr;
   #endif
}

Here is the caller graph for this function:

bool internalJSONNode::empty

(

void

)

const

bool internalJSONNode::empty ( void  ) const

inline

References CHILDREN, Fetch(), and isNotContainer().

                                                           {
    if (isNotContainer()) return true;
    Fetch();
    return CHILDREN -> empty();
}

Here is the call graph for this function:

JSONNode ** internalJSONNode::end ( void  ) const

inline

References CHILDREN, Fetch(), isContainer(), JSON_ASSERT_SAFE, json_global, and JSON_TEXT.

                                                                {
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("end"), return 0;);
    Fetch();
    return CHILDREN -> end();
}

Here is the call graph for this function:

JSONNode** internalJSONNode::end

(

void

)

const

void internalJSONNode::Fetch

(

void

)

const

References FetchArray(), FetchNode(), FetchNumber(), FetchString(), JSON_ARRAY, JSON_FAIL, JSON_NODE, JSON_NUMBER, JSON_STRING, JSON_TEXT, Nullify(), and type().

Referenced by begin(), empty(), end(), preparse(), and size().

                                                        {
      if (fetched) return;
      switch (type()){
        case JSON_STRING:
          FetchString();
          break;
        case JSON_NODE:
          FetchNode();
          break;
        case JSON_ARRAY:
          FetchArray();
          break;
        case JSON_NUMBER:
          FetchNumber();
          break;
        #if defined JSON_DEBUG || defined JSON_SAFE
          default:
            JSON_FAIL(JSON_TEXT("Fetching an unknown type"));
            Nullify();
        #endif
      }
      fetched = true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::Fetch

(

void

)

const

void internalJSONNode::FetchArray

(

void

)

const

References _string, clearString(), JSONWorker::DoArray(), JSON_ASSERT_SAFE, JSON_TEXT, and Nullify().

Referenced by Fetch().

                                                             {
      JSON_ASSERT_SAFE(!_string.empty(), JSON_TEXT("JSON node type is empty?"), Nullify(); return;);
      JSON_ASSERT_SAFE(_string[0] == JSON_TEXT('['), JSON_TEXT("JSON node type doesn't start with a square bracket?"), Nullify(); return;);
      JSON_ASSERT_SAFE(_string[_string.length() - 1] == JSON_TEXT(']'), JSON_TEXT("JSON node type doesn't end with a square bracket?"), Nullify(); return;);
      JSONWorker::DoArray(this, _string);
      clearString(_string);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::FetchArray

(

void

)

const

bool internalJSONNode::Fetched ( void  ) const

inline

                                                             {
    #if !defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY)
      return fetched;
    #else
      return true;
    #endif
}

bool internalJSONNode::Fetched

(

void

)

const

void internalJSONNode::FetchNode

(

void

)

const

References _string, clearString(), JSONWorker::DoNode(), JSON_ASSERT_SAFE, JSON_TEXT, and Nullify().

Referenced by Fetch().

                                                            {
      JSON_ASSERT_SAFE(!_string.empty(), JSON_TEXT("JSON node type is empty?"), Nullify(); return;);
      JSON_ASSERT_SAFE(_string[0] == JSON_TEXT('{'), JSON_TEXT("JSON node type doesn't start with a bracket?"), Nullify(); return;);
      JSON_ASSERT_SAFE(_string[_string.length() - 1] == JSON_TEXT('}'), JSON_TEXT("JSON node type doesn't end with a bracket?"), Nullify(); return;);
      JSONWorker::DoNode(this, _string);
      clearString(_string);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::FetchNode

(

void

)

const

void internalJSONNode::FetchNumber

(

void

)

const

void internalJSONNode::FetchNumber

(

void

)

const

References internalJSONNode::value_union_t::_number, _string, _value, clearString(), json_char, and json_auto< T >::ptr.

Referenced by Fetch().

                                                          {
    #ifdef JSON_STRICT
      _value._number = NumberToString::_atof(_string.c_str());
    #else
      #ifdef JSON_UNICODE
        const size_t len = _string.length();
        #if defined(_MSC_VER) && defined(JSON_SAFE)
          const size_t bytes = (len * (sizeof(json_char) / sizeof(char))) + 1;
          json_auto<char> temp(bytes);
          size_t res;
          errno_t err = std::wcstombs_s(&res, temp.ptr, bytes, _string.c_str(), len);
          if (err != 0){
            _value._number = (json_number)0.0;
            return;
          }
        #elif defined(JSON_SAFE)
          const size_t bytes = (len * (sizeof(json_char) / sizeof(char))) + 1;
          json_auto<char> temp(bytes);
          size_t res = std::wcstombs(temp.ptr, _string.c_str(), len);
          if (res == (size_t)-1){
            _value._number = (json_number)0.0;
            return;
          }
        #else
          json_auto<char> temp(len + 1);
          size_t res = std::wcstombs(temp.ptr, _string.c_str(), len);
        #endif
        temp.ptr[res] = '\0';
        _value._number = (json_number)std::atof(temp.ptr);
      #else
        _value._number = (json_number)std::atof(_string.c_str());
      #endif
    #endif
    #if((!defined(JSON_CASTABLE) && defined(JSON_LESS_MEMORY)) && !defined(JSON_WRITE_PRIORITY))
      clearString(_string);
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::FetchString

(

void

)

const

References _string, JSONWorker::FixString(), JSON_ASSERT, JSON_ASSERT_SAFE, JSON_TEXT, Nullify(), and STRING_ENCODED.

Referenced by Fetch().

                                                              {
      JSON_ASSERT_SAFE(!_string.empty(), JSON_TEXT("JSON json_string type is empty?"), Nullify(); return;);
      JSON_ASSERT_SAFE(_string[0] == JSON_TEXT('\"'), JSON_TEXT("JSON json_string type doesn't start with a quotation?"), Nullify(); return;);
      JSON_ASSERT_SAFE(_string[_string.length() - 1] == JSON_TEXT('\"'), JSON_TEXT("JSON json_string type doesn't end with a quotation?"), Nullify(); return;);
      _string = JSONWorker::FixString(json_string(_string.begin() + 1, _string.end() - 1), STRING_ENCODED);
      #ifdef JSON_LESS_MEMORY
        JSON_ASSERT(_string.capacity() == _string.length(), JSON_TEXT("_string object too large 2"));
      #endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::FetchString

(

void

)

const

json_string internalJSONNode::getcomment

(

void

)

const

json_string internalJSONNode::getcomment ( void  ) const

inline

References _comment.

Referenced by JSONNode::get_comment().

                                                                           {
      return _comment;
    }

Here is the caller graph for this function:

bool internalJSONNode::hasNoReferences ( void  )

inline

Referenced by JSONNode::decRef().

                                                                   {
      return refcount == 0;
    }

Here is the caller graph for this function:

bool internalJSONNode::hasNoReferences

(

void

)

internalJSONNode * internalJSONNode::incRef ( void  )

inline

References makeUnique().

                                                                    {
    #ifdef JSON_REF_COUNT
      ++refcount;
      return this;
    #else
      return makeUnique();
    #endif
}

Here is the call graph for this function:

internalJSONNode* internalJSONNode::incRef

(

void

)

bool internalJSONNode::isContainer ( void  ) const

inline

References JSON_ARRAY, and JSON_NODE.

Referenced by begin(), end(), and preparse().

                                                     {
      return (_type == JSON_NODE || _type == JSON_ARRAY);
    }

Here is the caller graph for this function:

bool internalJSONNode::isContainer ( void  ) const

inline

References JSON_ARRAY, and JSON_NODE.

                                                     {
      return (_type == JSON_NODE || _type == JSON_ARRAY);
    }

bool internalJSONNode::IsEqualTo ( const json_string &  val ) const

inline

References JSON_STRING.

                                                                                  {
    if (type() != JSON_STRING) return false;
    Fetch();
    return _string == val;
}

bool internalJSONNode::IsEqualTo

(

const json_string &

val

)

const

bool internalJSONNode::IsEqualTo ( bool  val ) const

inline

References JSON_BOOL.

                                                                   {
    if (type() != JSON_BOOL) return false;
    Fetch();
    return val == _value._bool;
}

bool internalJSONNode::IsEqualTo

(

bool

val

)

const

bool internalJSONNode::IsEqualTo

(

const internalJSONNode *

val

)

const

References _floatsAreEqual(), CHILDREN, JSON_ARRAY, JSON_ASSERT, JSON_BOOL, json_foreach, json_global, JSON_NODE, JSON_NULL, JSON_NUMBER, JSON_STRING, and JSON_TEXT.

                                                                                {
    if (this == val) return true;  //same internal object, so they must be equal (not only for ref counting)
    if (type() != val -> type()) return false;   //aren't even same type
    if (_name != val -> _name) return false;  //names aren't the same
    if (type() == JSON_NULL) return true;  //both null, can't be different
    #if !defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY)
      Fetch();
      val -> Fetch();
    #endif
    switch (type()){
      case JSON_STRING:
        return val -> _string == _string;
      case JSON_NUMBER:
        return _floatsAreEqual(val -> _value._number, _value._number);
      case JSON_BOOL:
        return val -> _value._bool == _value._bool;
    };

    JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, JSON_TEXT("Checking for equality, not sure what type"));
    if (CHILDREN -> size() != val -> CHILDREN -> size()) return false;  //if they arne't he same size then they certainly aren't equal

    //make sure each children is the same
    JSONNode ** valrunner = val -> CHILDREN -> begin();
    json_foreach(CHILDREN, myrunner){
        JSON_ASSERT(*myrunner != NULL, json_global(ERROR_NULL_IN_CHILDREN));
      JSON_ASSERT(*valrunner != NULL, json_global(ERROR_NULL_IN_CHILDREN));
      JSON_ASSERT(valrunner != val -> CHILDREN -> end(), JSON_TEXT("at the end of other one's children, but they're the same size?"));
        if (**myrunner != **valrunner) return false;
      ++valrunner;
    }
    return true;
}

Here is the call graph for this function:

bool internalJSONNode::IsEqualTo

(

const internalJSONNode *

val

)

const

template<typename T >

bool internalJSONNode::IsEqualToNum ( T  val ) const

inline

References JSON_NUMBER.

                                                                   {
    if (type() != JSON_NUMBER) return false;
    Fetch();
    return (json_number)val == _value._number;
}

template<typename T >

bool internalJSONNode::IsEqualToNum

(

T

val

)

const

bool internalJSONNode::isNotContainer ( void  ) const

inline

References JSON_ARRAY, and JSON_NODE.

Referenced by empty(), and size().

                                                        {
      return (_type != JSON_NODE && _type != JSON_ARRAY);
    }

Here is the caller graph for this function:

bool internalJSONNode::isNotContainer ( void  ) const

inline

References JSON_ARRAY, and JSON_NODE.

                                                        {
      return (_type != JSON_NODE && _type != JSON_ARRAY);
    }

internalJSONNode * internalJSONNode::makeUnique ( void  )

inline

References decRef(), JSON_ASSERT, JSON_TEXT, and newInternal().

Referenced by incRef(), and JSONNode::makeUniqueInternal().

                                                                        {
    #ifdef JSON_REF_COUNT
      if (refcount > 1){
        decRef();
        return newInternal(*this);
      }
      JSON_ASSERT(refcount == 1, JSON_TEXT("makeUnique on a 0 refcount internal"));
      return this;
    #else
      return newInternal(*this);
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

internalJSONNode* internalJSONNode::makeUnique

(

void

)

json_string internalJSONNode::name

(

void

)

const

json_string internalJSONNode::name ( void  ) const

inline

References _name.

                                                                 {
    return _name;
}

static internalJSONNode* internalJSONNode::newInternal ( char  mytype = JSON_NULL )

static

internalJSONNode * internalJSONNode::newInternal ( char  mytype = JSON_NULL )

static

References internalJSONNode().

Referenced by makeUnique().

                                                            {
   #ifdef JSON_MEMORY_POOL
      return new((internalJSONNode*)json_internal_mempool.allocate()) internalJSONNode(mytype);
   #elif defined(JSON_MEMORY_CALLBACKS)
      return new(json_malloc<internalJSONNode>(1)) internalJSONNode(mytype);
   #else
      return new internalJSONNode(mytype);
   #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static internalJSONNode* internalJSONNode::newInternal ( const json_string &  unparsed )

static

internalJSONNode * internalJSONNode::newInternal ( const json_string &  unparsed )

static

References internalJSONNode().

                                                                             {
   #ifdef JSON_MEMORY_POOL
      return new((internalJSONNode*)json_internal_mempool.allocate()) internalJSONNode(unparsed);
   #elif defined(JSON_MEMORY_CALLBACKS)
      return new(json_malloc<internalJSONNode>(1)) internalJSONNode(unparsed);
   #else
      return new internalJSONNode(unparsed);
   #endif
}

Here is the call graph for this function:

static internalJSONNode* internalJSONNode::newInternal ( const json_string &  name_t, const json_string &  value_t  )

static

internalJSONNode * internalJSONNode::newInternal ( const json_string &  name_t, const json_string &  value_t  )

static

References internalJSONNode().

                                                                                                        {
   #ifdef JSON_MEMORY_POOL
      return new((internalJSONNode*)json_internal_mempool.allocate()) internalJSONNode(name_t, value_t);
   #elif defined(JSON_MEMORY_CALLBACKS)
      return new(json_malloc<internalJSONNode>(1)) internalJSONNode(name_t, value_t);
   #else
      return new internalJSONNode(name_t, value_t);
   #endif
}

Here is the call graph for this function:

static internalJSONNode* internalJSONNode::newInternal ( const internalJSONNode &  orig )

static

internalJSONNode * internalJSONNode::newInternal ( const internalJSONNode &  orig )

static

References internalJSONNode().

                                                                              {
   #ifdef JSON_MEMORY_POOL
      return new((internalJSONNode*)json_internal_mempool.allocate()) internalJSONNode(orig);
   #elif defined(JSON_MEMORY_CALLBACKS)
      return new(json_malloc<internalJSONNode>(1)) internalJSONNode(orig);
   #else
      return new internalJSONNode(orig);
   #endif
}

Here is the call graph for this function:

void internalJSONNode::Nullify

(

void

)

const

References _string, clearString(), json_global, JSON_NULL, and SetFetched().

Referenced by Fetch(), FetchArray(), FetchNode(), FetchString(), and JSONNode::nullify().

                                                      {
    _type = JSON_NULL;
    #if(defined(JSON_CASTABLE) || !defined(JSON_LESS_MEMORY) || defined(JSON_WRITE_PRIORITY))
      _string = json_global(CONST_NULL);
    #else
      clearString(_string);
    #endif
    SetFetched(true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::Nullify

(

void

)

const

internalJSONNode::operator bool

(

)

const

References _floatsAreEqual(), JSON_ASSERT, JSON_BOOL, json_global, JSON_NULL, JSON_NUMBER, and JSON_TEXT.

                                                   {
    Fetch();
    #ifdef JSON_CASTABLE
      switch(type()){
        case JSON_NUMBER:
          return !_floatsAreEqual(_value._number, (json_number)0.0);
        case JSON_NULL:
          return false;
      }
    #endif
    JSON_ASSERT(type() == JSON_BOOL, json_global(ERROR_UNDEFINED) + JSON_TEXT("(bool)"));
    return _value._bool;
}

Here is the call graph for this function:

internalJSONNode::operator bool

(

)

const

internalJSONNode::operator double

(

)

const

internalJSONNode::operator double ( ) const

inline

                                                                  {
        return static_cast<double>(static_cast<long double>(*this));
      }

internalJSONNode::operator float ( ) const

inline

                                                                 {
        return static_cast<float>(static_cast<long double>(*this));
      }

internalJSONNode::operator float

(

)

const

internalJSONNode::operator json_string ( ) const

inline

                                                                 {
    Fetch();
    return _string;
}

internalJSONNode::operator json_string

(

)

const

internalJSONNode::operator long double

(

)

const

internalJSONNode::operator long double

(

)

const

References JSON_ASSERT, JSON_BOOL, json_global, JSON_NULL, JSON_NUMBER, JSON_STRING, and JSON_TEXT.

                                                                {
        Fetch();
        #ifdef JSON_CASTABLE
          switch(type()){
            case JSON_NULL:
                return (long double)0.0;
            case JSON_BOOL:
                return (long double)(_value._bool ? 1.0 : 0.0);
            case JSON_STRING:
                FetchNumber();
          }
        #endif
        JSON_ASSERT(type() == JSON_NUMBER, json_global(ERROR_UNDEFINED) + JSON_TEXT("(long double)"));
        return (long double)_value._number;
      }

internalJSONNode& internalJSONNode::operator=

(

const internalJSONNode &

)

internalJSONNode& internalJSONNode::operator=

(

const internalJSONNode &

)

size_t refcount internalJSONNode::PACKED

(

20

)

size_t refcount internalJSONNode::PACKED

(

20

)

JSONNode * internalJSONNode::pop_back

(

json_index_t

pos

)

References CHILDREN, JSON_ASSERT_SAFE, json_global, and JSON_TEXT.

                                                                   {
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("pop_back"), return 0;);
    JSONNode * result = (*CHILDREN)[pos];
    JSONNode ** temp = CHILDREN -> begin() + pos;
    CHILDREN -> erase(temp);
    return result;
}

JSONNode* internalJSONNode::pop_back

(

json_index_t

pos

)

JSONNode * internalJSONNode::pop_back

(

const json_string &

name_t

)

References CHILDREN, JSON_ASSERT_SAFE, json_global, and JSON_TEXT.

                                                                             {
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("pop_back(str)"), return 0;);
    if (JSONNode ** res = at(name_t)){
      JSONNode * result = *res;
      CHILDREN -> erase(res);
      return result;
    }
    return 0;
}

JSONNode* internalJSONNode::pop_back

(

const json_string &

name_t

)

JSONNode * internalJSONNode::pop_back_nocase

(

const json_string &

name_t

)

References CHILDREN, JSON_ASSERT_SAFE, json_global, and JSON_TEXT.

                                                                                        {
      JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("pop_back_nocase"), return 0;);
      if (JSONNode ** res = at_nocase(name_t)){
        JSONNode * result = *res;
        CHILDREN -> erase(res);
        return result;
      }
      return 0;
    }

JSONNode* internalJSONNode::pop_back_nocase

(

const json_string &

name_t

)

void internalJSONNode::preparse

(

void

)

void internalJSONNode::preparse

(

void

)

References CHILDREN, Fetch(), isContainer(), and json_foreach.

                                                     {
      Fetch();
      if (isContainer()){
        json_foreach(CHILDREN, myrunner){
          (*myrunner) -> preparse();
        }
      }
    }

Here is the call graph for this function:

void internalJSONNode::push_back

(

const JSONNode &

node

)

void internalJSONNode::push_back

(

const JSONNode &

node

)

References CHILDREN, JSON_ASSERT_SAFE, json_global, JSON_MUTEX_COPY, JSON_TEXT, and JSONNode::newJSONNode().

Referenced by JSONNode::push_back().

                                                                   {
#endif
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("push_back"), return;);
    #ifdef JSON_LIBRARY
      #ifdef JSON_MUTEX_CALLBACKS
        if (mylock != 0) node -> set_mutex(mylock);
      #endif
      CHILDREN -> push_back(node);
    #else
      CHILDREN -> push_back(JSONNode::newJSONNode(node   JSON_MUTEX_COPY));
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::push_front

(

const JSONNode &

node

)

References CHILDREN, JSON_ASSERT_SAFE, json_global, JSON_MUTEX_COPY, JSON_TEXT, and JSONNode::newJSONNode().

                                                                    {
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("push_front"), return;);
    CHILDREN -> push_front(JSONNode::newJSONNode(node   JSON_MUTEX_COPY));
}

Here is the call graph for this function:

void internalJSONNode::push_front

(

const JSONNode &

node

)

void internalJSONNode::reserve

(

json_index_t

siz

)

void internalJSONNode::reserve ( json_index_t  siz )

inline

References CHILDREN, JSON_ASSERT_SAFE, json_global, JSON_TEXT, and jsonChildren::reserve2().

Referenced by JSONNode::reserve().

{
    JSON_ASSERT_SAFE(isContainer(), json_global(ERROR_NON_CONTAINER) + JSON_TEXT("reserve"), return;);
    Fetch();
    jsonChildren::reserve2(CHILDREN, siz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::Set

(

const json_string &

val

)

void internalJSONNode::Set

(

const json_string &

val

)

References JSON_STRING, makeNotContainer, and shrinkString.

                                                               {
    makeNotContainer();
    _type = JSON_STRING;
    _string = shrinkString(val);
    _string_encoded = true;
    SetFetched(true);
}

void internalJSONNode::Set

(

long double

val

)

void internalJSONNode::Set

(

long double

val

)

void internalJSONNode::Set

(

float

val

)

void internalJSONNode::Set

(

float

val

)

void internalJSONNode::Set

(

double

val

)

void internalJSONNode::Set

(

double

val

)

void internalJSONNode::Set

(

bool

val

)

References JSON_BOOL, json_global, and makeNotContainer.

                                                {
    makeNotContainer();
    _type = JSON_BOOL;
    _value._bool = val;
    #if(defined(JSON_CASTABLE) || !defined(JSON_LESS_MEMORY) || defined(JSON_WRITE_PRIORITY))
      _string = val ? json_global(CONST_TRUE) : json_global(CONST_FALSE);
    #endif
    SetFetched(true);
}

void internalJSONNode::Set

(

bool

val

)

void internalJSONNode::setcomment

(

const json_string &

comment

)

void internalJSONNode::setcomment ( const json_string &  comment )

inline

Referenced by JSONNode::set_comment().

                                                                                     {
      _comment = comment;
    }

Here is the caller graph for this function:

void internalJSONNode::SetFetched ( bool  val ) const

inline

Referenced by Nullify().

                                                                        {
      fetched = val;
    }

Here is the caller graph for this function:

void internalJSONNode::SetFetched

(

bool

val

)

const

void internalJSONNode::setname

(

const json_string &

newname

)

void internalJSONNode::setname ( const json_string &  newname )

inline

References JSON_ASSERT, and JSON_TEXT.

Referenced by JSONNode::set_name().

                                                                              {
    #ifdef JSON_LESS_MEMORY
      JSON_ASSERT(newname.capacity() == newname.length(), JSON_TEXT("name object too large"));
    #endif
    _name = newname;
    _name_encoded = true;
}

Here is the caller graph for this function:

json_index_t internalJSONNode::size

(

void

)

const

json_index_t internalJSONNode::size ( void  ) const

inline

References CHILDREN, Fetch(), and isNotContainer().

                                                                  {
    if (isNotContainer()) return 0;
    Fetch();
    return CHILDREN -> size();
}

Here is the call graph for this function:

unsigned char internalJSONNode::type ( void  ) const

inline

Referenced by Fetch(), JSONNode::write(), and JSONNode::write_formatted().

                                                                   {
    return _type;
}

Here is the caller graph for this function:

unsigned char internalJSONNode::type

(

void

)

const

void internalJSONNode::Write	(	unsigned int	indent,
		bool	arrayChild,
		json_string &	output
	)		const

void internalJSONNode::Write	(	unsigned int	indent,
		bool	arrayChild,
		json_string &	output
	)		const

References JSON_ARRAY, JSON_ASSERT, JSON_BOOL, json_likely, JSON_NODE, JSON_NULL, JSON_NUMBER, JSON_STRING, JSON_TEXT, JSONWorker::UnfixString(), and used_ascii_one.

Referenced by JSONNode::write(), and JSONNode::write_formatted().

                                                                                                          {
    const bool formatted = indent != 0xFFFFFFFF;
   WriteComment(indent, output);
   
    #if !defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY)
      if (!(formatted || fetched)){  //It's not formatted or fetched, just do a raw dump
         WriteName(false, arrayChild, output);
           //first remove the \1 characters
         if (used_ascii_one){  //if it hasn't been used yet, don't bother checking
           json_string result(_string.begin(), _string.end());
           for(json_string::iterator beg = result.begin(), en = result.end(); beg != en; ++beg){
              if (*beg == JSON_TEXT('\1')) *beg = JSON_TEXT('\"');
           }
           output += result;
           return;
         }
         output.append(_string.begin(), _string.end());
         return;
      }
    #endif

   WriteName(formatted, arrayChild, output);
    //It's either formatted or fetched
    switch (_type){
      case JSON_NODE:   //got members, write the members
        Fetch();
            output += JSON_TEXT("{");
         WriteChildren(indent, output);
         output += JSON_TEXT("}");
         return;
      case JSON_ARRAY:     //write out the child nodes int he array
        Fetch();
        output += JSON_TEXT("[");
        #ifdef JSON_ARRAY_SIZE_ON_ONE_LINE
          if (size() <= JSON_ARRAY_SIZE_ON_ONE_LINE){
             WriteChildrenOneLine(indent, output);
          } else {
        #endif
             WriteChildren(indent, output);
        #ifdef JSON_ARRAY_SIZE_ON_ONE_LINE
          }
        #endif
            output += JSON_TEXT("]");
         return;
      case JSON_NUMBER:   //write out a literal, without quotes
      case JSON_NULL:
      case JSON_BOOL:
            output.append(_string.begin(), _string.end());
         return;
    }

   JSON_ASSERT(_type == JSON_STRING, JSON_TEXT("Unknown json node type"));
    //If it go here, then it's a json_string
    #if !defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY)
      if (json_likely(fetched)){
   #endif
         output += JSON_TEXT("\"");
         JSONWorker::UnfixString(_string, _string_encoded, output);  //It's already been fetched, meaning that it's unescaped
         output += JSON_TEXT("\"");  
   #if !defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY)
      } else {
         output.append(_string.begin(), _string.end());  //it hasn't yet been fetched, so it's already unescaped, just do a dump
      }
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void internalJSONNode::WriteChildren	(	unsigned int	indent,
		json_string &	output
	)		const

References CHILDREN, JSON_ARRAY, json_global, json_likely, JSON_TEXT, and makeIndent().

                                                                                                 {
    //Iterate through the children and write them
    if (json_likely(CHILDREN -> empty())) return;

    json_string indent_plus_one;
    //handle whether or not it's formatted JSON
    if (indent != 0xFFFFFFFF){  //it's formatted, make the indentation strings
      indent_plus_one = json_global(NEW_LINE) + makeIndent(++indent);
    }

    //else it's not formatted, leave the indentation strings empty
    const size_t size_minus_one = CHILDREN -> size() - 1;
    size_t i = 0;
    JSONNode ** it = CHILDREN -> begin();
    for(JSONNode ** it_end = CHILDREN -> end(); it != it_end; ++it, ++i){

      output += indent_plus_one;
      (*it) -> internal -> Write(indent, type() == JSON_ARRAY, output);
       if (json_likely(i < size_minus_one)) output += JSON_TEXT(',');  //the last one does not get a comma, but all of the others do
    }
    if (indent != 0xFFFFFFFF){
      output += json_global(NEW_LINE);
      output += makeIndent(indent - 1);
    }
}

Here is the call graph for this function:

void internalJSONNode::WriteChildren	(	unsigned int	indent,
		json_string &	output
	)		const

void internalJSONNode::WriteComment	(	unsigned int	indent,
		json_string &	output
	)		const

void internalJSONNode::WriteComment	(	unsigned int	indent,
		json_string &	output
	)		const

References json_global, json_likely, JSON_TEXT, json_unlikely, and makeIndent().

                                                                                                    {
      if (indent == 0xFFFFFFFF) return;
      if (json_likely(_comment.empty())) return;
      size_t pos = _comment.find(JSON_TEXT('\n'));
      
      const json_string current_indent(json_global(NEW_LINE) + makeIndent(indent));
      
      if (json_likely(pos == json_string::npos)){  //Single line comment
         output += current_indent;
         output += json_global(SINGLELINE_COMMENT);
         output.append(_comment.begin(), _comment.end());
         output += current_indent;
         return;
      }

      /*
       Multiline comments
       */
      output += current_indent;
      #if !(defined(JSON_WRITE_BASH_COMMENTS) || defined(JSON_WRITE_SINGLE_LINE_COMMENTS))
        const json_string current_indent_plus_one(json_global(NEW_LINE) + makeIndent(indent + 1));
        output += JSON_TEXT("/*");
        output += current_indent_plus_one;
      #endif
      size_t old = 0;
      while(pos != json_string::npos){
        if (json_unlikely(pos && _comment[pos - 1] == JSON_TEXT('\r'))) --pos;
        #if defined(JSON_WRITE_BASH_COMMENTS) || defined(JSON_WRITE_SINGLE_LINE_COMMENTS)
          output += json_global(SINGLELINE_COMMENT);
        #endif
        output.append(_comment.begin() + old, _comment.begin() + pos);
        
        #if defined(JSON_WRITE_BASH_COMMENTS) || defined(JSON_WRITE_SINGLE_LINE_COMMENTS)
          output += current_indent;
        #else
          output += current_indent_plus_one;
        #endif
        old = (_comment[pos] == JSON_TEXT('\r')) ? pos + 2 : pos + 1;
        pos = _comment.find(JSON_TEXT('\n'), old);
      }
      #if defined(JSON_WRITE_BASH_COMMENTS) || defined(JSON_WRITE_SINGLE_LINE_COMMENTS)
        output += json_global(SINGLELINE_COMMENT);
      #endif
      output.append(_comment.begin() + old, _comment.end());
      output += current_indent;
      #if !(defined(JSON_WRITE_BASH_COMMENTS) || defined(JSON_WRITE_SINGLE_LINE_COMMENTS))
        output += JSON_TEXT("*/");
        output += current_indent;
      #endif
    }

Here is the call graph for this function:

void internalJSONNode::WriteName	(	bool	formatted,
		bool	arrayChild,
		json_string &	output
	)		const

References JSON_TEXT, and JSONWorker::UnfixString().

                                                                                                         {
    if (!arrayChild){
      output += JSON_TEXT("\"");
      JSONWorker::UnfixString(_name, _name_encoded, output);
      output += ((formatted) ? JSON_TEXT("\" : ") : JSON_TEXT("\":"));
    }
}

Here is the call graph for this function:

void internalJSONNode::WriteName	(	bool	formatted,
		bool	arrayChild,
		json_string &	output
	)		const

Member Data Documentation

json_string internalJSONNode::_comment

Referenced by getcomment().

json_string internalJSONNode::_name

Referenced by clearname(), and name().

json_string internalJSONNode::_string

mutable

Referenced by FetchArray(), FetchNode(), FetchNumber(), FetchString(), and Nullify().

value_union_t internalJSONNode::_value

mutable

Referenced by FetchNumber().

jsonChildren * internalJSONNode::CHILDREN

Referenced by begin(), empty(), end(), preparse(), and size().

---

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

• Documentation/Operator-Console/JSON/internalJSONNode.h
• Documentation/Operator-Console/JSON/internalJSONNode.cpp
• Documentation/Operator-Console/JSON/JSONWriter.cpp