jsonval.cpp

Go to the documentation of this file.

 
// Name:        jsonval.cpp
// Purpose:     the wxJSON class that holds a JSON value
// Author:      Luciano Cattani
// Created:     2007/10/01
// RCS-ID:      $Id: jsonval.cpp,v 1.12 2008/03/06 10:25:18 luccat Exp $
// Copyright:   (c) 2007 Luciano Cattani
// Licence:     wxWidgets licence
 
#ifdef NDEBUG
// make wxLogTrace a noop if no debug set, it's really slow
// must be defined before including debug.h
#define wxDEBUG_LEVEL 0
#endif
 
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
 
#ifdef __BORLANDC__
#pragma hdrstop
#endif
 
#include <wx/log.h>
#include <wx/debug.h>
#include <wx/arrimpl.cpp>
 
#include <wx/jsonval.h>
 
WX_DEFINE_OBJARRAY(wxJSONInternalArray);
 
#if wxCHECK_VERSION(3, 0, 0)
#define compatibleLongLongFmtSpec _T(wxLongLongFmtSpec)
#else
#define compatibleLongLongFmtSpec wxLongLongFmtSpec
#endif
 
// the trace mask used in wxLogTrace() function
// static const wxChar* traceMask = _T("jsonval");
#if wxDEBUG_LEVEL > 0
static const wxChar* traceMask = _T("jsonval");
static const wxChar* compareTraceMask = _T("sameas");
static const wxChar* cowTraceMask = _T("traceCOW" );
#endif
 
/*******************************************************************
 
            class wxJSONRefData
 
*******************************************************************/
 
#if defined(WXJSON_USE_VALUE_COUNTER)
// The progressive counter (used for debugging only)
int wxJSONRefData::sm_progr = 1;
#endif
 
wxJSONRefData::wxJSONRefData() {
  m_lineNo = -1;
  m_refCount = 1;
  m_memBuff = nullptr;
 
#if defined(WXJSON_USE_VALUE_COUNTER)
  m_progr = sm_progr;
  ++sm_progr;
  wxLogTrace(traceMask, _T("(%s) JSON refData ctor progr=%d"),
             __PRETTY_FUNCTION__, m_progr);
#endif
}
 
// Dtor
wxJSONRefData::~wxJSONRefData() {
  if (m_memBuff) {
    delete m_memBuff;
  }
}
 
// Return the number of objects that reference this data.
int wxJSONRefData::GetRefCount() const { return m_refCount; }
 
/*******************************************************************
 
            class wxJSONValue
 
*******************************************************************/
 
#if defined(WXJSON_USE_VALUE_COUNTER)
// The progressive counter (used for debugging only)
int wxJSONValue::sm_progr = 1;
#endif
 
 
wxJSONValue::wxJSONValue() {
  m_refData = nullptr;
  Init(wxJSONTYPE_NULL);
}
 
 
wxJSONRefData* wxJSONValue::Init(wxJSONType type) {
  wxJSONRefData* data = GetRefData();
  if (data != 0) {
    UnRef();
  }
 
  // we allocate a new instance of the referenced data
  data = new wxJSONRefData();
  wxJSON_ASSERT(data);
 
  // in release builds we do not have ASSERT so we check 'data' before
  // using it
  if (data) {
    data->m_type = type;
    data->m_commentPos = wxJSONVALUE_COMMENT_BEFORE;
  }
  SetRefData(data);
 
#if defined(WXJSON_USE_VALUE_COUNTER)
  m_progr = sm_progr;
  ++sm_progr;
  wxLogTrace(cowTraceMask, _T("(%s) Init a new object progr=%d"),
             __PRETTY_FUNCTION__, m_progr);
#endif
  return data;
}
 
wxJSONValue::wxJSONValue(wxJSONType type) {
  m_refData = nullptr;
  Init(type);
}
 
wxJSONValue::wxJSONValue(int i) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_INT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    // the 'VAL_INT' macro expands to 'm_valLong' or 'm_valInt64' depending
    // on 64-bits integer support being enabled on not
    data->m_value.VAL_INT = i;
  }
}
 
wxJSONValue::wxJSONValue(unsigned int ui) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_UINT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    // the 'VAL_UINT' macro expands to 'm_valULong' or 'm_valUInt64' depending
    // on 64-bits integer support being enabled on not
    data->m_value.VAL_UINT = ui;
  }
}
 
wxJSONValue::wxJSONValue(short int i) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_INT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    // the 'VAL_INT' macro expands to 'm_valLong' or 'm_valInt64' depending
    // on 64-bits integer support being enabled on not
    data->m_value.VAL_INT = i;
  }
}
 
wxJSONValue::wxJSONValue(unsigned short ui) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_UINT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    // the 'VAL_UINT' macro expands to 'm_valULong' or 'm_valUInt64' depending
    // on 64-bits integer support being enabled on not
    data->m_value.VAL_UINT = ui;
  }
}
 
wxJSONValue::wxJSONValue(bool b) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_BOOL);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_value.m_valBool = b;
  }
}
 
wxJSONValue::wxJSONValue(double d) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_DOUBLE);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_value.m_valDouble = d;
  }
}
 
wxJSONValue::wxJSONValue(const wxChar* str) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_CSTRING);
  wxJSON_ASSERT(data);
  if (data != 0) {
#if !defined(WXJSON_USE_CSTRING)
    data->m_type = wxJSONTYPE_STRING;
    data->m_valString.assign(str);
#else
    data->m_value.m_valCString = str;
#endif
  }
}
 
wxJSONValue::wxJSONValue(const wxString& str) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_STRING);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_valString.assign(str);
  }
}
 
wxJSONValue::wxJSONValue(long int l) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_INT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_value.VAL_INT = l;
  }
}
 
wxJSONValue::wxJSONValue(unsigned long int ul) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_UINT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_value.VAL_UINT = ul;
  }
}
 
 
wxJSONValue::wxJSONValue(const wxMemoryBuffer& buff) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_MEMORYBUFF);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_memBuff = new wxMemoryBuffer();
    const void* ptr = buff.GetData();
    size_t buffLen = buff.GetDataLen();
    if (buffLen > 0) {
      data->m_memBuff->AppendData(ptr, buffLen);
    }
  }
}
 
 
wxJSONValue::wxJSONValue(const void* buff, size_t len) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_MEMORYBUFF);
  wxJSON_ASSERT(data);
  if (data != 0 && len > 0) {
    data->m_memBuff = new wxMemoryBuffer();
    data->m_memBuff->AppendData(buff, len);
  }
}
 
 
wxJSONValue::wxJSONValue(const wxJSONValue& other) {
  m_refData = nullptr;
  Ref(other);
 
  // the progressive counter of the ctor is not copied from
  // the other wxJSONValue object: only data is shared, the
  // progressive counter is not shared because this object
  // is a copy of 'other' and it has its own progressive
#if defined(WXJSON_USE_VALUE_COUNTER)
  m_progr = sm_progr;
  ++sm_progr;
  wxLogTrace(cowTraceMask, _T("(%s) Copy ctor - progr=%d other progr=%d"),
             __PRETTY_FUNCTION__, m_progr, other.m_progr);
#endif
}
 
wxJSONValue::~wxJSONValue() { UnRef(); }
 
// functions for retreiving the value type: they are all 'const'
 
 
wxJSONType wxJSONValue::GetType() const {
  wxJSONRefData* data = GetRefData();
  wxJSONType type = wxJSONTYPE_INVALID;
  if (data) {
    type = data->m_type;
 
    // for integers and unsigned ints check the storage requirements
    // note that ints are stored as 'long' or as 'long long'
    switch (type) {
      case wxJSONTYPE_INT:
        // check if the integer fits in a SHORT INT
        if (data->m_value.VAL_INT >= SHORT_MIN &&
            data->m_value.VAL_INT <= SHORT_MAX) {
          type = wxJSONTYPE_SHORT;
        }
        // check if the value fits in LONG INT
        else if (data->m_value.VAL_INT >= LONG_MIN &&
                 data->m_value.VAL_INT <= LONG_MAX) {
          type = wxJSONTYPE_LONG;
        } else {
          type = wxJSONTYPE_INT64;
        }
        break;
 
      case wxJSONTYPE_UINT:
        if (data->m_value.VAL_UINT <= USHORT_MAX) {
          type = wxJSONTYPE_USHORT;
        } else if (data->m_value.VAL_UINT <= ULONG_MAX) {
          type = wxJSONTYPE_ULONG;
        } else {
          type = wxJSONTYPE_UINT64;
        }
        break;
 
      default:
        break;
    }
  }
  return type;
}
 
bool wxJSONValue::IsNull() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_NULL) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsValid() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type != wxJSONTYPE_INVALID) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsInt() const {
  wxJSONType type = GetType();
  bool r = false;
  // if the type is SHORT the value fits into an INT, too
  if (type == wxJSONTYPE_SHORT) {
    r = true;
  } else if (type == wxJSONTYPE_LONG) {
    // in case of LONG, check if the bit width is the same
    if (INT_MAX == LONG_MAX) {
      r = true;
    }
  }
  return r;
}
 
 
bool wxJSONValue::IsShort() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_SHORT) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsUInt() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_USHORT) {
    r = true;
  } else if (type == wxJSONTYPE_ULONG) {
    if (INT_MAX == LONG_MAX) {
      r = true;
    }
  }
  return r;
}
 
 
bool wxJSONValue::IsUShort() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_USHORT) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsLong() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_LONG || type == wxJSONTYPE_SHORT) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsULong() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_ULONG || type == wxJSONTYPE_USHORT) {
    r = true;
  }
  return r;
}
 
bool wxJSONValue::IsBool() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_BOOL) {
    r = true;
  }
  return r;
}
 
bool wxJSONValue::IsDouble() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_DOUBLE) {
    r = true;
  }
  return r;
}
 
bool wxJSONValue::IsString() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_STRING) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsCString() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_CSTRING) {
    r = true;
  }
  return r;
}
 
bool wxJSONValue::IsArray() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_ARRAY) {
    r = true;
  }
  return r;
}
 
bool wxJSONValue::IsObject() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_OBJECT) {
    r = true;
  }
  return r;
}
 
bool wxJSONValue::IsMemoryBuff() const {
  wxJSONType type = GetType();
  bool r = false;
  if (type == wxJSONTYPE_MEMORYBUFF) {
    r = true;
  }
  return r;
}
 
// get the stored value; all these functions are 'const'
 
 
int wxJSONValue::AsInt() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  int i = (int)data->m_value.VAL_INT;
 
  wxJSON_ASSERT(IsInt());
  return i;
}
 
 
bool wxJSONValue::AsBool() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  wxJSON_ASSERT(data->m_type == wxJSONTYPE_BOOL);
  return data->m_value.m_valBool;
}
 
 
double wxJSONValue::AsDouble() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  double d = data->m_value.m_valDouble;
  wxJSON_ASSERT(IsDouble());
  return d;
}
 
 
wxString wxJSONValue::AsString() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  wxString s;
  int size = Size();
  switch (data->m_type) {
    case wxJSONTYPE_STRING:
      s.assign(data->m_valString);
      break;
    case wxJSONTYPE_CSTRING:
      s.assign(data->m_value.m_valCString);
      break;
    case wxJSONTYPE_INT:
#if defined(wxJSON_64BIT_INT)
      s.Printf(_T("%") compatibleLongLongFmtSpec _T("i"),
               data->m_value.m_valInt64);
#else
      s.Printf(_T("%ld"), data->m_value.m_valLong);
#endif
      break;
    case wxJSONTYPE_UINT:
#if defined(wxJSON_64BIT_INT)
      s.Printf(_T("%") compatibleLongLongFmtSpec _T("u"),
               data->m_value.m_valUInt64);
#else
      s.Printf(_T("%lu"), data->m_value.m_valULong);
#endif
      break;
    case wxJSONTYPE_DOUBLE:
      s.Printf(_T("%.10g"), data->m_value.m_valDouble);
      break;
    case wxJSONTYPE_BOOL:
      s.assign((data->m_value.m_valBool ? _T("true") : _T("false")));
      break;
    case wxJSONTYPE_NULL:
      s.assign(_T( "null"));
      break;
    case wxJSONTYPE_INVALID:
      s.assign(_T( "<invalid>"));
      break;
    case wxJSONTYPE_ARRAY:
      s.Printf(_T("[%d]"), size);
      break;
    case wxJSONTYPE_OBJECT:
      s.Printf(_T("{%d}"), size);
      break;
    case wxJSONTYPE_MEMORYBUFF:
      s = MemoryBuffToString(*(data->m_memBuff), 5);
      break;
    default:
      s.assign(_T( "wxJSONValue::AsString(): Unknown JSON type \'"));
      s.append(TypeToString(data->m_type));
      s.append(_T( "\'" ));
      wxFAIL_MSG(s);
      break;
  }
  return s;
}
 
 
const wxChar* wxJSONValue::AsCString() const {
  const wxChar* s = nullptr;
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  switch (data->m_type) {
    case wxJSONTYPE_CSTRING:
      s = data->m_value.m_valCString;
      break;
    case wxJSONTYPE_STRING:
      s = data->m_valString.c_str();
      break;
    default:
      break;
  }
  return s;
}
 
 
unsigned int wxJSONValue::AsUInt() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  unsigned int ui = (unsigned)data->m_value.VAL_UINT;
 
  wxJSON_ASSERT(IsUInt());
  return ui;
}
 
 
long int wxJSONValue::AsLong() const {
  long int l;
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  l = (long)data->m_value.VAL_INT;
 
  wxJSON_ASSERT(IsLong());
  return l;
}
 
 
unsigned long int wxJSONValue::AsULong() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  unsigned long int ul = (unsigned long)data->m_value.VAL_UINT;
 
  wxJSON_ASSERT(IsULong());  // expands only in debug builds
  return ul;
}
 
 
short int wxJSONValue::AsShort() const {
  short int i;
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  i = (short)data->m_value.VAL_INT;
 
  wxJSON_ASSERT(IsShort());
  return i;
}
 
 
unsigned short wxJSONValue::AsUShort() const {
  unsigned short ui;
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  ui = (unsigned short)data->m_value.VAL_UINT;
 
  wxJSON_ASSERT(IsUShort());
  return ui;
}
 
 
bool wxJSONValue::AsInt(int& i) const {
  bool r = false;
  if (IsInt()) {
    i = AsInt();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsUInt(unsigned int& ui) const {
  bool r = false;
  if (IsUInt()) {
    ui = AsUInt();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsShort(short int& s) const {
  bool r = false;
  if (IsShort()) {
    s = AsShort();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsUShort(unsigned short& us) const {
  bool r = false;
  if (IsUShort()) {
    us = AsUShort();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsLong(long int& l) const {
  bool r = false;
  if (IsLong()) {
    l = AsLong();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsULong(unsigned long& ul) const {
  bool r = false;
  if (IsULong()) {
    ul = AsULong();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsBool(bool& b) const {
  bool r = false;
  if (IsBool()) {
    b = AsBool();
    r = true;
  }
  return r;
}
 
bool wxJSONValue::AsDouble(double& d) const {
  bool r = false;
  if (IsDouble()) {
    d = AsDouble();
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::AsString(wxString& str) const {
  bool r = IsString();
  if (r) {
    str = AsString();
  }
  return r;
}
 
bool wxJSONValue::AsCString(wxChar* ch) const {
  bool r = IsCString();
  if (r) {
    ch = (wxChar*)AsCString();
  }
  return r;
}
 
 
wxMemoryBuffer wxJSONValue::AsMemoryBuff() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  wxMemoryBuffer buff;
  if (data->m_memBuff) {
    buff = *(data->m_memBuff);
  }
 
  wxJSON_ASSERT(IsMemoryBuff());
  return buff;
}
 
 
bool wxJSONValue::AsMemoryBuff(wxMemoryBuffer& buff) const {
  bool r = IsMemoryBuff();
  if (r) {
    buff = AsMemoryBuff();
  }
  return r;
}
 
// internal use
 
 
const wxJSONInternalMap* wxJSONValue::AsMap() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  const wxJSONInternalMap* v = nullptr;
  if (data->m_type == wxJSONTYPE_OBJECT) {
    v = &(data->m_valMap);
  }
  return v;
}
 
 
const wxJSONInternalArray* wxJSONValue::AsArray() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  const wxJSONInternalArray* v = nullptr;
  if (data->m_type == wxJSONTYPE_ARRAY) {
    v = &(data->m_valArray);
  }
  return v;
}
 
// retrieve the members and other info
 
 
bool wxJSONValue::HasMember(unsigned index) const {
  bool r = false;
  int size = Size();
  if (index < (unsigned)size) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::HasMember(const wxString& key) const {
  bool r = false;
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  if (data && data->m_type == wxJSONTYPE_OBJECT) {
    wxJSONInternalMap::iterator it = data->m_valMap.find(key);
    if (it != data->m_valMap.end()) {
      r = true;
    }
  }
  return r;
}
 
 
int wxJSONValue::Size() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  int size = -1;
  if (data->m_type == wxJSONTYPE_ARRAY) {
    size = (int)data->m_valArray.GetCount();
  }
  if (data->m_type == wxJSONTYPE_OBJECT) {
    size = (int)data->m_valMap.size();
  }
  return size;
}
 
 
wxArrayString wxJSONValue::GetMemberNames() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  wxJSON_ASSERT(data->m_type == wxJSONTYPE_OBJECT);
 
  wxArrayString arr;
  if (data->m_type == wxJSONTYPE_OBJECT) {
    wxJSONInternalMap::iterator it;
    for (it = data->m_valMap.begin(); it != data->m_valMap.end(); it++) {
      arr.Add(it->first);
    }
  }
  return arr;
}
 
// appending items, resizing and deleting items
// NOTE: these functions are not 'const' so we have to call
// the COW() function before accessing data
 
 
wxJSONValue& wxJSONValue::Append(const wxJSONValue& value) {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
  if (data->m_type != wxJSONTYPE_ARRAY) {
    // we have to change the type of the actual object to the array type
    SetType(wxJSONTYPE_ARRAY);
  }
  // we add the wxJSONValue object to the wxObjArray: note that the
  // array makes a copy of the JSON-value object by calling its
  // copy ctor thus using reference count
  data->m_valArray.Add(value);
  wxJSONValue& v = data->m_valArray.Last();
  return v;
}
 
wxJSONValue& wxJSONValue::Append(int i) {
  wxJSONValue v(i);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(short int i) {
  wxJSONValue v(i);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(long int l) {
  wxJSONValue v(l);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(bool b) {
  wxJSONValue v(b);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(unsigned int ui) {
  wxJSONValue v(ui);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(unsigned short ui) {
  wxJSONValue v(ui);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(unsigned long ul) {
  wxJSONValue v(ul);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(double d) {
  wxJSONValue v(d);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(const wxChar* str) {
  wxJSONValue v(str);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(const wxString& str) {
  wxJSONValue v(str);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(const wxMemoryBuffer& buff) {
  wxJSONValue v(buff);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(const void* buff, size_t len) {
  wxJSONValue v(buff, len);
  wxJSONValue& r = Append(v);
  return r;
}
 
 
bool wxJSONValue::Cat(const wxString& str) {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  bool r = false;
  if (data->m_type == wxJSONTYPE_STRING) {
    wxJSONRefData* data = COW();
    wxJSON_ASSERT(data);
    data->m_valString.append(str);
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::Cat(const wxMemoryBuffer& buff) {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  bool r = false;
  if (data->m_type == wxJSONTYPE_MEMORYBUFF) {
    wxJSONRefData* data = COW();
    wxJSON_ASSERT(data);
    data->m_memBuff->AppendData(buff.GetData(), buff.GetDataLen());
    r = true;
  }
  return r;
}
 
bool wxJSONValue::Cat(const wxChar* str) {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  bool r = false;
  if (data->m_type == wxJSONTYPE_STRING) {
    wxJSONRefData* data = COW();
    wxJSON_ASSERT(data);
    data->m_valString.append(str);
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::Remove(int index) {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
 
  bool r = false;
  if (data->m_type == wxJSONTYPE_ARRAY) {
    data->m_valArray.RemoveAt(index);
    r = true;
  }
  return r;
}
 
bool wxJSONValue::Remove(const wxString& key) {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
 
  bool r = false;
  if (data->m_type == wxJSONTYPE_OBJECT) {
    wxJSONInternalMap::size_type count = data->m_valMap.erase(key);
    if (count > 0) {
      r = true;
    }
  }
  return r;
}
 
 
void wxJSONValue::Clear() {
  UnRef();
  SetType(wxJSONTYPE_INVALID);
}
 
// retrieve an item
 
 
wxJSONValue& wxJSONValue::Item(unsigned index) {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
 
  if (data->m_type != wxJSONTYPE_ARRAY) {
    data = SetType(wxJSONTYPE_ARRAY);
  }
  int size = Size();
  wxJSON_ASSERT(size >= 0);
  // if the desired element does not yet exist, we create as many
  // elements as needed; the new values will be 'null' values
  if (index >= (unsigned)size) {
    wxJSONValue v(wxJSONTYPE_NULL);
    int missing = index - size + 1;
    data->m_valArray.Add(v, missing);
  }
  return data->m_valArray.Item(index);
}
 
 
wxJSONValue& wxJSONValue::Item(const wxString& key) {
  wxLogTrace(traceMask, _T("(%s) searched key=\'%s\'"), __PRETTY_FUNCTION__,
             key.c_str());
#if !wxCHECK_VERSION(2, 9, 0)
  wxLogTrace(traceMask, _T("(%s) actual object: %s"), __PRETTY_FUNCTION__,
             GetInfo().c_str());
#endif
 
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
 
  if (data->m_type != wxJSONTYPE_OBJECT) {
    // deletes the contained value;
    data = SetType(wxJSONTYPE_OBJECT);
    return data->m_valMap[key];
  }
  wxLogTrace(traceMask, _T("(%s) searching key \'%s' in the actual object"),
             __PRETTY_FUNCTION__, key.c_str());
  return data->m_valMap[key];
}
 
 
wxJSONValue wxJSONValue::ItemAt(unsigned index) const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxJSONValue v(wxJSONTYPE_INVALID);
  if (data->m_type == wxJSONTYPE_ARRAY) {
    int size = Size();
    wxJSON_ASSERT(size >= 0);
    if (index < (unsigned)size) {
      v = data->m_valArray.Item(index);
    }
  }
  return v;
}
 
 
wxJSONValue wxJSONValue::ItemAt(const wxString& key) const {
  wxLogTrace(traceMask, _T("(%s) searched key=\'%s\'"), __PRETTY_FUNCTION__,
             key.c_str());
  wxLogTrace(traceMask, _T("(%s) actual object: %s"), __PRETTY_FUNCTION__,
             GetInfo().c_str());
 
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxJSONValue v(wxJSONTYPE_INVALID);
  if (data->m_type == wxJSONTYPE_OBJECT) {
    wxJSONInternalMap::const_iterator it = data->m_valMap.find(key);
    if (it != data->m_valMap.end()) {
      v = it->second;
    }
  }
  return v;
}
 
 
wxJSONValue& wxJSONValue::operator[](unsigned index) {
  wxJSONValue& v = Item(index);
  return v;
}
 
 
wxJSONValue& wxJSONValue::operator[](const wxString& key) {
  wxJSONValue& v = Item(key);
  return v;
}
 
//
// assignment operators
// note that reference counting is only used if the original
// value is a wxJSONValue object
// in all other cases, the operator= function deletes the old
// content and assigns the new one
 
 
wxJSONValue& wxJSONValue::operator=(int i) {
  wxJSONRefData* data = SetType(wxJSONTYPE_INT);
  data->m_value.VAL_INT = i;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(bool b) {
  wxJSONRefData* data = SetType(wxJSONTYPE_BOOL);
  data->m_value.m_valBool = b;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(unsigned int ui) {
  wxJSONRefData* data = SetType(wxJSONTYPE_UINT);
  data->m_value.VAL_UINT = ui;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(long l) {
  wxJSONRefData* data = SetType(wxJSONTYPE_INT);
  data->m_value.VAL_INT = l;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(unsigned long ul) {
  wxJSONRefData* data = SetType(wxJSONTYPE_UINT);
  data->m_value.VAL_UINT = ul;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(short i) {
  wxJSONRefData* data = SetType(wxJSONTYPE_INT);
  data->m_value.VAL_INT = i;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(unsigned short ui) {
  wxJSONRefData* data = SetType(wxJSONTYPE_UINT);
  data->m_value.VAL_UINT = ui;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(double d) {
  wxJSONRefData* data = SetType(wxJSONTYPE_DOUBLE);
  data->m_value.m_valDouble = d;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(const wxChar* str) {
  wxJSONRefData* data = SetType(wxJSONTYPE_CSTRING);
  data->m_value.m_valCString = str;
#if !defined(WXJSON_USE_CSTRING)
  data->m_type = wxJSONTYPE_STRING;
  data->m_valString.assign(str);
#endif
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(const wxString& str) {
  wxJSONRefData* data = SetType(wxJSONTYPE_STRING);
  data->m_valString.assign(str);
  return *this;
}
 
 
wxJSONValue& wxJSONValue::operator=(const wxMemoryBuffer& buff) {
  wxJSONRefData* data = SetType(wxJSONTYPE_MEMORYBUFF);
  data->m_memBuff = new wxMemoryBuffer();
  const void* ptr = buff.GetData();
  size_t len = buff.GetDataLen();
  if (data->m_memBuff && len) {
    data->m_memBuff->AppendData(ptr, len);
  }
  return *this;
}
 
 
wxJSONValue& wxJSONValue::operator=(const wxJSONValue& other) {
  Ref(other);
  return *this;
}
 
// finding elements
 
 
wxJSONValue wxJSONValue::Get(const wxString& key,
                             const wxJSONValue& defaultValue) const {
  // NOTE: this function does many wxJSONValue copies.
  // so implementing COW is a good thing
 
  // this is the first copy (the default value)
  wxJSONValue v(defaultValue);
 
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  if (data->m_type == wxJSONTYPE_OBJECT) {
    wxJSONInternalMap::iterator it = data->m_valMap.find(key);
    if (it != data->m_valMap.end()) {
      v = it->second;
    }
  }
  return v;
}
 
// protected functions
 
 
wxJSONValue* wxJSONValue::Find(unsigned index) const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxJSONValue* vp = nullptr;
 
  if (data->m_type == wxJSONTYPE_ARRAY) {
    size_t size = data->m_valArray.GetCount();
    if (index < size) {
      vp = &(data->m_valArray.Item(index));
    }
  }
  return vp;
}
 
 
wxJSONValue* wxJSONValue::Find(const wxString& key) const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxJSONValue* vp = nullptr;
 
  if (data->m_type == wxJSONTYPE_OBJECT) {
    wxJSONInternalMap::iterator it = data->m_valMap.find(key);
    if (it != data->m_valMap.end()) {
      vp = &(it->second);
    }
  }
  return vp;
}
 
 
wxString wxJSONValue::TypeToString(wxJSONType type) {
  static const wxChar* str[] = {
      _T( "wxJSONTYPE_INVALID" ),     // 0
      _T( "wxJSONTYPE_NULL" ),        // 1
      _T( "wxJSONTYPE_INT" ),         // 2
      _T( "wxJSONTYPE_UINT" ),        // 3
      _T( "wxJSONTYPE_DOUBLE" ),      // 4
      _T( "wxJSONTYPE_STRING" ),      // 5
      _T( "wxJSONTYPE_CSTRING" ),     // 6
      _T( "wxJSONTYPE_BOOL" ),        // 7
      _T( "wxJSONTYPE_ARRAY" ),       // 8
      _T( "wxJSONTYPE_OBJECT" ),      // 9
      _T( "wxJSONTYPE_LONG" ),        // 10
      _T( "wxJSONTYPE_INT64" ),       // 11
      _T( "wxJSONTYPE_ULONG" ),       // 12
      _T( "wxJSONTYPE_UINT64" ),      // 13
      _T( "wxJSONTYPE_SHORT" ),       // 14
      _T( "wxJSONTYPE_USHORT" ),      // 15
      _T( "wxJSONTYPE_MEMORYBUFF" ),  // 16
  };
 
  wxString s;
  int idx = (int)type;
  if (idx >= 0 && idx < 17) {
    s = str[idx];
  }
  return s;
}
 
 
wxString wxJSONValue::Dump(bool deep, int indent) const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxJSONType type = GetType();
 
  wxString s;
  if (indent > 0) {
    s.append(indent, ' ');
  }
 
  wxString s1;
  wxString s2;
#if defined(WXJSON_USE_VALUE_COUNTER)
  s1.Printf(_T("Object: Progr=%d Type=%s Size=%d comments=%d\n"), m_progr,
            TypeToString(type).c_str(), Size(), data->m_comments.GetCount());
  s2.Printf(_T("      : RefData=%p Progr=%d Num shares=%d\n"), data,
            data->m_progr, data->GetRefCount());
#else
  s1.Printf(_T("Object: Type=%s Size=%d comments=%d\n"),
            TypeToString(type).c_str(), Size(), data->m_comments.GetCount());
  s2.Printf(_T("      : RefData=%p Num shares=%d\n"), data,
            data->GetRefCount());
#endif
  s.append(s1);
  if (indent > 0) {
    s.append(indent, ' ');
  }
  s.append(s2);
 
  wxString sub;
 
  // if we have to do a deep dump, we call the Dump() function for
  // every sub-item
  if (deep) {
    indent += 3;
    const wxJSONInternalMap* map;
    int size;
    ;
    wxJSONInternalMap::const_iterator it;
    switch (type) {
      case wxJSONTYPE_OBJECT:
        map = AsMap();
        size = Size();
        for (it = map->begin(); it != map->end(); ++it) {
          const wxJSONValue& v = it->second;
          sub = v.Dump(true, indent);
          s.append(sub);
        }
        break;
      case wxJSONTYPE_ARRAY:
        size = Size();
        for (int i = 0; i < size; i++) {
          const wxJSONValue* v = Find(i);
          wxJSON_ASSERT(v);
          sub = v->Dump(true, indent);
          s.append(sub);
        }
        break;
      default:
        break;
    }
  }
  return s;
}
 
 
wxString wxJSONValue::GetInfo() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxString s;
#if defined(WXJSON_USE_VALUE_CONTER)
  s.Printf(_T("Object: Progr=%d Type=%s Size=%d comments=%d\n"), data->m_progr,
           wxJSONValue::TypeToString(data->m_type).c_str(), Size(),
           data->m_comments.GetCount());
#else
  s.Printf(_T("Object: Type=%s Size=%d comments=%d\n"),
           wxJSONValue::TypeToString(data->m_type).c_str(), Size(),
           data->m_comments.GetCount());
#endif
  if (data->m_type == wxJSONTYPE_OBJECT) {
    wxArrayString arr = GetMemberNames();
    for (unsigned int i = 0; i < arr.size(); i++) {
      s.append(_T("    Member name: "));
      s.append(arr[i]);
      s.append(_T("\n"));
    }
  }
  return s;
}
 
 
bool wxJSONValue::IsSameAs(const wxJSONValue& other) const {
  // this is a recursive function: it calls itself
  // for every 'value' object in an array or map
  bool r = false;
 
  // some variables used in the switch statement
  int size;
  wxJSONInternalMap::const_iterator it;
 
  // get the referenced data for the two objects
  wxJSONRefData* data = GetRefData();
  wxJSONRefData* otherData = other.GetRefData();
 
  if (data == otherData) {
    wxLogTrace(compareTraceMask,
               _T("(%s) objects share the same referenced data - r=TRUE"),
               __PRETTY_FUNCTION__);
    return true;
  }
 
  // if the type does not match the function compares the values if
  // they are of compatible types such as INT, UINT and DOUBLE
  if (data->m_type != otherData->m_type) {
    // if the types are not compatible, returns false
    // otherwise compares the compatible types: INT, UINT and DOUBLE
    double val;
    switch (data->m_type) {
      case wxJSONTYPE_INT:
        if (otherData->m_type == wxJSONTYPE_UINT) {
          // compare the bits and returns true if value is between 0 and
          // LLONG_MAX
          if ((data->m_value.VAL_UINT <= LLONG_MAX) &&
              (data->m_value.VAL_UINT == otherData->m_value.VAL_UINT)) {
            r = true;
          }
        } else if (otherData->m_type == wxJSONTYPE_DOUBLE) {
          val = data->m_value.VAL_INT;
          if (val == otherData->m_value.m_valDouble) {
            r = true;
          }
        } else {
          r = false;
        }
        break;
      case wxJSONTYPE_UINT:
        if (otherData->m_type == wxJSONTYPE_INT) {
          // compare the bits and returns true if value is between 0 and
          // LLONG_MAX
          if ((data->m_value.VAL_UINT <= LLONG_MAX) &&
              (data->m_value.VAL_UINT == otherData->m_value.VAL_UINT)) {
            r = true;
          }
        } else if (otherData->m_type == wxJSONTYPE_DOUBLE) {
          val = data->m_value.VAL_UINT;
          if (val == otherData->m_value.m_valDouble) {
            r = true;
          }
        } else {
          r = false;
        }
        break;
      case wxJSONTYPE_DOUBLE:
        if (otherData->m_type == wxJSONTYPE_INT) {
          val = otherData->m_value.VAL_INT;
          if (val == data->m_value.m_valDouble) {
            r = true;
          }
        } else if (otherData->m_type == wxJSONTYPE_UINT) {
          val = otherData->m_value.VAL_UINT;
          if (val == data->m_value.m_valDouble) {
            r = true;
          }
        } else {
          r = false;
        }
        break;
      default:
        r = false;
        break;
    }
    return r;
  }
 
  // the two objects have the same 'm_type'
 
  // for comparing wxJSONTYPE_CSTRING we use two temporary wxString
  // objects: this is to avoid using strcmp() and wcscmp() which
  // may not be available on all platforms
  wxString s1, s2;
  r = true;
  int r1;
 
  switch (data->m_type) {
    case wxJSONTYPE_INVALID:
    case wxJSONTYPE_NULL:
      // there is no need to compare the values
      break;
    case wxJSONTYPE_INT:
      if (data->m_value.VAL_INT != otherData->m_value.VAL_INT) {
        r = false;
      }
      break;
    case wxJSONTYPE_UINT:
      if (data->m_value.VAL_UINT != otherData->m_value.VAL_UINT) {
        r = false;
      }
      break;
    case wxJSONTYPE_DOUBLE:
      if (data->m_value.m_valDouble != otherData->m_value.m_valDouble) {
        r = false;
      }
      break;
    case wxJSONTYPE_CSTRING:
      s1 = wxString(data->m_value.m_valCString);
      s2 = wxString(otherData->m_value.m_valCString);
      if (s1 != s2) {
        r = false;
      }
      break;
    case wxJSONTYPE_BOOL:
      if (data->m_value.m_valBool != otherData->m_value.m_valBool) {
        r = false;
      }
      break;
    case wxJSONTYPE_STRING:
      if (data->m_valString != otherData->m_valString) {
        r = false;
      }
      break;
    case wxJSONTYPE_MEMORYBUFF:
      // we cannot simply use the operator ==; we need a deep comparison
      r1 = CompareMemoryBuff(*(data->m_memBuff), *(otherData->m_memBuff));
      if (r1 != 0) {
        r = false;
      }
      break;
    case wxJSONTYPE_ARRAY:
      size = Size();
      wxLogTrace(compareTraceMask,
                 _T("(%s) Comparing an array object - size=%d"),
                 __PRETTY_FUNCTION__, size);
 
      if (size != other.Size()) {
        wxLogTrace(compareTraceMask, _T("(%s) Sizes does not match"),
                   __PRETTY_FUNCTION__);
        return false;
      }
      // compares every element in this object with the element of
      // the same index in the 'other' object
      for (int i = 0; i < size; i++) {
        wxLogTrace(compareTraceMask, _T("(%s) Comparing array element=%d"),
                   __PRETTY_FUNCTION__, i);
        wxJSONValue v1 = ItemAt(i);
        wxJSONValue v2 = other.ItemAt(i);
 
        if (!v1.IsSameAs(v2)) {
          return false;
        }
      }
      break;
    case wxJSONTYPE_OBJECT:
      size = Size();
      wxLogTrace(compareTraceMask, _T("(%s) Comparing a map obejct - size=%d"),
                 __PRETTY_FUNCTION__, size);
 
      if (size != other.Size()) {
        wxLogTrace(compareTraceMask,
                   _T("(%s) Comparison failed - sizes does not match"),
                   __PRETTY_FUNCTION__);
        return false;
      }
      // for every key calls itself on the value found in
      // the other object. if 'key' does no exist, returns FALSE
      for (it = data->m_valMap.begin(); it != data->m_valMap.end(); it++) {
        wxString key = it->first;
        wxLogTrace(compareTraceMask, _T("(%s) Comparing map object - key=%s"),
                   __PRETTY_FUNCTION__, key.c_str());
        wxJSONValue otherVal = other.ItemAt(key);
        bool isSame = it->second.IsSameAs(otherVal);
        if (!isSame) {
          wxLogTrace(compareTraceMask,
                     _T("(%s) Comparison failed for the last object"),
                     __PRETTY_FUNCTION__);
          return false;
        }
      }
      break;
    default:
      // should never happen
      wxFAIL_MSG(_T("wxJSONValue::IsSameAs() unexpected wxJSONType"));
      break;
  }
  return r;
}
 
 
int wxJSONValue::AddComment(const wxString& str, int position) {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
 
  wxLogTrace(traceMask, _T("(%s) comment=%s"), __PRETTY_FUNCTION__,
             str.c_str());
  int r = -1;
  int len = str.length();
  if (len < 2) {
    wxLogTrace(traceMask, _T("     error: len < 2"));
    return -1;
  }
  if (str[0] != '/') {
    wxLogTrace(traceMask, _T("     error: does not start with\'/\'"));
    return -1;
  }
  if (str[1] == '/') {  // a C++ comment: check that it ends with '\n'
    wxLogTrace(traceMask, _T("     C++ comment" ));
    if (str.GetChar(len - 1) != '\n') {
      wxString temp(str);
      temp.append(1, '\n');
      data->m_comments.Add(temp);
      wxLogTrace(traceMask, _T("     C++ comment: LF added"));
    } else {
      data->m_comments.Add(str);
    }
    r = data->m_comments.size();
  } else if (str[1] ==
             '*') {  // a C-style comment: check that it ends with '*/'
    wxLogTrace(traceMask, _T("     C-style comment"));
    int lastPos = len - 1;
    wxChar ch = str.GetChar(lastPos);
    // skip leading whitespaces
    while (ch == ' ' || ch == '\n' || ch == '\t') {
      --lastPos;
      ch = str.GetChar(lastPos);
    }
    if (str.GetChar(lastPos) == '/' && str.GetChar(lastPos - 1) == '*') {
      data->m_comments.Add(str);
      r = data->m_comments.size();
    }
  } else {
    wxLogTrace(traceMask, _T("     error: is not a valid comment string"));
    r = -1;
  }
  // if the comment was stored, store the position
  if (r >= 0 && position != wxJSONVALUE_COMMENT_DEFAULT) {
    data->m_commentPos = position;
  }
  return r;
}
 
 
int wxJSONValue::AddComment(const wxArrayString& comments, int position) {
  int siz = comments.GetCount();
  int r = 0;
  for (int i = 0; i < siz; i++) {
    int r2 = AddComment(comments[i], position);
    if (r2 >= 0) {
      ++r;
    }
  }
  return r;
}
 
 
wxString wxJSONValue::GetComment(int idx) const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  wxString s;
  int size = data->m_comments.GetCount();
  if (idx < 0) {
    for (int i = 0; i < size; i++) {
      s.append(data->m_comments[i]);
    }
  } else if (idx < size) {
    s = data->m_comments[idx];
  }
  return s;
}
 
int wxJSONValue::GetCommentCount() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  int d = data->m_comments.GetCount();
  wxLogTrace(traceMask, _T("(%s) comment count=%d"), __PRETTY_FUNCTION__, d);
  return d;
}
 
int wxJSONValue::GetCommentPos() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  return data->m_commentPos;
}
 
const wxArrayString& wxJSONValue::GetCommentArray() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
 
  return data->m_comments;
}
 
void wxJSONValue::ClearComments() {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
 
  data->m_comments.clear();
}
 
 
wxJSONRefData* wxJSONValue::SetType(wxJSONType type) {
  wxJSONRefData* data = GetRefData();
  wxJSONType oldType = GetType();
 
  // check that type is within the allowed range
  wxJSON_ASSERT((type >= wxJSONTYPE_INVALID) &&
                (type <= wxJSONTYPE_MEMORYBUFF));
  if ((type < wxJSONTYPE_INVALID) || (type > wxJSONTYPE_MEMORYBUFF)) {
    type = wxJSONTYPE_INVALID;
  }
 
  // the function unshares the referenced data but does not delete the
  // structure. This is because the wxJSON reader stores comments
  // that apear before the value in a temporary value of type wxJSONTYPE_INVALID
  // which is invalid and, next, it stores the JSON value in the same
  // wxJSONValue object.
  // If we would delete the structure using 'Unref()' we loose the
  // comments
  data = COW();
 
  // do nothing if the actual type is the same as 'type'
  if (type == oldType) {
    return data;
  }
 
  // change the type of the referened structure
  // NOTE: integer types are always stored as the generic integer types
  if (type == wxJSONTYPE_LONG || type == wxJSONTYPE_INT64 ||
      type == wxJSONTYPE_SHORT) {
    type = wxJSONTYPE_INT;
  }
  if (type == wxJSONTYPE_ULONG || type == wxJSONTYPE_UINT64 ||
      type == wxJSONTYPE_USHORT) {
    type = wxJSONTYPE_UINT;
  }
 
  wxJSON_ASSERT(data);
  data->m_type = type;
 
  // clears complex objects of the old type
  switch (oldType) {
    case wxJSONTYPE_STRING:
      data->m_valString.clear();
      break;
    case wxJSONTYPE_ARRAY:
      data->m_valArray.Clear();
      break;
    case wxJSONTYPE_OBJECT:
      data->m_valMap.clear();
      break;
    case wxJSONTYPE_MEMORYBUFF:
      // we first have to delete the actual memory buffer, if any
      if (data->m_memBuff) {
        delete data->m_memBuff;
        data->m_memBuff = 0;
      }
      break;
    default:
      // there is not need to clear primitive types
      break;
  }
 
    // if the WXJSON_USE_CSTRING macro is not defined, the class forces
    // C-string to be stored as wxString objects
#if !defined(WXJSON_USE_CSTRING)
  if (data->m_type == wxJSONTYPE_CSTRING) {
    data->m_type = wxJSONTYPE_STRING;
  }
#endif
  return data;
}
 
 
int wxJSONValue::GetLineNo() const {
  // return ZERO if there is not a referenced data structure
  int n = 0;
  wxJSONRefData* data = GetRefData();
  if (data != 0) {
    n = data->m_lineNo;
  }
  return n;
}
 
void wxJSONValue::SetLineNo(int num) {
  wxJSONRefData* data = COW();
  wxJSON_ASSERT(data);
  data->m_lineNo = num;
}
 
void wxJSONValue::SetRefData(wxJSONRefData* data) { m_refData = data; }
 
void wxJSONValue::Ref(const wxJSONValue& clone) {
  // nothing to be done
  if (m_refData == clone.m_refData) return;
 
  // delete reference to old data
  UnRef();
 
  // reference new data
  if (clone.m_refData) {
    m_refData = clone.m_refData;
    ++(m_refData->m_refCount);
  }
}
 
 
void wxJSONValue::UnRef() {
  if (m_refData) {
    wxASSERT_MSG(m_refData->m_refCount > 0, _T("invalid ref data count"));
 
    if (--m_refData->m_refCount == 0) {
      delete m_refData;
      m_refData = nullptr;
    }
  }
}
 
void wxJSONValue::UnShare() { AllocExclusive(); }
 
 
void wxJSONValue::DeepCopy(const wxJSONValue& other) {
  UnRef();
  wxJSONRefData* data = CloneRefData(other.m_refData);
  SetRefData(data);
}
 
wxJSONRefData* wxJSONValue::GetRefData() const {
  wxJSONRefData* data = m_refData;
  return data;
}
 
 
wxJSONRefData* wxJSONValue::CloneRefData(const wxJSONRefData* otherData) const {
  wxJSON_ASSERT(otherData);
 
  // make a static cast to pointer-to-wxJSONRefData
  const wxJSONRefData* other = otherData;
 
  // allocate a new instance of wxJSONRefData using the default
  // ctor; we cannot use the copy ctor of a wxJSONRefData
  wxJSONRefData* data = new wxJSONRefData();
 
  // copy the referenced data structure's data members
  data->m_type = other->m_type;
  data->m_value = other->m_value;
  data->m_commentPos = other->m_commentPos;
  data->m_comments = other->m_comments;
  data->m_lineNo = other->m_lineNo;
  data->m_valString = other->m_valString;
  data->m_valArray = other->m_valArray;
  data->m_valMap = other->m_valMap;
 
  // if the data contains a wxMemoryBuffer object, then we have
  // to make a deep copy of the buffer by allocating a new one because
  // wxMemoryBuffer is not a copy-on-write structure
  if (other->m_memBuff) {
    data->m_memBuff = new wxMemoryBuffer();
    const void* ptr = data->m_memBuff->GetData();
    size_t len = data->m_memBuff->GetDataLen();
    if (data->m_memBuff && len) {
      data->m_memBuff->AppendData(ptr, len);
    }
  }
 
  wxLogTrace(cowTraceMask, _T("(%s) CloneRefData() PROGR: other=%d data=%d"),
             __PRETTY_FUNCTION__, other->GetRefCount(), data->GetRefCount());
 
  return data;
}
 
 
wxJSONRefData* wxJSONValue::CreateRefData() const {
  wxJSONRefData* data = new wxJSONRefData();
  data->m_type = wxJSONTYPE_INVALID;
  return data;
}
 
 
wxJSONRefData* wxJSONValue::COW() {
  wxJSONRefData* data = GetRefData();
  wxLogTrace(cowTraceMask, _T("(%s) COW() START data=%p data->m_count=%d"),
             __PRETTY_FUNCTION__, data, data->GetRefCount());
  UnShare();
  data = GetRefData();
  wxLogTrace(cowTraceMask, _T("(%s) COW() END data=%p data->m_count=%d"),
             __PRETTY_FUNCTION__, data, data->GetRefCount());
  return GetRefData();
}
 
void wxJSONValue::AllocExclusive() {
  if (!m_refData) {
    m_refData = CreateRefData();
  } else if (m_refData->GetRefCount() > 1) {
    // note that ref is not going to be destroyed in this case
    const wxJSONRefData* ref = m_refData;
    UnRef();
 
    // ... so we can still access it
    m_refData = CloneRefData(ref);
  }
  // else: ref count is 1, we are exclusive owners of m_refData anyhow
 
  wxASSERT_MSG(m_refData && m_refData->GetRefCount() == 1,
               _T("wxObject::AllocExclusive() failed."));
}
 
/*/
 The fucntion returns a string representation of the data contained in the
 memory buffer object \c buff.
 The string is conposed of two hexadecimal digits for every byte contained
 in the memory buffer; bytes are separated by a space character.
 The string starts with the actual lenght of the data enclosed in parenthesis.
 The string will contain \c len bytes if \c len is less than the length
 of the actual data in \c buff.
 Note that the (len) printed in the output referes to the length of the buffer
 which may be greater than the length that has to be printed.
 
 \b Example:
 This is an example of printing a memory buffer object that contains 10 bytes:
 \code
   0x80974653 (10) 00 01 02 03 04 05 06 07 08 09
 \endcode
*/
wxString wxJSONValue::MemoryBuffToString(const wxMemoryBuffer& buff,
                                         size_t len) {
  size_t buffLen = buff.GetDataLen();
  void* ptr = buff.GetData();
  wxString s = MemoryBuffToString(ptr, MIN(buffLen, len), buffLen);
  return s;
}
 
/*/
 The function returns a string representation of the data contained in the
 binary memory buffer pointed to by \c buff for \c len bytes.
 The string is composed of two hexadecimal digits for every byte contained
 in the memory buffer; bytes are separated by a space character.
 The string starts with pointer to binary data followed by the lenght of the
 data enclosed in parenthesis.
 
 \b Example:
 This is an example of printing ten bytes from a memory buffer:
 \code
   0x80974653 (10) 00 01 02 03 04 05 06 07 08 09
 \endcode
 
 @param buff the pointer to the memory buffer data
 @len   the length of the data that has to be printed
 @actualLen the real lenght of the memory buffer that has to be printed
        just afetr the pointer; may be greater than \c len. If this parameter
        is -1 then it is equal to \c len
*/
wxString wxJSONValue::MemoryBuffToString(const void* buff, size_t len,
                                         size_t actualLen) {
  wxString s;
  size_t buffLen = actualLen;
  if (buffLen == (size_t)-1) {
    buffLen = len;
  }
  s.Printf(_T("%p (%u) "), buff, buffLen);
  unsigned char* ptr = (unsigned char*)buff;
  for (unsigned int i = 0; i < len; i++) {
    unsigned char c = *ptr;
    ++ptr;
    // now convert the character
    char c1 = c / 16;
    char c2 = c % 16;
    c1 += '0';
    c2 += '0';
    if (c1 > '9') {
      c1 += 7;
    }
    if (c2 > '9') {
      c2 += 7;
    }
    s.Append(c1, 1);
    s.Append(c2, 1);
    s.Append(' ', 1);  // a space separates the bytes
  }
  return s;
}
 
 
int wxJSONValue::CompareMemoryBuff(const wxMemoryBuffer& buff1,
                                   const wxMemoryBuffer& buff2) {
  int r;
  size_t buff1Len = buff1.GetDataLen();
  size_t buff2Len = buff2.GetDataLen();
  if (buff1Len > buff2Len) {
    r = 1;
  } else if (buff1Len < buff2Len) {
    r = -1;
  } else {
    r = memcmp(buff1.GetData(), buff2.GetData(), buff1Len);
  }
  return r;
}
 
 
int wxJSONValue::CompareMemoryBuff(const wxMemoryBuffer& buff1,
                                   const void* buff2) {
  int r;
  size_t buff1Len = buff1.GetDataLen();
  r = memcmp(buff1.GetData(), buff2, buff1Len);
  return r;
}
 
 
wxMemoryBuffer wxJSONValue::ArrayToMemoryBuff(const wxJSONValue& value) {
  wxMemoryBuffer buff;
  if (value.IsArray()) {
    int len = value.Size();
    for (int i = 0; i < len; i++) {
      short int byte;
      unsigned char c;
      // we do not use opertaor [] because it is not const
      // bool r = value[i].AsShort( byte );
      bool r = value.ItemAt(i).AsShort(byte);
      if (r && (byte >= 0 && byte <= 255)) {
        c = (unsigned char)byte;
        buff.AppendByte(c);
      }
    }
  }
  return buff;
}
 
/*************************************************************************
 
            64-bits integer support
 
*************************************************************************/
 
#if defined(wxJSON_64BIT_INT)
 
wxJSONValue::wxJSONValue(wxInt64 i) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_INT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_value.VAL_INT = i;
  }
}
 
wxJSONValue::wxJSONValue(wxUint64 ui) {
  m_refData = nullptr;
  wxJSONRefData* data = Init(wxJSONTYPE_UINT);
  wxJSON_ASSERT(data);
  if (data != 0) {
    data->m_value.VAL_UINT = ui;
  }
}
 
 
bool wxJSONValue::IsInt32() const {
  bool r = IsLong();
  return r;
}
 
 
bool wxJSONValue::IsUInt32() const {
  bool r = IsULong();
  return r;
}
 
 
bool wxJSONValue::IsInt64() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  bool r = false;
  if (data->m_type == wxJSONTYPE_INT) {
    r = true;
  }
  return r;
}
 
 
bool wxJSONValue::IsUInt64() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  bool r = false;
  if (data->m_type == wxJSONTYPE_UINT) {
    r = true;
  }
  return r;
}
 
 
wxInt32 wxJSONValue::AsInt32() const {
  wxInt32 i;
  i = (wxInt32)AsLong();
  return i;
}
 
 
wxUint32 wxJSONValue::AsUInt32() const {
  wxUint32 ui;
  ui = (wxUint32)AsULong();
  return ui;
}
 
 
wxInt64 wxJSONValue::AsInt64() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  wxInt64 i64 = data->m_value.m_valInt64;
 
  wxJSON_ASSERT(IsInt64());  // exapnds only in debug builds
  return i64;
}
 
 
wxUint64 wxJSONValue::AsUInt64() const {
  wxJSONRefData* data = GetRefData();
  wxJSON_ASSERT(data);
  wxUint64 ui64 = data->m_value.m_valUInt64;
 
  wxJSON_ASSERT(IsUInt64());  // exapnds only in debug builds
  return ui64;
}
 
bool wxJSONValue::AsInt32(wxInt32& i32) const {
  bool r = IsInt32();
  if (r) {
    i32 = AsInt32();
  }
  return r;
}
 
bool wxJSONValue::AsUInt32(wxUint32& ui32) const {
  bool r = IsUInt32();
  if (r) {
    ui32 = AsUInt32();
  }
  return r;
}
 
bool wxJSONValue::AsInt64(wxInt64& i64) const {
  bool r = IsInt64();
  if (r) {
    i64 = AsInt64();
  }
  return r;
}
 
bool wxJSONValue::AsUInt64(wxUint64& ui64) const {
  bool r = IsUInt64();
  if (r) {
    ui64 = AsUInt64();
  }
  return r;
}
 
wxJSONValue& wxJSONValue::Append(wxInt64 i) {
  wxJSONValue v(i);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::Append(wxUint64 ui) {
  wxJSONValue v(ui);
  wxJSONValue& r = Append(v);
  return r;
}
 
wxJSONValue& wxJSONValue::operator=(wxInt64 i) {
  wxJSONRefData* data = SetType(wxJSONTYPE_INT);
  data->m_value.VAL_INT = i;
  return *this;
}
 
wxJSONValue& wxJSONValue::operator=(wxUint64 ui) {
  wxJSONRefData* data = SetType(wxJSONTYPE_UINT);
  data->m_value.VAL_UINT = ui;
  return *this;
}
 
#endif  // defined( wxJSON_64BIT_INT )
 
/*
{
}
*/