jsonChildren Class Reference

#include <JSONChildren.h>

Classes
struct	iteratorKeeper

Public Member Functions
	jsonChildren (void) json_nothrow
childrenVirtual	~jsonChildren (void) json_nothrow
void	inc (json_index_t amount) json_nothrow
void	inc (void) json_nothrow
void	push_back (JSONNode *item) json_nothrow
void	push_front (JSONNode *item) json_nothrow
JSONNode *	operator[] (json_index_t position) const json_nothrow
json_index_t	capacity () const json_nothrow
json_index_t	size () const json_nothrow
bool	empty () const json_nothrow
void	clear () json_nothrow
JSONNode **	begin (void) const json_nothrow
JSONNode **	end (void) const json_nothrow
void	erase (JSONNode **&position) json_nothrow
void	erase (JSONNode **&position, json_index_t number) json_nothrow
void	erase (JSONNode **position, json_index_t number, JSONNode **&starter) json_nothrow
void	insert (JSONNode **&position, JSONNode *item, bool reverse=false) json_nothrow
void	insert (JSONNode **&position, JSONNode **items, json_index_t num) json_nothrow
void	reserve (json_index_t amount) json_nothrow
childrenVirtual void	shrink () json_nothrow
JSON_PROTECTED	jsonChildren (const jsonChildren &)
jsonChildren &	operator= (const jsonChildren &)
void	deleteAll (void) json_nothrow json_hot
void	doerase (JSONNode **position, json_index_t number) json_nothrow
	jsonChildren (void) json_nothrow
childrenVirtual	~jsonChildren (void) json_nothrow
void	inc (json_index_t amount) json_nothrow
void	inc (void) json_nothrow
void	push_back (JSONNode *item) json_nothrow
void	push_front (JSONNode *item) json_nothrow
JSONNode *	operator[] (json_index_t position) const json_nothrow
json_index_t	capacity () const json_nothrow
json_index_t	size () const json_nothrow
bool	empty () const json_nothrow
void	clear () json_nothrow
JSONNode **	begin (void) const json_nothrow
JSONNode **	end (void) const json_nothrow
void	erase (JSONNode **&position) json_nothrow
void	erase (JSONNode **&position, json_index_t number) json_nothrow
void	erase (JSONNode **position, json_index_t number, JSONNode **&starter) json_nothrow
void	insert (JSONNode **&position, JSONNode *item, bool reverse=false) json_nothrow
void	insert (JSONNode **&position, JSONNode **items, json_index_t num) json_nothrow
void	reserve (json_index_t amount) json_nothrow
childrenVirtual void	shrink () json_nothrow
JSON_PROTECTED	jsonChildren (const jsonChildren &)
jsonChildren &	operator= (const jsonChildren &)
void	deleteAll (void) json_nothrow json_hot
void	doerase (JSONNode **position, json_index_t number) json_nothrow

Static Public Member Functions
static void	reserve2 (jsonChildren *&mine, json_index_t amount) json_nothrow
static void	deleteChildren (jsonChildren *ptr) json_nothrow
static jsonChildren *	newChildren (void)
static void	reserve2 (jsonChildren *&mine, json_index_t amount) json_nothrow
static void	deleteChildren (jsonChildren *ptr) json_nothrow
static jsonChildren *	newChildren (void)

Public Attributes
JSONNode **	array
json_index_t	mysize
json_index_t	mycapacity

Constructor & Destructor Documentation

jsonChildren::jsonChildren ( void  )

inline

References addAllocCount.

Referenced by newChildren().

                                    : array(0), mysize(0), mycapacity(0) {
      addAllocCount();
    }

Here is the caller graph for this function:

childrenVirtual jsonChildren::~jsonChildren ( void  )

inline

References array, deleteAll(), json_unlikely, and subAllocCount.

Referenced by deleteChildren().

                                                     {
      if (json_unlikely(array != 0)){  //the following function calls are safe, but take more time than a check here
        deleteAll();
        libjson_free<JSONNode*>(array);
      }
      subAllocCount();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

JSON_PROTECTED jsonChildren::jsonChildren

(

const jsonChildren &

)

jsonChildren::jsonChildren ( void  )

inline

References addAllocCount.

                                    : array(0), mysize(0), mycapacity(0) {
      addAllocCount();
    }

childrenVirtual jsonChildren::~jsonChildren ( void  )

inline

References array, deleteAll(), json_unlikely, and subAllocCount.

                                                     {
      if (json_unlikely(array != 0)){  //the following function calls are safe, but take more time than a check here
        deleteAll();
        libjson_free<JSONNode*>(array);
      }
      subAllocCount();
    }

Here is the call graph for this function:

JSON_PROTECTED jsonChildren::jsonChildren

(

const jsonChildren &

)

Member Function Documentation

JSONNode** jsonChildren::begin ( void  ) const

inline

References array, JSON_ASSERT, and JSON_TEXT.

                                                      {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null begin"));
      return array;
    }

JSONNode** jsonChildren::begin ( void  ) const

inline

References array, JSON_ASSERT, and JSON_TEXT.

                                                      {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null begin"));
      return array;
    }

json_index_t jsonChildren::capacity ( ) const

inline

References JSON_ASSERT, JSON_TEXT, and mycapacity.

                                                      {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null capacity"));
      return mycapacity;
    }

json_index_t jsonChildren::capacity ( ) const

inline

References JSON_ASSERT, JSON_TEXT, and mycapacity.

                                                      {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null capacity"));
      return mycapacity;
    }

void jsonChildren::clear ( void  )

inline

References array, deleteAll(), JSON_ASSERT, json_likely, JSON_TEXT, mycapacity, and mysize.

                                     {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null clear"));
      if (json_likely(array != 0)){  //don't bother clearing anything if there is nothing in it
        JSON_ASSERT(mycapacity != 0, JSON_TEXT("mycapacity is not zero, but array is null"));
        deleteAll();
        mysize = 0;
      }
      JSON_ASSERT(mysize == 0, JSON_TEXT("mysize is not zero after clear"));
    }

Here is the call graph for this function:

void jsonChildren::clear ( )

inline

References array, deleteAll(), JSON_ASSERT, json_likely, JSON_TEXT, mycapacity, and mysize.

                                     {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null clear"));
      if (json_likely(array != 0)){  //don't bother clearing anything if there is nothing in it
        JSON_ASSERT(mycapacity != 0, JSON_TEXT("mycapacity is not zero, but array is null"));
        deleteAll();
        mysize = 0;
      }
      JSON_ASSERT(mysize == 0, JSON_TEXT("mysize is not zero after clear"));
    }

Here is the call graph for this function:

void jsonChildren::deleteAll

(

void

)

References JSONNode::deleteJSONNode(), JSON_ASSERT, json_foreach, and JSON_TEXT.

Referenced by clear(), and ~jsonChildren().

                                              {
    JSON_ASSERT(this != 0, JSON_TEXT("Children is null deleteAll"));
    json_foreach(this, runner){
        JSON_ASSERT(*runner != JSON_TEXT('\0'), JSON_TEXT("a null pointer within the children"));
      JSONNode::deleteJSONNode(*runner);  //this is why I can't do forward declaration
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void jsonChildren::deleteAll

(

void

)

static void jsonChildren::deleteChildren ( jsonChildren *  ptr )

inlinestatic

References ~jsonChildren().

                                                                       {
      #ifdef JSON_MEMORY_CALLBACKS
        ptr -> ~jsonChildren();
        libjson_free<jsonChildren>(ptr);
      #else
        delete ptr;
      #endif
    }

Here is the call graph for this function:

static void jsonChildren::deleteChildren ( jsonChildren *  ptr )

inlinestatic

References ~jsonChildren().

                                                                       {
      #ifdef JSON_MEMORY_CALLBACKS
        ptr -> ~jsonChildren();
        libjson_free<jsonChildren>(ptr);
      #else
        delete ptr;
      #endif
    }

Here is the call graph for this function:

void jsonChildren::doerase	(	JSONNode **	position,
		json_index_t	number
	)

void jsonChildren::doerase	(	JSONNode **	position,
		json_index_t	number
	)

References JSON_ASSERT, and JSON_TEXT.

Referenced by erase().

                                                                                 {
    JSON_ASSERT(this != 0, JSON_TEXT("Children is null doerase"));
    JSON_ASSERT(array != 0, JSON_TEXT("erasing something from a null array 2"));
    JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array 2"));
    JSON_ASSERT(position + number <= array + mysize, JSON_TEXT("erasing out of bounds 2"));
    if (position + number >= array + mysize){
      mysize = (json_index_t)(position - array);
      #ifndef JSON_ISO_STRICT
        JSON_ASSERT((long long)position - (long long)array >= 0, JSON_TEXT("doing negative allocation"));
      #endif
    } else {
      std::memmove(position, position + number, (mysize - (position - array) - number) * sizeof(JSONNode *));
      mysize -= number;
    }
}

Here is the caller graph for this function:

bool jsonChildren::empty ( void  ) const

inline

References JSON_ASSERT, JSON_TEXT, and mysize.

                                           {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null empty"));
      return mysize == 0;
    }

bool jsonChildren::empty ( void  ) const

inline

References JSON_ASSERT, JSON_TEXT, and mysize.

                                           {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null empty"));
      return mysize == 0;
    }

JSONNode** jsonChildren::end ( void  ) const

inline

References array, JSON_ASSERT, JSON_TEXT, and mysize.

                                                    {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null end"));
      return array + mysize;
    }

JSONNode** jsonChildren::end ( void  ) const

inline

References array, JSON_ASSERT, JSON_TEXT, and mysize.

                                                    {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null end"));
      return array + mysize;
    }

void jsonChildren::erase ( JSONNode **&  position )

inline

References array, JSON_ASSERT, JSON_TEXT, mysize, and shrink().

                                                           {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null erase"));
      JSON_ASSERT(array != 0, JSON_TEXT("erasing something from a null array 1"));
      JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array 1"));
      JSON_ASSERT(position <= array + mysize, JSON_TEXT("erasing out of bounds 1"));
      std::memmove(position, position + 1, (mysize-- - (position - array) - 1) * sizeof(JSONNode *));
      iteratorKeeper ik(this, position);
      shrink();
    }

Here is the call graph for this function:

void jsonChildren::erase ( JSONNode **&  position )

inline

References array, JSON_ASSERT, JSON_TEXT, mysize, and shrink().

                                                           {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null erase"));
      JSON_ASSERT(array != 0, JSON_TEXT("erasing something from a null array 1"));
      JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array 1"));
      JSON_ASSERT(position <= array + mysize, JSON_TEXT("erasing out of bounds 1"));
      std::memmove(position, position + 1, (mysize-- - (position - array) - 1) * sizeof(JSONNode *));
      iteratorKeeper ik(this, position);
      shrink();
    }

Here is the call graph for this function:

void jsonChildren::erase ( JSONNode **&  position, json_index_t  number  )

inline

References doerase(), JSON_ASSERT, JSON_TEXT, and shrink().

                                                                                {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null erase 2"));
      doerase(position, number);
      iteratorKeeper ik(this, position);
      shrink();
    }

Here is the call graph for this function:

void jsonChildren::erase ( JSONNode **&  position, json_index_t  number  )

inline

References doerase(), JSON_ASSERT, JSON_TEXT, and shrink().

                                                                                {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null erase 2"));
      doerase(position, number);
      iteratorKeeper ik(this, position);
      shrink();
    }

Here is the call graph for this function:

void jsonChildren::erase ( JSONNode **  position, json_index_t  number, JSONNode **&  starter  )

inline

References doerase(), JSON_ASSERT, JSON_TEXT, and shrink().

                                                                                                     {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null erase 3"));
      doerase(position, number);
      iteratorKeeper ik(this, starter);
      shrink();
    }

Here is the call graph for this function:

void jsonChildren::erase ( JSONNode **  position, json_index_t  number, JSONNode **&  starter  )

inline

References doerase(), JSON_ASSERT, JSON_TEXT, and shrink().

                                                                                                     {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null erase 3"));
      doerase(position, number);
      iteratorKeeper ik(this, starter);
      shrink();
    }

Here is the call graph for this function:

void jsonChildren::inc

(

json_index_t

amount

)

void jsonChildren::inc

(

json_index_t

amount

)

References JSON_ASSERT, json_likely, JSON_TEXT, and json_unlikely.

                                                       {
    JSON_ASSERT(this != 0, JSON_TEXT("Children is null inc(amount)"));
    if (json_unlikely(amount == 0)) return;
    if (json_likely(mysize + amount >= mycapacity)){  //it's full
      if (json_unlikely(mycapacity == 0)){  //the array hasn't been created yet
        JSON_ASSERT(!array, JSON_TEXT("Expanding a 0 capacity array, but not null"));
        #ifdef JSON_LESS_MEMORY
          array = json_malloc<JSONNode*>(amount);
          mycapacity = amount;
        #else
          array = json_malloc<JSONNode*>(amount > 8 ? amount : 8);  //8 seems average for JSON, and it's only 64 bytes
          mycapacity = amount > 8 ? amount : 8;
        #endif
      } else {
        #ifdef JSON_LESS_MEMORY
          mycapacity = mysize + amount;  //increment the size of the array
        #else
          while(mysize + amount > mycapacity){
            mycapacity <<= 1;  //double the size of the array
          }
        #endif
        array = json_realloc<JSONNode*>(array, mycapacity);
      }
    }
}

void jsonChildren::inc

(

void

)

References array, JSON_ASSERT, JSON_TEXT, json_unlikely, mycapacity, and mysize.

Referenced by insert(), push_back(), and push_front().

                                        {
    JSON_ASSERT(this != 0, JSON_TEXT("Children is null inc"));
    if (json_unlikely(mysize == mycapacity)){  //it's full
      if (json_unlikely(mycapacity == 0)){  //the array hasn't been created yet
        JSON_ASSERT(!array, JSON_TEXT("Expanding a 0 capacity array, but not null"));
        #ifdef JSON_LESS_MEMORY
          array = json_malloc<JSONNode*>(1);
          mycapacity = 1;
        #else
          array = json_malloc<JSONNode*>(8);  //8 seems average for JSON, and it's only 64 bytes
          mycapacity = 8;
        #endif
      } else {
        #ifdef JSON_LESS_MEMORY
          mycapacity += 1;  //increment the size of the array
        #else
          mycapacity <<= 1;  //double the size of the array
        #endif
        array = json_realloc<JSONNode*>(array, mycapacity);
      }
    }
}

Here is the caller graph for this function:

void jsonChildren::inc

(

void

)

void jsonChildren::insert ( JSONNode **&  position, JSONNode *  item, bool  reverse = false  )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                                                              {
    #endif
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null insert"));
      //position isnt relative to array because of realloc
      JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array insert 1"));
      JSON_ASSERT(position <= array + mysize, JSON_TEXT("position is above the end of the array insert 1"));
      {
        #ifdef JSON_LIBRARY
          iteratorKeeper ik(this, position);
        #else
          iteratorKeeper ik(this, position, reverse);
        #endif
        inc();
      }
      std::memmove(position + 1, position, (mysize++ - (position - array)) * sizeof(JSONNode *));
      *position = item;
    }

Here is the call graph for this function:

void jsonChildren::insert ( JSONNode **&  position, JSONNode *  item, bool  reverse = false  )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                                                              {
    #endif
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null insert"));
      //position isnt relative to array because of realloc
      JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array insert 1"));
      JSON_ASSERT(position <= array + mysize, JSON_TEXT("position is above the end of the array insert 1"));
      {
        #ifdef JSON_LIBRARY
          iteratorKeeper ik(this, position);
        #else
          iteratorKeeper ik(this, position, reverse);
        #endif
        inc();
      }
      std::memmove(position + 1, position, (mysize++ - (position - array)) * sizeof(JSONNode *));
      *position = item;
    }

Here is the call graph for this function:

void jsonChildren::insert ( JSONNode **&  position, JSONNode **  items, json_index_t  num  )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                                                          {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null insert 2"));
      JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array insert 2"));
      JSON_ASSERT(position <= array + mysize, JSON_TEXT("position is above the end of the array insert 2"));
      {
        iteratorKeeper ik(this, position);
        inc(num);
      }
      const size_t ptrs = ((JSONNode **)(array + mysize)) - position;
      std::memmove(position + num, position, ptrs * sizeof(JSONNode *));
      std::memcpy(position, items, num * sizeof(JSONNode *));
      mysize += num;
    }

Here is the call graph for this function:

void jsonChildren::insert ( JSONNode **&  position, JSONNode **  items, json_index_t  num  )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                                                          {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null insert 2"));
      JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array insert 2"));
      JSON_ASSERT(position <= array + mysize, JSON_TEXT("position is above the end of the array insert 2"));
      {
        iteratorKeeper ik(this, position);
        inc(num);
      }
      const size_t ptrs = ((JSONNode **)(array + mysize)) - position;
      std::memmove(position + num, position, ptrs * sizeof(JSONNode *));
      std::memcpy(position, items, num * sizeof(JSONNode *));
      mysize += num;
    }

Here is the call graph for this function:

static jsonChildren* jsonChildren::newChildren ( void  )

inlinestatic

References jsonChildren().

Referenced by internalJSONNode::internalJSONNode().

                                                   {
      #ifdef JSON_MEMORY_CALLBACKS
        return new(json_malloc<jsonChildren>(1)) jsonChildren();
      #else
        return new jsonChildren();
      #endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static jsonChildren* jsonChildren::newChildren ( void  )

inlinestatic

References jsonChildren().

                                                   {
      #ifdef JSON_MEMORY_CALLBACKS
        return new(json_malloc<jsonChildren>(1)) jsonChildren();
      #else
        return new jsonChildren();
      #endif
    }

Here is the call graph for this function:

jsonChildren& jsonChildren::operator=

(

const jsonChildren &

)

jsonChildren& jsonChildren::operator=

(

const jsonChildren &

)

JSONNode* jsonChildren::operator[] ( json_index_t  position ) const

inline

References array, JSON_ASSERT, JSON_TEXT, mycapacity, and mysize.

                                                                            {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null []"));
      JSON_ASSERT(position < mysize, JSON_TEXT("Using [] out of bounds"));
      JSON_ASSERT(position < mycapacity, JSON_TEXT("Using [] out of bounds"));
      JSON_ASSERT(array != 0, JSON_TEXT("Array is null"));
      return array[position];
    }

JSONNode* jsonChildren::operator[] ( json_index_t  position ) const

inline

References array, JSON_ASSERT, JSON_TEXT, mycapacity, and mysize.

                                                                            {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null []"));
      JSON_ASSERT(position < mysize, JSON_TEXT("Using [] out of bounds"));
      JSON_ASSERT(position < mycapacity, JSON_TEXT("Using [] out of bounds"));
      JSON_ASSERT(array != 0, JSON_TEXT("Array is null"));
      return array[position];
    }

void jsonChildren::push_back ( JSONNode *  item )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                 {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null push_back"));
      inc();
      array[mysize++] = item;
    }

Here is the call graph for this function:

void jsonChildren::push_back ( JSONNode *  item )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                 {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null push_back"));
      inc();
      array[mysize++] = item;
    }

Here is the call graph for this function:

void jsonChildren::push_front ( JSONNode *  item )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                  {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null push_front"));
      inc();
      std::memmove(array + 1, array, mysize++ * sizeof(JSONNode *));
      array[0] = item;
    }

Here is the call graph for this function:

void jsonChildren::push_front ( JSONNode *  item )

inline

References array, inc(), JSON_ASSERT, JSON_TEXT, and mysize.

                                                  {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null push_front"));
      inc();
      std::memmove(array + 1, array, mysize++ * sizeof(JSONNode *));
      array[0] = item;
    }

Here is the call graph for this function:

void jsonChildren::reserve ( json_index_t  amount )

inline

References array, JSON_ASSERT, JSON_TEXT, mycapacity, and mysize.

                                                          {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null reserve"));
      JSON_ASSERT(array == 0, JSON_TEXT("reserve is not meant to expand a preexisting array"));
      JSON_ASSERT(mycapacity == 0, JSON_TEXT("reservec is not meant to expand a preexisting array"));
      JSON_ASSERT(mysize == 0, JSON_TEXT("reserves is not meant to expand a preexisting array"));
      array = json_malloc<JSONNode*>(mycapacity = amount);
    }

void jsonChildren::reserve ( json_index_t  amount )

inline

References array, JSON_ASSERT, JSON_TEXT, mycapacity, and mysize.

                                                          {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null reserve"));
      JSON_ASSERT(array == 0, JSON_TEXT("reserve is not meant to expand a preexisting array"));
      JSON_ASSERT(mycapacity == 0, JSON_TEXT("reservec is not meant to expand a preexisting array"));
      JSON_ASSERT(mysize == 0, JSON_TEXT("reserves is not meant to expand a preexisting array"));
      array = json_malloc<JSONNode*>(mycapacity = amount);
    }

void jsonChildren::reserve2 ( jsonChildren *&  mine, json_index_t  amount  )

static

Referenced by internalJSONNode::reserve().

                                                                                  {
    if (mine -> array != 0){
      if (mine -> mycapacity < amount){
        mine -> inc(amount - mine -> mycapacity);
        #ifdef JSON_LESS_MEMORY
          mine = jsonChildren_Reserved::newChildren_Reserved(mine, amount);
        #endif
      }
    } else {
      mine -> reserve(amount);
    }
}

Here is the caller graph for this function:

static void jsonChildren::reserve2 ( jsonChildren *&  mine, json_index_t  amount  )

static

childrenVirtual void jsonChildren::shrink ( )

inline

References array, JSON_ASSERT, JSON_TEXT, json_unlikely, mycapacity, and mysize.

                                                      {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null shrink"));
      if (json_unlikely(mysize == 0)){  //size is zero, we should completely free the array
        libjson_free<JSONNode*>(array);  //free does checks for a null pointer, so don't bother checking
        array = 0;
      #ifdef JSON_LESS_MEMORY
        } else {  //need to shrink it, using realloc
          JSON_ASSERT(array != 0, JSON_TEXT("shrinking a null array that is not size 0"));
          array = json_realloc<JSONNode*>(array, mysize);
      #endif
      }
      mycapacity = mysize;
    }

childrenVirtual void jsonChildren::shrink ( )

inline

References array, JSON_ASSERT, JSON_TEXT, json_unlikely, mycapacity, and mysize.

Referenced by erase().

                                                      {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null shrink"));
      if (json_unlikely(mysize == 0)){  //size is zero, we should completely free the array
        libjson_free<JSONNode*>(array);  //free does checks for a null pointer, so don't bother checking
        array = 0;
      #ifdef JSON_LESS_MEMORY
        } else {  //need to shrink it, using realloc
          JSON_ASSERT(array != 0, JSON_TEXT("shrinking a null array that is not size 0"));
          array = json_realloc<JSONNode*>(array, mysize);
      #endif
      }
      mycapacity = mysize;
    }

Here is the caller graph for this function:

json_index_t jsonChildren::size ( void  ) const

inline

References JSON_ASSERT, JSON_TEXT, and mysize.

                                                  {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null size"));
      return mysize;
    }

json_index_t jsonChildren::size ( void  ) const

inline

References JSON_ASSERT, JSON_TEXT, and mysize.

                                                  {
      JSON_ASSERT(this != 0, JSON_TEXT("Children is null size"));
      return mysize;
    }

Member Data Documentation

JSONNode ** jsonChildren::array

Referenced by begin(), clear(), end(), erase(), inc(), insert(), operator[](), push_back(), push_front(), reserve(), shrink(), and ~jsonChildren().

json_index_t jsonChildren::mycapacity

Referenced by capacity(), clear(), inc(), operator[](), reserve(), and shrink().

json_index_t jsonChildren::mysize

Referenced by clear(), empty(), end(), erase(), inc(), insert(), operator[](), push_back(), push_front(), reserve(), shrink(), size(), and jsonChildren::iteratorKeeper::~iteratorKeeper().

---

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

• Documentation/Operator-Console/JSON/JSONChildren.h
• Documentation/Operator-Console/JSON/JSONChildren.cpp