6 #if !defined(JSON_IS_AMALGAMATION) 10 #endif // if !defined(JSON_IS_AMALGAMATION) 17 #include <cpptl/conststring.h> 22 #define JSON_ASSERT_UNREACHABLE assert(false) 29 #if defined(__ARMEL__) 30 #define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment))) 32 #define ALIGNAS(byte_alignment) 42 static Value const nullStatic;
54 #if defined(JSON_HAS_INT64) 62 #endif // defined(JSON_HAS_INT64) 67 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 68 template <
typename T,
typename U>
69 static inline bool InRange(
double d, T min, U max) {
73 return d >= min && d <= max;
75 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 76 static inline double integerToDouble(
Json::UInt64 value) {
77 return static_cast<double>(
Int64(value / 2)) * 2.0 + static_cast<double>(
Int64(value & 1));
80 template <
typename T>
static inline double integerToDouble(T value) {
81 return static_cast<double>(value);
84 template <
typename T,
typename U>
85 static inline bool InRange(
double d, T min, U max) {
86 return d >= integerToDouble(min) && d <= integerToDouble(max);
88 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 105 char* newString =
static_cast<char*
>(malloc(length + 1));
106 if (newString == NULL) {
108 "in Json::Value::duplicateStringValue(): " 109 "Failed to allocate string value buffer");
111 memcpy(newString, value, length);
112 newString[length] = 0;
125 "in Json::Value::duplicateAndPrefixStringValue(): " 126 "length too big for prefixing");
127 unsigned actualLength = length +
static_cast<unsigned>(
sizeof(unsigned)) + 1U;
128 char* newString =
static_cast<char*
>(malloc(actualLength));
129 if (newString == 0) {
131 "in Json::Value::duplicateAndPrefixStringValue(): " 132 "Failed to allocate string value buffer");
134 *
reinterpret_cast<unsigned*
>(newString) = length;
135 memcpy(newString +
sizeof(
unsigned), value, length);
136 newString[actualLength - 1U] = 0;
140 bool isPrefixed,
char const* prefixed,
141 unsigned* length,
char const** value)
144 *length =
static_cast<unsigned>(strlen(prefixed));
147 *length = *
reinterpret_cast<unsigned const*
>(prefixed);
148 *value = prefixed +
sizeof(unsigned);
153 #if JSONCPP_USING_SECURE_MEMORY 156 char const* valueDecoded;
158 size_t const size =
sizeof(unsigned) + length + 1U;
159 memset(value, 0, size);
164 size_t size = (length==0) ? strlen(value) : length;
165 memset(value, 0, size);
168 #else // !JSONCPP_USING_SECURE_MEMORY 175 #endif // JSONCPP_USING_SECURE_MEMORY 186 #if !defined(JSON_IS_AMALGAMATION) 189 #endif // if !defined(JSON_IS_AMALGAMATION) 214 throw LogicError(msg);
225 Value::CommentInfo::CommentInfo() : comment_(0)
228 Value::CommentInfo::~CommentInfo() {
233 void Value::CommentInfo::setComment(
const char* text,
size_t len) {
240 text[0] ==
'\0' || text[0] ==
'/',
241 "in Json::Value::setComment(): Comments must start with /");
257 Value::CZString::CZString(
ArrayIndex aindex) : cstr_(0), index_(aindex) {}
259 Value::CZString::CZString(
char const* str,
unsigned ulength, DuplicationPolicy allocate)
262 storage_.policy_ = allocate & 0x3;
263 storage_.length_ = ulength & 0x3FFFFFFF;
266 Value::CZString::CZString(
const CZString& other) {
267 cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0
270 storage_.policy_ =
static_cast<unsigned>(other.cstr_
271 ? (
static_cast<DuplicationPolicy
>(other.storage_.policy_) == noDuplication
272 ? noDuplication : duplicate)
273 :
static_cast<DuplicationPolicy
>(other.storage_.policy_)) & 3U;
274 storage_.length_ = other.storage_.length_;
277 #if JSON_HAS_RVALUE_REFERENCES 278 Value::CZString::CZString(CZString&& other)
279 : cstr_(other.cstr_), index_(other.index_) {
280 other.cstr_ =
nullptr;
284 Value::CZString::~CZString() {
285 if (cstr_ && storage_.policy_ == duplicate) {
290 void Value::CZString::swap(CZString& other) {
295 Value::CZString& Value::CZString::operator=(
const CZString& other) {
297 index_ = other.index_;
301 #if JSON_HAS_RVALUE_REFERENCES 302 Value::CZString& Value::CZString::operator=(CZString&& other) {
304 index_ = other.index_;
305 other.cstr_ =
nullptr;
310 bool Value::CZString::operator<(
const CZString& other)
const {
311 if (!cstr_)
return index_ < other.index_;
314 unsigned this_len = this->storage_.length_;
315 unsigned other_len = other.storage_.length_;
316 unsigned min_len = std::min<unsigned>(this_len, other_len);
318 int comp = memcmp(this->cstr_, other.cstr_, min_len);
319 if (comp < 0)
return true;
320 if (comp > 0)
return false;
321 return (this_len < other_len);
325 if (!cstr_)
return index_ == other.index_;
328 unsigned this_len = this->storage_.length_;
329 unsigned other_len = other.storage_.length_;
330 if (this_len != other_len)
return false;
332 int comp = memcmp(this->cstr_, other.cstr_, this_len);
336 ArrayIndex Value::CZString::index()
const {
return index_; }
339 const char* Value::CZString::data()
const {
return cstr_; }
340 unsigned Value::CZString::length()
const {
return storage_.length_; }
341 bool Value::CZString::isStaticString()
const {
return storage_.policy_ == noDuplication; }
356 static char const emptyString[] =
"";
370 value_.string_ =
const_cast<char*
>(
static_cast<char const*
>(emptyString));
374 value_.map_ =
new ObjectValues();
377 value_.bool_ =
false;
391 value_.uint_ = value;
393 #if defined(JSON_HAS_INT64) 400 value_.uint_ = value;
402 #endif // defined(JSON_HAS_INT64) 404 Value::Value(
double value) {
406 value_.real_ = value;
409 Value::Value(
const char* value) {
415 Value::Value(
const char* beginValue,
const char* endValue) {
429 value_.string_ =
const_cast<char*
>(value.
c_str());
432 #ifdef JSON_USE_CPPTL 433 Value::Value(
const CppTL::ConstString& value) {
439 Value::Value(
bool value) {
441 value_.bool_ = value;
445 : type_(other.type_), allocated_(false)
447 comments_(0), start_(other.start_), limit_(other.limit_)
455 value_ = other.value_;
458 if (other.value_.string_ && other.allocated_) {
466 value_.string_ = other.value_.string_;
472 value_.map_ =
new ObjectValues(*other.value_.map_);
477 if (other.comments_) {
480 const CommentInfo& otherComment = other.comments_[comment];
481 if (otherComment.comment_)
482 comments_[comment].setComment(
483 otherComment.comment_, strlen(otherComment.comment_));
488 #if JSON_HAS_RVALUE_REFERENCES 530 std::swap(value_, other.value_);
531 int temp2 = allocated_;
532 allocated_ = other.allocated_;
533 other.allocated_ = temp2 & 0x1;
538 value_ = other.value_;
539 allocated_ = other.allocated_;
544 std::swap(comments_, other.comments_);
545 std::swap(start_, other.start_);
546 std::swap(limit_, other.limit_);
551 comments_ = other.comments_;
552 start_ = other.start_;
553 limit_ = other.limit_;
567 int typeDelta = type_ - other.type_;
569 return typeDelta < 0 ? true :
false;
574 return value_.int_ < other.value_.int_;
576 return value_.uint_ < other.value_.uint_;
578 return value_.real_ < other.value_.real_;
580 return value_.bool_ < other.value_.bool_;
583 if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
584 if (other.value_.string_)
return true;
589 char const* this_str;
590 char const* other_str;
593 unsigned min_len = std::min<unsigned>(this_len, other_len);
595 int comp = memcmp(this_str, other_str, min_len);
596 if (comp < 0)
return true;
597 if (comp > 0)
return false;
598 return (this_len < other_len);
602 int delta = int(value_.map_->size() - other.value_.map_->size());
605 return (*value_.map_) < (*other.value_.map_);
624 int temp = other.type_;
631 return value_.int_ == other.value_.int_;
633 return value_.uint_ == other.value_.uint_;
635 return value_.real_ == other.value_.real_;
637 return value_.bool_ == other.value_.bool_;
640 if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
641 return (value_.string_ == other.value_.string_);
645 char const* this_str;
646 char const* other_str;
649 if (this_len != other_len)
return false;
651 int comp = memcmp(this_str, other_str, this_len);
656 return value_.map_->size() == other.value_.map_->size() &&
657 (*value_.map_) == (*other.value_.map_);
668 "in Json::Value::asCString(): requires stringValue");
669 if (value_.string_ == 0)
return 0;
671 char const* this_str;
676 #if JSONCPP_USING_SECURE_MEMORY 677 unsigned Value::getCStringLength()
const {
679 "in Json::Value::asCString(): requires stringValue");
680 if (value_.string_ == 0)
return 0;
682 char const* this_str;
690 if (value_.string_ == 0)
return false;
693 *cend = *str + length;
703 if (value_.string_ == 0)
return "";
705 char const* this_str;
710 return value_.bool_ ?
"true" :
"false";
722 #ifdef JSON_USE_CPPTL 723 CppTL::ConstString Value::asConstString()
const {
728 return CppTL::ConstString(str, len);
736 return Int(value_.int_);
739 return Int(value_.uint_);
742 "double out of Int range");
743 return Int(value_.real_);
747 return value_.bool_ ? 1 : 0;
758 return UInt(value_.int_);
761 return UInt(value_.uint_);
764 "double out of UInt range");
765 return UInt(value_.real_);
769 return value_.bool_ ? 1 : 0;
776 #if defined(JSON_HAS_INT64) 781 return Int64(value_.int_);
784 return Int64(value_.uint_);
787 "double out of Int64 range");
788 return Int64(value_.real_);
792 return value_.bool_ ? 1 : 0;
803 return UInt64(value_.int_);
805 return UInt64(value_.uint_);
808 "double out of UInt64 range");
809 return UInt64(value_.real_);
813 return value_.bool_ ? 1 : 0;
819 #endif // if defined(JSON_HAS_INT64) 822 #if defined(JSON_NO_INT64) 830 #if defined(JSON_NO_INT64) 840 return static_cast<double>(value_.int_);
842 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 843 return static_cast<double>(value_.uint_);
844 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 845 return integerToDouble(value_.uint_);
846 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 852 return value_.bool_ ? 1.0 : 0.0;
862 return static_cast<float>(value_.int_);
864 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 865 return static_cast<float>(value_.uint_);
866 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 868 return static_cast<float>(integerToDouble(value_.uint_));
869 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 871 return static_cast<float>(value_.real_);
875 return value_.bool_ ? 1.0f : 0.0f;
889 return value_.int_ ? true :
false;
891 return value_.uint_ ? true :
false;
894 return (value_.real_ != 0.0) ? true :
false;
907 (type_ ==
arrayValue && value_.map_->size() == 0) ||
908 (type_ ==
objectValue && value_.map_->size() == 0) ||
945 if (!value_.map_->empty()) {
946 ObjectValues::const_iterator itLast = value_.map_->end();
948 return (*itLast).first.index() + 1;
965 Value::operator bool()
const {
return ! isNull(); }
970 "in Json::Value::clear(): requires complex value");
976 value_.map_->clear();
985 "in Json::Value::resize(): requires arrayValue");
991 else if (newSize > oldSize)
992 (*this)[newSize - 1];
994 for (
ArrayIndex index = newSize; index < oldSize; ++index) {
995 value_.map_->erase(index);
1004 "in Json::Value::operator[](ArrayIndex): requires arrayValue");
1007 CZString key(index);
1008 ObjectValues::iterator it = value_.map_->lower_bound(key);
1009 if (it != value_.map_->end() && (*it).first == key)
1010 return (*it).second;
1012 ObjectValues::value_type defaultValue(key,
nullSingleton());
1013 it = value_.map_->insert(it, defaultValue);
1014 return (*it).second;
1020 "in Json::Value::operator[](int index): index cannot be negative");
1027 "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
1030 CZString key(index);
1031 ObjectValues::const_iterator it = value_.map_->find(key);
1032 if (it == value_.map_->end())
1034 return (*it).second;
1040 "in Json::Value::operator[](int index) const: index cannot be negative");
1044 void Value::initBasic(
ValueType vtype,
bool allocated) {
1046 allocated_ = allocated;
1055 Value& Value::resolveReference(
const char* key) {
1058 "in Json::Value::resolveReference(): requires objectValue");
1062 key, static_cast<unsigned>(strlen(key)), CZString::noDuplication);
1063 ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
1064 if (it != value_.map_->end() && (*it).first == actualKey)
1065 return (*it).second;
1067 ObjectValues::value_type defaultValue(actualKey,
nullSingleton());
1068 it = value_.map_->insert(it, defaultValue);
1069 Value& value = (*it).second;
1074 Value& Value::resolveReference(
char const* key,
char const* cend)
1078 "in Json::Value::resolveReference(key, end): requires objectValue");
1082 key, static_cast<unsigned>(cend-key), CZString::duplicateOnCopy);
1083 ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
1084 if (it != value_.map_->end() && (*it).first == actualKey)
1085 return (*it).second;
1087 ObjectValues::value_type defaultValue(actualKey,
nullSingleton());
1088 it = value_.map_->insert(it, defaultValue);
1089 Value& value = (*it).second;
1094 const Value* value = &((*this)[index]);
1104 "in Json::Value::find(key, end, found): requires objectValue or nullValue");
1106 CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
1107 ObjectValues::const_iterator it = value_.map_->find(actualKey);
1108 if (it == value_.map_->end())
return NULL;
1109 return &(*it).second;
1113 Value const* found =
find(key, key + strlen(key));
1119 Value const* found =
find(key.data(), key.data() + key.length());
1125 return resolveReference(key, key + strlen(key));
1129 return resolveReference(key.data(), key.data() + key.length());
1133 return resolveReference(key.
c_str());
1136 #ifdef JSON_USE_CPPTL 1138 return resolveReference(key.c_str(), key.end_c_str());
1142 Value const* found =
find(key.c_str(), key.end_c_str());
1150 #if JSON_HAS_RVALUE_REFERENCES 1157 return !found ? defaultValue : *found;
1161 return get(key, key + strlen(key), defaultValue);
1165 return get(key.data(), key.data() + key.length(), defaultValue);
1174 CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
1175 ObjectValues::iterator it = value_.map_->find(actualKey);
1176 if (it == value_.map_->end())
1178 *removed = it->second;
1179 value_.map_->erase(it);
1188 return removeMember(key.data(), key.data() + key.length(), removed);
1193 "in Json::Value::removeMember(): requires objectValue");
1197 CZString actualKey(key,
unsigned(strlen(key)), CZString::noDuplication);
1198 value_.map_->erase(actualKey);
1209 CZString key(index);
1210 ObjectValues::iterator it = value_.map_->find(key);
1211 if (it == value_.map_->end()) {
1214 *removed = it->second;
1217 for (
ArrayIndex i = index; i < (oldSize - 1); ++i){
1219 (*value_.map_)[keey] = (*
this)[i + 1];
1222 CZString keyLast(oldSize - 1);
1223 ObjectValues::iterator itLast = value_.map_->find(keyLast);
1224 value_.map_->erase(itLast);
1228 #ifdef JSON_USE_CPPTL 1230 const Value& defaultValue)
const {
1231 return get(key.c_str(), key.end_c_str(), defaultValue);
1238 return NULL != value;
1242 return isMember(key, key + strlen(key));
1246 return isMember(key.data(), key.data() + key.length());
1249 #ifdef JSON_USE_CPPTL 1251 return isMember(key.c_str(), key.end_c_str());
1258 "in Json::Value::getMemberNames(), value must be objectValue");
1262 members.reserve(value_.map_->size());
1263 ObjectValues::const_iterator it = value_.map_->begin();
1264 ObjectValues::const_iterator itEnd = value_.map_->end();
1265 for (; it != itEnd; ++it) {
1267 (*it).first.length()));
1298 double integral_part;
1299 return modf(d, &integral_part) == 0.0;
1309 #if defined(JSON_HAS_INT64) 1317 return value_.real_ >=
minInt && value_.real_ <=
maxInt &&
1328 #if defined(JSON_HAS_INT64) 1331 return value_.int_ >= 0;
1334 #if defined(JSON_HAS_INT64) 1335 return value_.uint_ <=
maxUInt;
1340 return value_.real_ >= 0 && value_.real_ <=
maxUInt &&
1349 #if defined(JSON_HAS_INT64) 1359 return value_.real_ >= double(
minInt64) &&
1364 #endif // JSON_HAS_INT64 1369 #if defined(JSON_HAS_INT64) 1372 return value_.int_ >= 0;
1384 #endif // JSON_HAS_INT64 1394 #if defined(JSON_HAS_INT64) 1401 #endif // JSON_HAS_INT64 1421 if ((len > 0) && (comment[len-1] ==
'\n')) {
1425 comments_[placement].setComment(comment, len);
1429 setComment(comment, strlen(comment), placement);
1433 setComment(comment.c_str(), comment.length(), placement);
1437 return comments_ != 0 && comments_[placement].comment_ != 0;
1442 return comments_[placement].comment_;
1495 return iterator(value_.map_->begin());
1508 return iterator(value_.map_->end());
1522 : key_(), index_(index), kind_(kindIndex) {}
1525 : key_(key), index_(), kind_(kindKey) {}
1528 : key_(key.c_str()), index_(), kind_(kindKey) {}
1549 void Path::makePath(
const JSONCPP_STRING& path,
const InArgs& in) {
1550 const char* current = path.c_str();
1551 const char* end = current + path.length();
1552 InArgs::const_iterator itInArg = in.begin();
1553 while (current != end) {
1554 if (*current ==
'[') {
1556 if (*current ==
'%')
1557 addPathInArg(path, in, itInArg, PathArgument::kindIndex);
1560 for (; current != end && *current >=
'0' && *current <=
'9'; ++current)
1561 index = index * 10 +
ArrayIndex(*current -
'0');
1562 args_.push_back(index);
1564 if (current == end || *++current !=
']')
1565 invalidPath(path,
int(current - path.c_str()));
1566 }
else if (*current ==
'%') {
1567 addPathInArg(path, in, itInArg, PathArgument::kindKey);
1569 }
else if (*current ==
'.' || *current ==
']') {
1572 const char* beginName = current;
1573 while (current != end && !strchr(
"[.", *current))
1582 InArgs::const_iterator& itInArg,
1583 PathArgument::Kind kind) {
1584 if (itInArg == in.end()) {
1586 }
else if ((*itInArg)->kind_ != kind) {
1589 args_.push_back(**itInArg++);
1598 const Value* node = &root;
1599 for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
1601 if (arg.kind_ == PathArgument::kindIndex) {
1606 node = &((*node)[arg.index_]);
1607 }
else if (arg.kind_ == PathArgument::kindKey) {
1612 node = &((*node)[arg.key_]);
1624 const Value* node = &root;
1625 for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
1627 if (arg.kind_ == PathArgument::kindIndex) {
1629 return defaultValue;
1630 node = &((*node)[arg.index_]);
1631 }
else if (arg.kind_ == PathArgument::kindKey) {
1633 return defaultValue;
1634 node = &((*node)[arg.key_]);
1636 return defaultValue;
1643 Value* node = &root;
1644 for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
1646 if (arg.kind_ == PathArgument::kindIndex) {
1650 node = &((*node)[arg.index_]);
1651 }
else if (arg.kind_ == PathArgument::kindKey) {
1655 node = &((*node)[arg.key_]);
Path(const std::string &path, const PathArgument &a1=PathArgument(), const PathArgument &a2=PathArgument(), const PathArgument &a3=PathArgument(), const PathArgument &a4=PathArgument(), const PathArgument &a5=PathArgument())
static bool IsIntegral(double d)
int compare(const Value &other) const
static const Int64 maxInt64
Maximum signed 64 bits int value that can be stored in a Json::Value.
Value const * find(char const *begin, char const *end) const
Most general and efficient version of isMember()const, get()const, and operator[]const.
Value & make(Value &root) const
Creates the "path" to access the specified node and returns a reference on the node.
LargestUInt asLargestUInt() const
array value (ordered list)
void copy(const Value &other)
copy everything.
#define JSON_ASSERT_MESSAGE(condition, message)
static Value const & nullSingleton()
Prefer this to null or nullRef.
Json::ArrayIndex ArrayIndex
bool empty() const
Return true if empty array, empty object, or null; otherwise, false.
Members getMemberNames() const
Return a list of the member names.
object value (collection of name/value pairs).
bool getString(char const **begin, char const **end) const
Get raw char* of string-value.
void swapPayload(Value &other)
Swap values but leave comments and source offsets in place.
RuntimeError(std::string const &msg)
bool removeIndex(ArrayIndex i, Value *removed)
Remove the indexed array element.
static const Int maxInt
Maximum signed int value that can be stored in a Json::Value.
ptrdiff_t getOffsetStart() const
static const Value & null
We regret this reference to a global instance; prefer the simpler Value().
Lightweight wrapper to tag static string.
std::string toStyledString() const
#define JSON_ASSERT(condition)
It should not be possible for a maliciously designed file to cause an abort() or seg-fault, so these macros are used only for pre-condition violations and internal logic errors.
static const UInt maxUInt
Maximum unsigned int value that can be stored in a Json::Value.
static const Value & nullRef
just a kludge for binary-compatibility; same as null
Json::LargestUInt LargestUInt
LogicError(std::string const &msg)
Value & operator=(Value other)
Deep copy, then swap(other).
static void releaseStringValue(char *value, unsigned)
const iterator for object and array value.
Value(ValueType type=nullValue)
Create a default Value of the given type.
Experimental and untested: represents an element of the "path" to access a node.
void setComment(const char *comment, CommentPlacement placement)
static bool InRange(double d, T min, U max)
static const LargestInt minLargestInt
Minimum signed integer value that can be stored in a Json::Value.
std::string getComment(CommentPlacement placement) const
Include delimiters and embedded newlines.
static void decodePrefixedString(bool isPrefixed, char const *prefixed, unsigned *length, char const **value)
Value & operator[](ArrayIndex index)
Access an array element (zero based index ).
ArrayIndex size() const
Number of values in array or object.
const char * asCString() const
Embedded zeroes could cause you trouble!
bool operator==(const Value &other) const
ValueConstIterator const_iterator
LargestInt asLargestInt() const
bool operator>(const Value &other) const
std::string valueToString(Int value)
bool isValidIndex(ArrayIndex index) const
Return true if index < size().
std::string asString() const
Embedded zeroes are possible.
bool operator>=(const Value &other) const
JSON (JavaScript Object Notation).
void removeMember(const char *key)
Remove and return the named member.
bool operator==(const SecureAllocator< T > &, const SecureAllocator< U > &)
#define JSON_FAIL_MESSAGE(message)
void swap(Value &other)
Swap everything.
Json::LargestInt LargestInt
static const double maxUInt64AsDouble
static const UInt64 maxUInt64
Maximum unsigned 64 bits int value that can be stored in a Json::Value.
ptrdiff_t getOffsetLimit() const
const char * c_str() const
Value get(ArrayIndex index, const Value &defaultValue) const
If the array contains at least index+1 elements, returns the element value, otherwise returns default...
const_iterator begin() const
Exception(std::string const &msg)
Value & append(const Value &value)
Append value to array at the end.
static char * duplicateAndPrefixStringValue(const char *value, unsigned int length)
#define JSON_ASSERT_UNREACHABLE
void setOffsetStart(ptrdiff_t start)
static char * duplicateStringValue(const char *value, size_t length)
Duplicates the specified string value.
static const Int64 minInt64
Minimum signed 64 bits int value that can be stored in a Json::Value.
static const Int minInt
Minimum signed int value that can be stored in a Json::Value.
Exceptions which the user cannot easily avoid.
bool hasComment(CommentPlacement placement) const
void resize(ArrayIndex size)
Resize the array to size elements.
void clear()
Remove all object members and array elements.
bool operator!=(const Value &other) const
Iterator for object and array value.
static void releasePrefixedStringValue(char *value)
Free the string duplicated by duplicateStringValue()/duplicateAndPrefixStringValue().
void setOffsetLimit(ptrdiff_t limit)
bool isMember(const char *key) const
Return true if the object has a member named key.
std::vector< std::string > Members
bool operator<=(const Value &other) const
std::string writeString(StreamWriter::Factory const &factory, Value const &root)
Write into stringstream, then return string, for convenience.
const Value & resolve(const Value &root) const
bool isConvertibleTo(ValueType other) const
bool operator<(const Value &other) const
Compare payload only, not comments etc.
void copyPayload(const Value &other)
copy values but leave comments and source offsets in place.
a comment placed on the line before a value
char const * what() const
Build a StreamWriter implementation.
void swap(Json::Value &a, Json::Value &b)
Specialize std::swap() for Json::Value.
Base class for all exceptions we throw.
const_iterator end() const
static const LargestInt maxLargestInt
Maximum signed integer value that can be stored in a Json::Value.
static const LargestUInt maxLargestUInt
Maximum unsigned integer value that can be stored in a Json::Value.