// Copyright 2011 Baptiste Lepilleur

// Distributed under MIT license, or public domain if desired and

// recognized in your jurisdiction.

// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE

#if !defined(JSON_IS_AMALGAMATION)

#include <json/assertions.h>

#include <json/value.h>

#include <json/writer.h>

#endif // if !defined(JSON_IS_AMALGAMATION)

#include <math.h>

#include <sstream>

#include <utility>

#include <cstring>

#include <cassert>

#ifdef JSON_USE_CPPTL

#include <cpptl/conststring.h>

#endif

#include <cstddef> // size_t

#define JSON_ASSERT_UNREACHABLE assert(false)

namespace Json {

// This is a walkaround to avoid the static initialization of Value::null.

// kNull must be word-aligned to avoid crashing on ARM. We use an alignment of

// 8 (instead of 4) as a bit of future-proofing.

#if defined(__ARMEL__)

#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))

#else

#define ALIGNAS(byte_alignment)

#endif

static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };

const unsigned char& kNullRef = kNull[0];

const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);

const Value& Value::nullRef = null;

const Int Value::minInt = Int(~(UInt(-1) / 2));

const Int Value::maxInt = Int(UInt(-1) / 2);

const UInt Value::maxUInt = UInt(-1);

#if defined(JSON_HAS_INT64)

const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2));

const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2);

const UInt64 Value::maxUInt64 = UInt64(-1);

// The constant is hard-coded because some compiler have trouble

// converting Value::maxUInt64 to a double correctly (AIX/xlC).

// Assumes that UInt64 is a 64 bits integer.

static const double maxUInt64AsDouble = 18446744073709551615.0;

#endif // defined(JSON_HAS_INT64)

const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2));

const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2);

const LargestUInt Value::maxLargestUInt = LargestUInt(-1);

/// Unknown size marker

static const size_t unknown = (size_t)-1;

#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

template <typename T, typename U>

static inline bool InRange(double d, T min, U max) {

return d >= min && d <= max;

}

#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

static inline double integerToDouble(Json::UInt64 value) {

return static_cast<double>(Int64(value / 2)) * 2.0 + Int64(value & 1);

}

template <typename T> static inline double integerToDouble(T value) {

return static_cast<double>(value);

}

template <typename T, typename U>

static inline bool InRange(double d, T min, U max) {

return d >= integerToDouble(min) && d <= integerToDouble(max);

}

#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

/** Duplicates the specified string value.

* @param value Pointer to the string to duplicate. Must be zero-terminated if

* length is "unknown".

* @param length Length of the value. if equals to unknown, then it will be

* computed using strlen(value).

* @return Pointer on the duplicate instance of string.

*/

static inline char* duplicateStringValue(const char* value,

size_t length = unknown) {

if (length == unknown)

length = strlen(value);

// Avoid an integer overflow in the call to malloc below by limiting length

// to a sane value.

if (length >= (unsigned)Value::maxInt)

length = Value::maxInt - 1;

char* newString = static_cast<char*>(malloc(length + 1));

JSON_ASSERT_MESSAGE(newString != 0,

"in Json::Value::duplicateStringValue(): "

"Failed to allocate string value buffer");

memcpy(newString, value, length);

newString[length] = 0;

return newString;

}

/** Free the string duplicated by duplicateStringValue().

*/

static inline void releaseStringValue(char* value) { free(value); }

} // namespace Json

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// ValueInternals...

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

#if !defined(JSON_IS_AMALGAMATION)

#include "json_valueiterator.inl"

#endif // if !defined(JSON_IS_AMALGAMATION)

namespace Json {

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// class Value::CommentInfo

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

Value::CommentInfo::CommentInfo() : comment_(0) {}

Value::CommentInfo::~CommentInfo() {

if (comment_)

releaseStringValue(comment_);

}

void Value::CommentInfo::setComment(const char* text, size_t len) {

if (comment_) {

releaseStringValue(comment_);

comment_ = 0;

}

JSON_ASSERT(text != 0);

JSON_ASSERT_MESSAGE(

text[0] == '\0' || text[0] == '/',

"in Json::Value::setComment(): Comments must start with /");

// It seems that /**/ style comments are acceptable as well.

comment_ = duplicateStringValue(text, len);

}

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// class Value::CZString

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// Notes: index_ indicates if the string was allocated when

// a string is stored.

Value::CZString::CZString(ArrayIndex index) : cstr_(0), index_(index) {}

Value::CZString::CZString(const char* cstr, DuplicationPolicy allocate)

: cstr_(allocate == duplicate ? duplicateStringValue(cstr) : cstr),

index_(allocate) {}

Value::CZString::CZString(const CZString& other)

: cstr_(other.index_ != noDuplication && other.cstr_ != 0

? duplicateStringValue(other.cstr_)

: other.cstr_),

index_(other.cstr_

? static_cast<ArrayIndex>(other.index_ == noDuplication

? noDuplication : duplicate)

: other.index_) {}

Value::CZString::~CZString() {

if (cstr_ && index_ == duplicate)

releaseStringValue(const_cast<char*>(cstr_));

}

void Value::CZString::swap(CZString& other) {

std::swap(cstr_, other.cstr_);

std::swap(index_, other.index_);

}

Value::CZString& Value::CZString::operator=(CZString other) {

swap(other);

return *this;

}

bool Value::CZString::operator<(const CZString& other) const {

if (cstr_)

return strcmp(cstr_, other.cstr_) < 0;

return index_ < other.index_;

}

bool Value::CZString::operator==(const CZString& other) const {

if (cstr_)

return strcmp(cstr_, other.cstr_) == 0;

return index_ == other.index_;

}

ArrayIndex Value::CZString::index() const { return index_; }

const char* Value::CZString::c_str() const { return cstr_; }

bool Value::CZString::isStaticString() const { return index_ == noDuplication; }

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// class Value::Value

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

/*! \internal Default constructor initialization must be equivalent to:

* memset( this, 0, sizeof(Value) )

* This optimization is used in ValueInternalMap fast allocator.

*/

Value::Value(ValueType type) {

initBasic(type);

switch (type) {

case nullValue:

break;

case intValue:

case uintValue:

value_.int_ = 0;

break;

case realValue:

value_.real_ = 0.0;

break;

case stringValue:

value_.string_ = 0;

break;

case arrayValue:

case objectValue:

value_.map_ = new ObjectValues();

break;

case booleanValue:

value_.bool_ = false;

break;

default:

JSON_ASSERT_UNREACHABLE;

}

}

Value::Value(Int value) {

initBasic(intValue);

value_.int_ = value;

}

Value::Value(UInt value) {

initBasic(uintValue);

value_.uint_ = value;

}

#if defined(JSON_HAS_INT64)

Value::Value(Int64 value) {

initBasic(intValue);

value_.int_ = value;

}

Value::Value(UInt64 value) {

initBasic(uintValue);

value_.uint_ = value;

}

#endif // defined(JSON_HAS_INT64)

Value::Value(double value) {

initBasic(realValue);

value_.real_ = value;

}

Value::Value(const char* value) {

initBasic(stringValue, true);

value_.string_ = duplicateStringValue(value);

}

Value::Value(const char* beginValue, const char* endValue) {

initBasic(stringValue, true);

value_.string_ =

duplicateStringValue(beginValue, (unsigned int)(endValue - beginValue));

}

Value::Value(const std::string& value) {

initBasic(stringValue, true);

value_.string_ =

duplicateStringValue(value.c_str(), (unsigned int)value.length());

}

Value::Value(const StaticString& value) {

initBasic(stringValue);

value_.string_ = const_cast<char*>(value.c_str());

}

#ifdef JSON_USE_CPPTL

Value::Value(const CppTL::ConstString& value) {

initBasic(stringValue, true);

value_.string_ = duplicateStringValue(value, value.length());

}

#endif

Value::Value(bool value) {

initBasic(booleanValue);

value_.bool_ = value;

}

Value::Value(const Value& other)

: type_(other.type_), allocated_(false)

,

comments_(0), start_(other.start_), limit_(other.limit_) {

switch (type_) {

case nullValue:

case intValue:

case uintValue:

case realValue:

case booleanValue:

value_ = other.value_;

break;

case stringValue:

if (other.value_.string_) {

value_.string_ = duplicateStringValue(other.value_.string_);

allocated_ = true;

} else {

value_.string_ = 0;

allocated_ = false;

}

break;

case arrayValue:

case objectValue:

value_.map_ = new ObjectValues(*other.value_.map_);

break;

default:

JSON_ASSERT_UNREACHABLE;

}

if (other.comments_) {

comments_ = new CommentInfo[numberOfCommentPlacement];

for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {

const CommentInfo& otherComment = other.comments_[comment];

if (otherComment.comment_)

comments_[comment].setComment(

otherComment.comment_, strlen(otherComment.comment_));

}

}

}

Value::~Value() {

switch (type_) {

case nullValue:

case intValue:

case uintValue:

case realValue:

case booleanValue:

break;

case stringValue:

if (allocated_)

releaseStringValue(value_.string_);

break;

case arrayValue:

case objectValue:

delete value_.map_;

break;

default:

JSON_ASSERT_UNREACHABLE;

}

if (comments_)

delete[] comments_;

}

Value& Value::operator=(Value other) {

swap(other);

return *this;

}

void Value::swapPayload(Value& other) {

ValueType temp = type_;

type_ = other.type_;

other.type_ = temp;

std::swap(value_, other.value_);

int temp2 = allocated_;

allocated_ = other.allocated_;

other.allocated_ = temp2;

}

void Value::swap(Value& other) {

swapPayload(other);

std::swap(comments_, other.comments_);

std::swap(start_, other.start_);

std::swap(limit_, other.limit_);

}

ValueType Value::type() const { return type_; }

int Value::compare(const Value& other) const {

if (*this < other)

return -1;

if (*this > other)

return 1;

return 0;

}

bool Value::operator<(const Value& other) const {

int typeDelta = type_ - other.type_;

if (typeDelta)

return typeDelta < 0 ? true : false;

switch (type_) {

case nullValue:

return false;

case intValue:

return value_.int_ < other.value_.int_;

case uintValue:

return value_.uint_ < other.value_.uint_;

case realValue:

return value_.real_ < other.value_.real_;

case booleanValue:

return value_.bool_ < other.value_.bool_;

case stringValue:

return (value_.string_ == 0 && other.value_.string_) ||

(other.value_.string_ && value_.string_ &&

strcmp(value_.string_, other.value_.string_) < 0);

case arrayValue:

case objectValue: {

int delta = int(value_.map_->size() - other.value_.map_->size());

if (delta)

return delta < 0;

return (*value_.map_) < (*other.value_.map_);

}

default:

JSON_ASSERT_UNREACHABLE;

}

return false; // unreachable

}

bool Value::operator<=(const Value& other) const { return !(other < *this); }

bool Value::operator>=(const Value& other) const { return !(*this < other); }

bool Value::operator>(const Value& other) const { return other < *this; }

bool Value::operator==(const Value& other) const {

// if ( type_ != other.type_ )

// GCC 2.95.3 says:

// attempt to take address of bit-field structure member `Json::Value::type_'

// Beats me, but a temp solves the problem.

int temp = other.type_;

if (type_ != temp)

return false;

switch (type_) {

case nullValue:

return true;

case intValue:

return value_.int_ == other.value_.int_;

case uintValue:

return value_.uint_ == other.value_.uint_;

case realValue:

return value_.real_ == other.value_.real_;

case booleanValue:

return value_.bool_ == other.value_.bool_;

case stringValue:

return (value_.string_ == other.value_.string_) ||

(other.value_.string_ && value_.string_ &&

strcmp(value_.string_, other.value_.string_) == 0);

case arrayValue:

case objectValue:

return value_.map_->size() == other.value_.map_->size() &&

(*value_.map_) == (*other.value_.map_);

default:

JSON_ASSERT_UNREACHABLE;

}

return false; // unreachable

}

bool Value::operator!=(const Value& other) const { return !(*this == other); }

const char* Value::asCString() const {

JSON_ASSERT_MESSAGE(type_ == stringValue,

"in Json::Value::asCString(): requires stringValue");

return value_.string_;

}

std::string Value::asString() const {

switch (type_) {

case nullValue:

return "";

case stringValue:

return value_.string_ ? value_.string_ : "";

case booleanValue:

return value_.bool_ ? "true" : "false";

case intValue:

return valueToString(value_.int_);

case uintValue:

return valueToString(value_.uint_);

case realValue:

return valueToString(value_.real_);

default:

JSON_FAIL_MESSAGE("Type is not convertible to string");

}

}

#ifdef JSON_USE_CPPTL

CppTL::ConstString Value::asConstString() const {

return CppTL::ConstString(asString().c_str());

}

#endif

Value::Int Value::asInt() const {

switch (type_) {

case intValue:

JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");

return Int(value_.int_);

case uintValue:

JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");

return Int(value_.uint_);

case realValue:

JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),

"double out of Int range");

return Int(value_.real_);

case nullValue:

return 0;

case booleanValue:

return value_.bool_ ? 1 : 0;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to Int.");

}

Value::UInt Value::asUInt() const {

switch (type_) {

case intValue:

JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");

return UInt(value_.int_);

case uintValue:

JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");

return UInt(value_.uint_);

case realValue:

JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),

"double out of UInt range");

return UInt(value_.real_);

case nullValue:

return 0;

case booleanValue:

return value_.bool_ ? 1 : 0;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to UInt.");

}

#if defined(JSON_HAS_INT64)

Value::Int64 Value::asInt64() const {

switch (type_) {

case intValue:

return Int64(value_.int_);

case uintValue:

JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");

return Int64(value_.uint_);

case realValue:

JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),

"double out of Int64 range");

return Int64(value_.real_);

case nullValue:

return 0;

case booleanValue:

return value_.bool_ ? 1 : 0;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to Int64.");

}

Value::UInt64 Value::asUInt64() const {

switch (type_) {

case intValue:

JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");

return UInt64(value_.int_);

case uintValue:

return UInt64(value_.uint_);

case realValue:

JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),

"double out of UInt64 range");

return UInt64(value_.real_);

case nullValue:

return 0;

case booleanValue:

return value_.bool_ ? 1 : 0;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");

}

#endif // if defined(JSON_HAS_INT64)

LargestInt Value::asLargestInt() const {

#if defined(JSON_NO_INT64)

return asInt();

#else

return asInt64();

#endif

}

LargestUInt Value::asLargestUInt() const {

#if defined(JSON_NO_INT64)

return asUInt();

#else

return asUInt64();

#endif

}

double Value::asDouble() const {

switch (type_) {

case intValue:

return static_cast<double>(value_.int_);

case uintValue:

#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

return static_cast<double>(value_.uint_);

#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

return integerToDouble(value_.uint_);

#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

case realValue:

return value_.real_;

case nullValue:

return 0.0;

case booleanValue:

return value_.bool_ ? 1.0 : 0.0;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to double.");

}

float Value::asFloat() const {

switch (type_) {

case intValue:

return static_cast<float>(value_.int_);

case uintValue:

#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

return static_cast<float>(value_.uint_);

#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

return integerToDouble(value_.uint_);

#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

case realValue:

return static_cast<float>(value_.real_);

case nullValue:

return 0.0;

case booleanValue:

return value_.bool_ ? 1.0f : 0.0f;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to float.");

}

bool Value::asBool() const {

switch (type_) {

case booleanValue:

return value_.bool_;

case nullValue:

return false;

case intValue:

return value_.int_ ? true : false;

case uintValue:

return value_.uint_ ? true : false;

case realValue:

return value_.real_ ? true : false;

default:

break;

}

JSON_FAIL_MESSAGE("Value is not convertible to bool.");

}

bool Value::isConvertibleTo(ValueType other) const {

switch (other) {

case nullValue:

return (isNumeric() && asDouble() == 0.0) ||

(type_ == booleanValue && value_.bool_ == false) ||

(type_ == stringValue && asString() == "") ||

(type_ == arrayValue && value_.map_->size() == 0) ||

(type_ == objectValue && value_.map_->size() == 0) ||

type_ == nullValue;

case intValue:

return isInt() ||

(type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||

type_ == booleanValue || type_ == nullValue;

case uintValue:

return isUInt() ||

(type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||

type_ == booleanValue || type_ == nullValue;

case realValue:

return isNumeric() || type_ == booleanValue || type_ == nullValue;

case booleanValue:

return isNumeric() || type_ == booleanValue || type_ == nullValue;

case stringValue:

return isNumeric() || type_ == booleanValue || type_ == stringValue ||

type_ == nullValue;

case arrayValue:

return type_ == arrayValue || type_ == nullValue;

case objectValue:

return type_ == objectValue || type_ == nullValue;

}

JSON_ASSERT_UNREACHABLE;

return false;

}

/// Number of values in array or object

ArrayIndex Value::size() const {

switch (type_) {

case nullValue:

case intValue:

case uintValue:

case realValue:

case booleanValue:

case stringValue:

return 0;

case arrayValue: // size of the array is highest index + 1

if (!value_.map_->empty()) {

ObjectValues::const_iterator itLast = value_.map_->end();

--itLast;

return (*itLast).first.index() + 1;

}

return 0;

case objectValue:

return ArrayIndex(value_.map_->size());

}

JSON_ASSERT_UNREACHABLE;

return 0; // unreachable;

}

bool Value::empty() const {

if (isNull() || isArray() || isObject())

return size() == 0u;

else

return false;

}

bool Value::operator!() const { return isNull(); }

void Value::clear() {

JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||

type_ == objectValue,

"in Json::Value::clear(): requires complex value");

start_ = 0;

limit_ = 0;

switch (type_) {

case arrayValue:

case objectValue:

value_.map_->clear();

break;

default:

break;

}

}

void Value::resize(ArrayIndex newSize) {

JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,

"in Json::Value::resize(): requires arrayValue");

if (type_ == nullValue)

*this = Value(arrayValue);

ArrayIndex oldSize = size();

if (newSize == 0)

clear();

else if (newSize > oldSize)

(*this)[newSize - 1];

else {

for (ArrayIndex index = newSize; index < oldSize; ++index) {

value_.map_->erase(index);

}

assert(size() == newSize);

}

}

Value& Value::operator[](ArrayIndex index) {

JSON_ASSERT_MESSAGE(

type_ == nullValue || type_ == arrayValue,

"in Json::Value::operator[](ArrayIndex): requires arrayValue");

if (type_ == nullValue)

*this = Value(arrayValue);

CZString key(index);

ObjectValues::iterator it = value_.map_->lower_bound(key);

if (it != value_.map_->end() && (*it).first == key)

return (*it).second;

ObjectValues::value_type defaultValue(key, null);

it = value_.map_->insert(it, defaultValue);

return (*it).second;

}

Value& Value::operator[](int index) {

JSON_ASSERT_MESSAGE(

index >= 0,

"in Json::Value::operator[](int index): index cannot be negative");

return (*this)[ArrayIndex(index)];

}

const Value& Value::operator[](ArrayIndex index) const {

JSON_ASSERT_MESSAGE(

type_ == nullValue || type_ == arrayValue,

"in Json::Value::operator[](ArrayIndex)const: requires arrayValue");

if (type_ == nullValue)

return null;

CZString key(index);

ObjectValues::const_iterator it = value_.map_->find(key);

if (it == value_.map_->end())

return null;

return (*it).second;

}

const Value& Value::operator[](int index) const {

JSON_ASSERT_MESSAGE(

index >= 0,

"in Json::Value::operator[](int index) const: index cannot be negative");

return (*this)[ArrayIndex(index)];

}

Value& Value::operator[](const char* key) {

return resolveReference(key, false);

}

void Value::initBasic(ValueType type, bool allocated) {

type_ = type;

allocated_ = allocated;

comments_ = 0;

start_ = 0;

limit_ = 0;

}

Value& Value::resolveReference(const char* key, bool isStatic) {

JSON_ASSERT_MESSAGE(

type_ == nullValue || type_ == objectValue,

"in Json::Value::resolveReference(): requires objectValue");

if (type_ == nullValue)

*this = Value(objectValue);

CZString actualKey(

key, isStatic ? CZString::noDuplication : CZString::duplicateOnCopy);

ObjectValues::iterator it = value_.map_->lower_bound(actualKey);

if (it != value_.map_->end() && (*it).first == actualKey)

return (*it).second;

ObjectValues::value_type defaultValue(actualKey, null);

it = value_.map_->insert(it, defaultValue);

Value& value = (*it).second;

return value;

}

Value Value::get(ArrayIndex index, const Value& defaultValue) const {

const Value* value = &((*this)[index]);

return value == &null ? defaultValue : *value;

}

bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }

const Value& Value::operator[](const char* key) const {

JSON_ASSERT_MESSAGE(

type_ == nullValue || type_ == objectValue,

"in Json::Value::operator[](char const*)const: requires objectValue");

if (type_ == nullValue)

return null;

CZString actualKey(key, CZString::noDuplication);

ObjectValues::const_iterator it = value_.map_->find(actualKey);

if (it == value_.map_->end())

return null;

return (*it).second;

}

Value& Value::operator[](const std::string& key) {

return (*this)[key.c_str()];

}

const Value& Value::operator[](const std::string& key) const {

return (*this)[key.c_str()];

}

Value& Value::operator[](const StaticString& key) {

return resolveReference(key, true);

}

#ifdef JSON_USE_CPPTL

Value& Value::operator[](const CppTL::ConstString& key) {

return (*this)[key.c_str()];

}

const Value& Value::operator[](const CppTL::ConstString& key) const {

return (*this)[key.c_str()];

}

#endif

Value& Value::append(const Value& value) { return (*this)[size()] = value; }

Value Value::get(const char* key, const Value& defaultValue) const {

const Value* value = &((*this)[key]);

return value == &null ? defaultValue : *value;

}

Value Value::get(const std::string& key, const Value& defaultValue) const {

return get(key.c_str(), defaultValue);

}

bool Value::removeMember(const char* key, Value* removed) {

if (type_ != objectValue) {

return false;

}

CZString actualKey(key, CZString::noDuplication);

ObjectValues::iterator it = value_.map_->find(actualKey);

if (it == value_.map_->end())

return false;

*removed = it->second;

value_.map_->erase(it);

return true;

}

Value Value::removeMember(const char* key) {

JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,

"in Json::Value::removeMember(): requires objectValue");

if (type_ == nullValue)

return null;

Value removed; // null

removeMember(key, &removed);

return removed; // still null if removeMember() did nothing

}

Value Value::removeMember(const std::string& key) {

return removeMember(key.c_str());

}

bool Value::removeIndex(ArrayIndex index, Value* removed) {

if (type_ != arrayValue) {

return false;

}

CZString key(index);

ObjectValues::iterator it = value_.map_->find(key);

if (it == value_.map_->end()) {

return false;

}

*removed = it->second;

ArrayIndex oldSize = size();

// shift left all items left, into the place of the "removed"

for (ArrayIndex i = index; i < (oldSize - 1); ++i){

CZString key(i);

(*value_.map_)[key] = (*this)[i + 1];

}

// erase the last one ("leftover")

CZString keyLast(oldSize - 1);

ObjectValues::iterator itLast = value_.map_->find(keyLast);

value_.map_->erase(itLast);

return true;

}

#ifdef JSON_USE_CPPTL

Value Value::get(const CppTL::ConstString& key,

const Value& defaultValue) const {

return get(key.c_str(), defaultValue);

}

#endif

bool Value::isMember(const char* key) const {

const Value* value = &((*this)[key]);

return value != &null;

}

bool Value::isMember(const std::string& key) const {

return isMember(key.c_str());

}

#ifdef JSON_USE_CPPTL

bool Value::isMember(const CppTL::ConstString& key) const {

return isMember(key.c_str());

}

#endif

Value::Members Value::getMemberNames() const {

JSON_ASSERT_MESSAGE(

type_ == nullValue || type_ == objectValue,

"in Json::Value::getMemberNames(), value must be objectValue");

if (type_ == nullValue)

return Value::Members();

Members members;

members.reserve(value_.map_->size());

ObjectValues::const_iterator it = value_.map_->begin();

ObjectValues::const_iterator itEnd = value_.map_->end();

for (; it != itEnd; ++it)

members.push_back(std::string((*it).first.c_str()));

return members;

}

//

//# ifdef JSON_USE_CPPTL

// EnumMemberNames

// Value::enumMemberNames() const

//{

// if ( type_ == objectValue )

// {

// return CppTL::Enum::any( CppTL::Enum::transform(

// CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),

// MemberNamesTransform() ) );

// }

// return EnumMemberNames();

//}