15#ifndef RAPIDJSON_DOCUMENT_H_
16#define RAPIDJSON_DOCUMENT_H_
22#include "internal/meta.h"
23#include "internal/strfunc.h"
24#include "memorystream.h"
25#include "encodedstream.h"
28#ifdef __cpp_lib_three_way_comparison
34RAPIDJSON_DIAG_OFF(padded)
35RAPIDJSON_DIAG_OFF(
switch-
enum)
36RAPIDJSON_DIAG_OFF(c++98-compat)
37#elif defined(_MSC_VER)
38RAPIDJSON_DIAG_OFF(4127)
39RAPIDJSON_DIAG_OFF(4244)
43RAPIDJSON_DIAG_OFF(effc++)
46#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
50#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
57template <
typename Encoding,
typename Allocator>
60template <
typename Encoding,
typename Allocator,
typename StackAllocator>
69#ifndef RAPIDJSON_DEFAULT_ALLOCATOR
70#define RAPIDJSON_DEFAULT_ALLOCATOR MemoryPoolAllocator<CrtAllocator>
79#ifndef RAPIDJSON_DEFAULT_STACK_ALLOCATOR
80#define RAPIDJSON_DEFAULT_STACK_ALLOCATOR CrtAllocator
89#ifndef RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
91#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY 16
100#ifndef RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
102#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY 16
111template <
typename Encoding,
typename Allocator>
117#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
120 :
name(std::move(rhs.name)),
121 value(std::move(rhs.value))
145 a.value.Swap(b.value);
156#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
177template <
bool Const,
typename Encoding,
typename Allocator>
184 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
196 typedef ValueType value_type;
197 typedef ValueType * pointer;
198 typedef ValueType & reference;
199 typedef std::ptrdiff_t difference_type;
200 typedef std::random_access_iterator_tag iterator_category;
237 Iterator& operator++(){ ++ptr_;
return *
this; }
238 Iterator& operator--(){ --ptr_;
return *
this; }
261#ifdef __cpp_lib_three_way_comparison
268 Reference operator*()
const {
return *ptr_; }
269 Pointer operator->()
const {
return ptr_; }
287template <
bool Const,
typename Encoding,
typename Allocator>
291template <
typename Encoding,
typename Allocator>
298template <
typename Encoding,
typename Allocator>
337template<
typename CharType>
392 :
s(str),
length(NotNullStrLen(str)) {}
409 operator const Ch *()
const {
return s; }
415 SizeType NotNullStrLen(
const CharType* str) {
417 return internal::StrLen(str);
421 static const Ch emptyString[];
430template<
typename CharType>
445template<
typename CharType>
465template<
typename CharType>
470#if RAPIDJSON_HAS_STDSTRING
483template<
typename CharType>
493template <
typename T,
typename Encoding =
void,
typename Allocator =
void>
498 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>
::Type {};
510template <
typename ValueType,
typename T>
513template<
typename ValueType>
515 static bool Is(
const ValueType& v) {
return v.IsBool(); }
516 static bool Get(
const ValueType& v) {
return v.GetBool(); }
517 static ValueType& Set(ValueType& v,
bool data) {
return v.SetBool(data); }
518 static ValueType& Set(ValueType& v,
bool data,
typename ValueType::AllocatorType&) {
return v.SetBool(data); }
521template<
typename ValueType>
523 static bool Is(
const ValueType& v) {
return v.IsInt(); }
524 static int Get(
const ValueType& v) {
return v.GetInt(); }
525 static ValueType& Set(ValueType& v,
int data) {
return v.SetInt(data); }
526 static ValueType& Set(ValueType& v,
int data,
typename ValueType::AllocatorType&) {
return v.SetInt(data); }
529template<
typename ValueType>
531 static bool Is(
const ValueType& v) {
return v.IsUint(); }
532 static unsigned Get(
const ValueType& v) {
return v.GetUint(); }
533 static ValueType& Set(ValueType& v,
unsigned data) {
return v.SetUint(data); }
534 static ValueType& Set(ValueType& v,
unsigned data,
typename ValueType::AllocatorType&) {
return v.SetUint(data); }
539template<
typename ValueType>
541 static bool Is(
const ValueType& v) {
return v.IsInt(); }
542 static long Get(
const ValueType& v) {
return v.GetInt(); }
543 static ValueType& Set(ValueType& v,
long data) {
return v.SetInt(data); }
544 static ValueType& Set(ValueType& v,
long data,
typename ValueType::AllocatorType&) {
return v.SetInt(data); }
548template<
typename ValueType>
549struct TypeHelper<ValueType, unsigned long> {
550 static bool Is(
const ValueType& v) {
return v.IsUint(); }
551 static unsigned long Get(
const ValueType& v) {
return v.GetUint(); }
552 static ValueType& Set(ValueType& v,
unsigned long data) {
return v.SetUint(data); }
553 static ValueType& Set(ValueType& v,
unsigned long data,
typename ValueType::AllocatorType&) {
return v.SetUint(data); }
557template<
typename ValueType>
559 static bool Is(
const ValueType& v) {
return v.IsInt64(); }
560 static int64_t Get(
const ValueType& v) {
return v.GetInt64(); }
561 static ValueType& Set(ValueType& v, int64_t data) {
return v.SetInt64(data); }
562 static ValueType& Set(ValueType& v, int64_t data,
typename ValueType::AllocatorType&) {
return v.SetInt64(data); }
565template<
typename ValueType>
567 static bool Is(
const ValueType& v) {
return v.IsUint64(); }
568 static uint64_t Get(
const ValueType& v) {
return v.GetUint64(); }
569 static ValueType& Set(ValueType& v, uint64_t data) {
return v.SetUint64(data); }
570 static ValueType& Set(ValueType& v, uint64_t data,
typename ValueType::AllocatorType&) {
return v.SetUint64(data); }
573template<
typename ValueType>
575 static bool Is(
const ValueType& v) {
return v.IsDouble(); }
576 static double Get(
const ValueType& v) {
return v.GetDouble(); }
577 static ValueType& Set(ValueType& v,
double data) {
return v.SetDouble(data); }
578 static ValueType& Set(ValueType& v,
double data,
typename ValueType::AllocatorType&) {
return v.SetDouble(data); }
581template<
typename ValueType>
583 static bool Is(
const ValueType& v) {
return v.IsFloat(); }
584 static float Get(
const ValueType& v) {
return v.GetFloat(); }
585 static ValueType& Set(ValueType& v,
float data) {
return v.SetFloat(data); }
586 static ValueType& Set(ValueType& v,
float data,
typename ValueType::AllocatorType&) {
return v.SetFloat(data); }
589template<
typename ValueType>
591 typedef const typename ValueType::Ch* StringType;
592 static bool Is(
const ValueType& v) {
return v.IsString(); }
593 static StringType Get(
const ValueType& v) {
return v.GetString(); }
594 static ValueType& Set(ValueType& v,
const StringType data) {
return v.SetString(
typename ValueType::StringRefType(data)); }
595 static ValueType& Set(ValueType& v,
const StringType data,
typename ValueType::AllocatorType& a) {
return v.SetString(data, a); }
598#if RAPIDJSON_HAS_STDSTRING
599template<
typename ValueType>
600struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
601 typedef std::basic_string<typename ValueType::Ch> StringType;
602 static bool Is(
const ValueType& v) {
return v.IsString(); }
603 static StringType Get(
const ValueType& v) {
return StringType(v.GetString(), v.GetStringLength()); }
604 static ValueType& Set(ValueType& v,
const StringType& data,
typename ValueType::AllocatorType& a) {
return v.SetString(data, a); }
608template<
typename ValueType>
610 typedef typename ValueType::Array ArrayType;
611 static bool Is(
const ValueType& v) {
return v.IsArray(); }
612 static ArrayType Get(ValueType& v) {
return v.GetArray(); }
613 static ValueType& Set(ValueType& v, ArrayType data) {
return v = data; }
614 static ValueType& Set(ValueType& v, ArrayType data,
typename ValueType::AllocatorType&) {
return v = data; }
617template<
typename ValueType>
618struct TypeHelper<ValueType, typename ValueType::ConstArray> {
619 typedef typename ValueType::ConstArray ArrayType;
620 static bool Is(
const ValueType& v) {
return v.IsArray(); }
621 static ArrayType Get(
const ValueType& v) {
return v.GetArray(); }
624template<
typename ValueType>
626 typedef typename ValueType::Object ObjectType;
627 static bool Is(
const ValueType& v) {
return v.IsObject(); }
628 static ObjectType Get(ValueType& v) {
return v.GetObject(); }
629 static ValueType& Set(ValueType& v, ObjectType data) {
return v = data; }
630 static ValueType& Set(ValueType& v, ObjectType data,
typename ValueType::AllocatorType&) {
return v = data; }
633template<
typename ValueType>
634struct TypeHelper<ValueType, typename ValueType::ConstObject> {
635 typedef typename ValueType::ConstObject ObjectType;
636 static bool Is(
const ValueType& v) {
return v.IsObject(); }
637 static ObjectType Get(
const ValueType& v) {
return v.GetObject(); }
659template <
typename Encoding,
typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR >
666 typedef typename Encoding::Ch
Ch;
682 GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }
684#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
687 rhs.data_.f.flags = kNullFlag;
695#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
697 template <
typename StackAllocator>
701 template <
typename StackAllocator>
713 static const uint16_t defaultFlags[] = {
714 kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
718 data_.f.flags = defaultFlags[type];
722 data_.ss.SetLength(0);
733 template <
typename SourceAllocator>
735 switch (rhs.GetType()) {
740 for (
SizeType i = 0; i < count; i++) {
744 data_.f.flags = kObjectFlag;
745 data_.o.size = data_.o.capacity = count;
746 SetMembersPointer(lm);
753 for (
SizeType i = 0; i < count; i++)
754 new (&le[i])
GenericValue(re[i], allocator, copyConstStrings);
755 data_.f.flags = kArrayFlag;
756 data_.a.size = data_.a.capacity = count;
757 SetElementsPointer(le);
761 if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {
762 data_.f.flags = rhs.data_.f.flags;
763 data_ = *
reinterpret_cast<const Data*
>(&rhs.data_);
769 data_.f.flags = rhs.data_.f.flags;
770 data_ = *
reinterpret_cast<const Data*
>(&rhs.data_);
781#ifndef RAPIDJSON_DOXYGEN_RUNNING
782 template <
typename T>
783 explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) RAPIDJSON_NOEXCEPT
790 data_.f.flags = b ? kTrueFlag : kFalseFlag;
796 data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
802 data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
808 data_.f.flags = kNumberInt64Flag;
810 data_.f.flags |= kNumberUint64Flag;
812 data_.f.flags |= kUintFlag;
814 data_.f.flags |= kIntFlag;
817 data_.f.flags |= kIntFlag;
823 data_.f.flags = kNumberUint64Flag;
825 data_.f.flags |= kInt64Flag;
827 data_.f.flags |= kUintFlag;
829 data_.f.flags |= kIntFlag;
833 explicit GenericValue(
double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }
836 explicit GenericValue(
float f) RAPIDJSON_NOEXCEPT : data_() { data_.n.d =
static_cast<double>(f); data_.f.flags = kNumberDoubleFlag; }
850#if RAPIDJSON_HAS_STDSTRING
864 a.value_.data_ =
Data();
865 a.value_.data_.f.flags = kArrayFlag;
875 o.value_.data_ =
Data();
876 o.value_.data_.f.flags = kObjectFlag;
883 if (Allocator::kNeedFree) {
884 switch(data_.f.flags) {
897 Allocator::Free(GetMembersPointer());
900 case kCopyStringFlag:
901 Allocator::Free(
const_cast<Ch*
>(GetStringPointer()));
926#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
929 return *
this = rhs.Move();
955 template <
typename T>
969 template <
typename SourceAllocator>
971 RAPIDJSON_ASSERT(
static_cast<void*
>(
this) !=
static_cast<void const*
>(&rhs));
973 new (
this)
GenericValue(rhs, allocator, copyConstStrings);
986 other.RawAssign(temp);
1006 GenericValue& Move() RAPIDJSON_NOEXCEPT {
return *
this; }
1016 template <
typename SourceAllocator>
1019 if (GetType() != rhs.GetType())
1022 switch (GetType()) {
1024 if (data_.o.size != rhs.data_.o.size)
1026 for (
ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
1027 typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
1028 if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
1034 if (data_.a.size != rhs.data_.a.size)
1036 for (
SizeType i = 0; i < data_.a.size; i++)
1037 if ((*
this)[i] != rhs[i])
1042 return StringEqual(rhs);
1045 if (IsDouble() || rhs.IsDouble()) {
1046 double a = GetDouble();
1047 double b = rhs.GetDouble();
1048 return a >= b && a <= b;
1051 return data_.n.u64 == rhs.data_.n.u64;
1061#if RAPIDJSON_HAS_STDSTRING
1065 bool operator==(
const std::basic_string<Ch>& rhs)
const {
return *
this ==
GenericValue(
StringRef(rhs)); }
1076 template <
typename SourceAllocator>
1080 bool operator!=(
const Ch* rhs)
const {
return !(*
this == rhs); }
1101 Type GetType()
const {
return static_cast<Type>(data_.f.flags & kTypeMask); }
1102 bool IsNull()
const {
return data_.f.flags == kNullFlag; }
1103 bool IsFalse()
const {
return data_.f.flags == kFalseFlag; }
1104 bool IsTrue()
const {
return data_.f.flags == kTrueFlag; }
1105 bool IsBool()
const {
return (data_.f.flags & kBoolFlag) != 0; }
1106 bool IsObject()
const {
return data_.f.flags == kObjectFlag; }
1107 bool IsArray()
const {
return data_.f.flags == kArrayFlag; }
1108 bool IsNumber()
const {
return (data_.f.flags & kNumberFlag) != 0; }
1109 bool IsInt()
const {
return (data_.f.flags & kIntFlag) != 0; }
1110 bool IsUint()
const {
return (data_.f.flags & kUintFlag) != 0; }
1111 bool IsInt64()
const {
return (data_.f.flags & kInt64Flag) != 0; }
1112 bool IsUint64()
const {
return (data_.f.flags & kUint64Flag) != 0; }
1113 bool IsDouble()
const {
return (data_.f.flags & kDoubleFlag) != 0; }
1114 bool IsString()
const {
return (data_.f.flags & kStringFlag) != 0; }
1117 bool IsLosslessDouble()
const {
1118 if (!IsNumber())
return false;
1120 uint64_t u = GetUint64();
1121 volatile double d =
static_cast<double>(u);
1123 && (d < static_cast<double>((std::numeric_limits<uint64_t>::max)()))
1124 && (u ==
static_cast<uint64_t
>(d));
1127 int64_t i = GetInt64();
1128 volatile double d =
static_cast<double>(i);
1129 return (d >=
static_cast<double>((std::numeric_limits<int64_t>::min)()))
1130 && (d < static_cast<double>((std::numeric_limits<int64_t>::max)()))
1131 && (i ==
static_cast<int64_t
>(d));
1137 bool IsFloat()
const {
1138 if ((data_.f.flags & kDoubleFlag) == 0)
1140 double d = GetDouble();
1141 return d >= -3.4028234e38 && d <= 3.4028234e38;
1144 bool IsLosslessFloat()
const {
1145 if (!IsNumber())
return false;
1146 double a = GetDouble();
1147 if (a <
static_cast<double>(-(std::numeric_limits<float>::max)())
1148 || a >
static_cast<double>((std::numeric_limits<float>::max)()))
1150 double b =
static_cast<double>(
static_cast<float>(a));
1151 return a >= b && a <= b;
1166 bool GetBool()
const {
RAPIDJSON_ASSERT(IsBool());
return data_.f.flags == kTrueFlag; }
1187 bool ObjectEmpty()
const {
RAPIDJSON_ASSERT(IsObject());
return data_.o.size == 0; }
1198 template <
typename T>
1203 template <
typename T>
1215 template <
typename SourceAllocator>
1218 if (member != MemberEnd())
1219 return member->value;
1232 template <
typename SourceAllocator>
1235#if RAPIDJSON_HAS_STDSTRING
1262 if (newCapacity > data_.o.capacity) {
1263 SetMembersPointer(
reinterpret_cast<Member*
>(allocator.Realloc(GetMembersPointer(), data_.o.capacity *
sizeof(
Member), newCapacity *
sizeof(
Member))));
1264 data_.o.capacity = newCapacity;
1277 bool HasMember(
const Ch* name)
const {
return FindMember(name) != MemberEnd(); }
1279#if RAPIDJSON_HAS_STDSTRING
1288 bool HasMember(
const std::basic_string<Ch>& name)
const {
return FindMember(name) != MemberEnd(); }
1300 template <
typename SourceAllocator>
1317 return FindMember(n);
1335 template <
typename SourceAllocator>
1340 for ( ; member != MemberEnd(); ++member)
1341 if (name.StringEqual(member->name))
1347#if RAPIDJSON_HAS_STDSTRING
1373 ObjectData& o = data_.o;
1374 if (o.size >= o.capacity)
1375 MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
1376 Member* members = GetMembersPointer();
1377 members[o.size].name.RawAssign(name);
1378 members[o.size].value.RawAssign(value);
1394 return AddMember(name, v, allocator);
1397#if RAPIDJSON_HAS_STDSTRING
1409 return AddMember(name, v, allocator);
1430 template <
typename T>
1434 return AddMember(name, v, allocator);
1437#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
1439 return AddMember(name, value, allocator);
1442 return AddMember(name, value, allocator);
1445 return AddMember(name, value, allocator);
1449 return AddMember(n, value, allocator);
1466 return AddMember(n, value, allocator);
1480 return AddMember(name, v, allocator);
1500 template <
typename T>
1504 return AddMember(n, value, allocator);
1511 void RemoveAllMembers() {
1526 bool RemoveMember(
const Ch* name) {
1528 return RemoveMember(n);
1531#if RAPIDJSON_HAS_STDSTRING
1532 bool RemoveMember(
const std::basic_string<Ch>& name) {
return RemoveMember(
GenericValue(
StringRef(name))); }
1535 template <
typename SourceAllocator>
1538 if (m != MemberEnd()) {
1561 if (data_.o.size > 1 && m != last)
1579 return EraseMember(pos, pos +1);
1602 std::memmove(
static_cast<void*
>(&*pos), &*last,
static_cast<size_t>(MemberEnd() - last) *
sizeof(
Member));
1603 data_.o.size -=
static_cast<SizeType>(last - first);
1612 bool EraseMember(
const Ch* name) {
1614 return EraseMember(n);
1617#if RAPIDJSON_HAS_STDSTRING
1618 bool EraseMember(
const std::basic_string<Ch>& name) {
return EraseMember(
GenericValue(
StringRef(name))); }
1621 template <
typename SourceAllocator>
1624 if (m != MemberEnd()) {
1633 ConstObject GetObject()
const {
RAPIDJSON_ASSERT(IsObject());
return ConstObject(*
this); }
1651 bool Empty()
const {
RAPIDJSON_ASSERT(IsArray());
return data_.a.size == 0; }
1673 return GetElementsPointer()[index];
1698 if (newCapacity > data_.a.capacity) {
1700 data_.a.capacity = newCapacity;
1717 if (data_.a.size >= data_.a.capacity)
1718 Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
1719 GetElementsPointer()[data_.a.size++].
RawAssign(value);
1723#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
1725 return PushBack(value, allocator);
1739 return (*this).template PushBack<StringRefType>(value, allocator);
1759 template <
typename T>
1761 PushBack(T value,
Allocator& allocator) {
1763 return PushBack(v, allocator);
1785 return Erase(pos, pos + 1);
1806 std::memmove(
static_cast<void*
>(pos), last,
static_cast<size_t>(End() - last) *
sizeof(
GenericValue));
1807 data_.a.size -=
static_cast<SizeType>(last - first);
1812 ConstArray GetArray()
const {
RAPIDJSON_ASSERT(IsArray());
return ConstArray(*
this); }
1819 int GetInt()
const {
RAPIDJSON_ASSERT(data_.f.flags & kIntFlag);
return data_.n.i.i; }
1820 unsigned GetUint()
const {
RAPIDJSON_ASSERT(data_.f.flags & kUintFlag);
return data_.n.u.u; }
1821 int64_t GetInt64()
const {
RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag);
return data_.n.i64; }
1822 uint64_t GetUint64()
const {
RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag);
return data_.n.u64; }
1827 double GetDouble()
const {
1829 if ((data_.f.flags & kDoubleFlag) != 0)
return data_.n.d;
1830 if ((data_.f.flags & kIntFlag) != 0)
return data_.n.i.i;
1831 if ((data_.f.flags & kUintFlag) != 0)
return data_.n.u.u;
1832 if ((data_.f.flags & kInt64Flag) != 0)
return static_cast<double>(data_.n.i64);
1833 RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0);
return static_cast<double>(data_.n.u64);
1839 float GetFloat()
const {
1840 return static_cast<float>(GetDouble());
1855 const Ch* GetString()
const {
RAPIDJSON_ASSERT(IsString());
return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); }
1860 SizeType GetStringLength()
const {
RAPIDJSON_ASSERT(IsString());
return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }
1905#if RAPIDJSON_HAS_STDSTRING
1925 template <
typename T>
1928 template <
typename T>
1931 template <
typename T>
1934 template<
typename T>
1937 template<
typename T>
1949 template <
typename Handler>
1950 bool Accept(
Handler& handler)
const {
1954 case kTrueType:
return handler.Bool(
true);
1961 if (
RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
1966 return handler.EndObject(data_.o.size);
1974 return handler.EndArray(data_.a.size);
1977 return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
1981 if (IsDouble())
return handler.Double(data_.n.d);
1982 else if (IsInt())
return handler.Int(data_.n.i.i);
1983 else if (IsUint())
return handler.Uint(data_.n.u.u);
1984 else if (IsInt64())
return handler.Int64(data_.n.i64);
1985 else return handler.Uint64(data_.n.u64);
1990 template <
typename,
typename>
friend class GenericValue;
1995 kNumberFlag = 0x0010,
1998 kInt64Flag = 0x0080,
1999 kUint64Flag = 0x0100,
2000 kDoubleFlag = 0x0200,
2001 kStringFlag = 0x0400,
2003 kInlineStrFlag = 0x1000,
2008 kTrueFlag =
static_cast<int>(
kTrueType) |
static_cast<int>(kBoolFlag),
2009 kFalseFlag =
static_cast<int>(
kFalseType) |
static_cast<int>(kBoolFlag),
2010 kNumberIntFlag =
static_cast<int>(
kNumberType) |
static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag),
2011 kNumberUintFlag =
static_cast<int>(
kNumberType) |
static_cast<int>(kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag),
2012 kNumberInt64Flag =
static_cast<int>(
kNumberType) |
static_cast<int>(kNumberFlag | kInt64Flag),
2013 kNumberUint64Flag =
static_cast<int>(
kNumberType) |
static_cast<int>(kNumberFlag | kUint64Flag),
2014 kNumberDoubleFlag =
static_cast<int>(
kNumberType) |
static_cast<int>(kNumberFlag | kDoubleFlag),
2015 kNumberAnyFlag =
static_cast<int>(
kNumberType) |
static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag),
2016 kConstStringFlag =
static_cast<int>(
kStringType) |
static_cast<int>(kStringFlag),
2017 kCopyStringFlag =
static_cast<int>(
kStringType) |
static_cast<int>(kStringFlag | kCopyFlag),
2018 kShortStringFlag =
static_cast<int>(
kStringType) |
static_cast<int>(kStringFlag | kCopyFlag | kInlineStrFlag),
2029#if RAPIDJSON_48BITPOINTER_OPTIMIZATION
2030 char payload[
sizeof(
SizeType) * 2 + 6];
2031#elif RAPIDJSON_64BIT
2032 char payload[
sizeof(
SizeType) * 2 +
sizeof(
void*) + 6];
2034 char payload[
sizeof(
SizeType) * 2 +
sizeof(
void*) + 2];
2054 enum { MaxChars =
sizeof(
static_cast<Flag*
>(0)->payload) /
sizeof(
Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
2057 inline static bool Usable(
SizeType len) {
return (MaxSize >= len); }
2058 inline void SetLength(
SizeType len) { str[LenPos] =
static_cast<Ch>(MaxSize - len); }
2059 inline SizeType GetLength()
const {
return static_cast<SizeType>(MaxSize - str[LenPos]); }
2064#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
2109 RAPIDJSON_FORCEINLINE
const Ch* GetStringPointer()
const {
return RAPIDJSON_GETPOINTER(
Ch, data_.s.str); }
2110 RAPIDJSON_FORCEINLINE
const Ch* SetStringPointer(
const Ch* str) {
return RAPIDJSON_SETPOINTER(
Ch, data_.s.str, str); }
2111 RAPIDJSON_FORCEINLINE
GenericValue* GetElementsPointer()
const {
return RAPIDJSON_GETPOINTER(
GenericValue, data_.a.elements); }
2113 RAPIDJSON_FORCEINLINE
Member* GetMembersPointer()
const {
return RAPIDJSON_GETPOINTER(
Member, data_.o.members); }
2114 RAPIDJSON_FORCEINLINE
Member* SetMembersPointer(
Member* members) {
return RAPIDJSON_SETPOINTER(
Member, data_.o.members, members); }
2118 data_.f.flags = kArrayFlag;
2121 SetElementsPointer(e);
2122 std::memcpy(
static_cast<void*
>(e), values, count *
sizeof(
GenericValue));
2125 SetElementsPointer(0);
2126 data_.a.size = data_.a.capacity = count;
2131 data_.f.flags = kObjectFlag;
2134 SetMembersPointer(m);
2135 std::memcpy(
static_cast<void*
>(m), members, count *
sizeof(
Member));
2138 SetMembersPointer(0);
2139 data_.o.size = data_.o.capacity = count;
2144 data_.f.flags = kConstStringFlag;
2145 SetStringPointer(s);
2146 data_.s.length = s.length;
2152 if (ShortString::Usable(s.
length)) {
2153 data_.f.flags = kShortStringFlag;
2154 data_.ss.SetLength(s.
length);
2157 data_.f.flags = kCopyStringFlag;
2158 data_.s.length = s.
length;
2159 str =
static_cast<Ch *
>(allocator.Malloc((s.
length + 1) *
sizeof(
Ch)));
2160 SetStringPointer(str);
2162 std::memcpy(str, s, s.
length *
sizeof(
Ch));
2170 rhs.data_.f.flags = kNullFlag;
2173 template <
typename SourceAllocator>
2178 const SizeType len1 = GetStringLength();
2179 const SizeType len2 = rhs.GetStringLength();
2180 if(len1 != len2) {
return false; }
2182 const Ch*
const str1 = GetString();
2183 const Ch*
const str2 = rhs.GetString();
2184 if(str1 == str2) {
return true; }
2186 return (std::memcmp(str1, str2,
sizeof(
Ch) * len1) == 0);
2206template <
typename Encoding,
typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR,
typename StackAllocator = RAPIDJSON_DEFAULT_STACK_ALLOCATOR >
2209 typedef typename Encoding::Ch
Ch;
2234 allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
2240#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2243 :
ValueType(std::forward<ValueType>(rhs)),
2244 allocator_(rhs.allocator_),
2245 ownAllocator_(rhs.ownAllocator_),
2246 stack_(std::move(rhs.stack_)),
2247 parseResult_(rhs.parseResult_)
2250 rhs.ownAllocator_ = 0;
2259#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2270 allocator_ = rhs.allocator_;
2271 ownAllocator_ = rhs.ownAllocator_;
2272 stack_ = std::move(rhs.stack_);
2273 parseResult_ = rhs.parseResult_;
2276 rhs.ownAllocator_ = 0;
2290 ValueType::Swap(rhs);
2291 stack_.Swap(rhs.stack_);
2292 internal::Swap(allocator_, rhs.allocator_);
2293 internal::Swap(ownAllocator_, rhs.ownAllocator_);
2294 internal::Swap(parseResult_, rhs.parseResult_);
2300 using ValueType::Swap;
2321 template <
typename Generator>
2323 ClearStackOnExit scope(*
this);
2341 template <
unsigned parseFlags,
typename SourceEncoding,
typename InputStream>
2344 stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
2345 ClearStackOnExit scope(*
this);
2360 template <
unsigned parseFlags,
typename InputStream>
2370 template <
typename InputStream>
2384 template <
unsigned parseFlags>
2407 template <
unsigned parseFlags,
typename SourceEncoding>
2418 template <
unsigned parseFlags>
2430 template <
unsigned parseFlags,
typename SourceEncoding>
2433 MemoryStream ms(
reinterpret_cast<const char*
>(str), length *
sizeof(
typename SourceEncoding::Ch));
2439 template <
unsigned parseFlags>
2448#if RAPIDJSON_HAS_STDSTRING
2449 template <
unsigned parseFlags,
typename SourceEncoding>
2455 template <
unsigned parseFlags>
2505 struct ClearStackOnExit {
2507 ~ClearStackOnExit() { d_.ClearStack(); }
2509 ClearStackOnExit(
const ClearStackOnExit&);
2510 ClearStackOnExit& operator=(
const ClearStackOnExit&);
2516 template <
typename,
typename>
friend class GenericValue;
2520 bool Null() {
new (stack_.template Push<ValueType>())
ValueType();
return true; }
2521 bool Bool(
bool b) {
new (stack_.template Push<ValueType>())
ValueType(b);
return true; }
2522 bool Int(
int i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2523 bool Uint(
unsigned i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2524 bool Int64(int64_t i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2525 bool Uint64(uint64_t i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2526 bool Double(
double d) {
new (stack_.template Push<ValueType>())
ValueType(d);
return true; }
2528 bool RawNumber(
const Ch* str,
SizeType length,
bool copy) {
2532 new (stack_.template Push<ValueType>())
ValueType(str, length);
2536 bool String(
const Ch* str,
SizeType length,
bool copy) {
2540 new (stack_.template Push<ValueType>())
ValueType(str, length);
2544 bool StartObject() {
new (stack_.template Push<ValueType>())
ValueType(
kObjectType);
return true; }
2546 bool Key(
const Ch* str,
SizeType length,
bool copy) {
return String(str, length, copy); }
2548 bool EndObject(
SizeType memberCount) {
2549 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
2550 stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount,
GetAllocator());
2554 bool StartArray() {
new (stack_.template Push<ValueType>())
ValueType(
kArrayType);
return true; }
2556 bool EndArray(
SizeType elementCount) {
2557 ValueType* elements = stack_.template Pop<ValueType>(elementCount);
2558 stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount,
GetAllocator());
2569 if (Allocator::kNeedFree)
2570 while (stack_.GetSize() > 0)
2571 (stack_.template Pop<ValueType>(1))->~
ValueType();
2574 stack_.ShrinkToFit();
2581 static const size_t kDefaultStackCapacity = 1024;
2597template <
bool Const,
typename ValueT>
2602 typedef ValueT PlainType;
2603 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
2604 typedef ValueType* ValueIterator;
2605 typedef const ValueT* ConstValueIterator;
2606 typedef typename ValueType::AllocatorType AllocatorType;
2607 typedef typename ValueType::StringRefType StringRefType;
2609 template <
typename,
typename>
2616 operator ValueType&()
const {
return value_; }
2617 SizeType Size()
const {
return value_.Size(); }
2618 SizeType Capacity()
const {
return value_.Capacity(); }
2619 bool Empty()
const {
return value_.Empty(); }
2620 void Clear()
const { value_.Clear(); }
2621 ValueType& operator[](
SizeType index)
const {
return value_[index]; }
2622 ValueIterator Begin()
const {
return value_.Begin(); }
2623 ValueIterator End()
const {
return value_.End(); }
2624 GenericArray Reserve(
SizeType newCapacity, AllocatorType &allocator)
const { value_.Reserve(newCapacity, allocator);
return *
this; }
2625 GenericArray PushBack(ValueType& value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2626#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2627 GenericArray PushBack(ValueType&& value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2629 GenericArray PushBack(StringRefType value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2630 template <
typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,
internal::IsGenericValue<T> >), (
const GenericArray&)) PushBack(T value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2631 GenericArray PopBack()
const { value_.PopBack();
return *
this; }
2632 ValueIterator Erase(ConstValueIterator pos)
const {
return value_.Erase(pos); }
2633 ValueIterator Erase(ConstValueIterator first, ConstValueIterator last)
const {
return value_.Erase(first, last); }
2635#if RAPIDJSON_HAS_CXX11_RANGE_FOR
2636 ValueIterator begin()
const {
return value_.Begin(); }
2637 ValueIterator end()
const {
return value_.End(); }
2651template <
bool Const,
typename ValueT>
2656 typedef ValueT PlainType;
2657 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
2660 typedef typename ValueType::AllocatorType AllocatorType;
2661 typedef typename ValueType::StringRefType StringRefType;
2662 typedef typename ValueType::EncodingType EncodingType;
2663 typedef typename ValueType::Ch Ch;
2665 template <
typename,
typename>
2672 operator ValueType&()
const {
return value_; }
2673 SizeType MemberCount()
const {
return value_.MemberCount(); }
2674 SizeType MemberCapacity()
const {
return value_.MemberCapacity(); }
2675 bool ObjectEmpty()
const {
return value_.ObjectEmpty(); }
2676 template <
typename T> ValueType& operator[](T* name)
const {
return value_[name]; }
2678#if RAPIDJSON_HAS_STDSTRING
2679 ValueType& operator[](
const std::basic_string<Ch>& name)
const {
return value_[name]; }
2681 MemberIterator MemberBegin()
const {
return value_.MemberBegin(); }
2683 GenericObject MemberReserve(
SizeType newCapacity, AllocatorType &allocator)
const { value_.MemberReserve(newCapacity, allocator);
return *
this; }
2684 bool HasMember(
const Ch* name)
const {
return value_.HasMember(name); }
2685#if RAPIDJSON_HAS_STDSTRING
2686 bool HasMember(
const std::basic_string<Ch>& name)
const {
return value_.HasMember(name); }
2689 MemberIterator FindMember(
const Ch* name)
const {
return value_.FindMember(name); }
2691#if RAPIDJSON_HAS_STDSTRING
2692 MemberIterator FindMember(
const std::basic_string<Ch>& name)
const {
return value_.FindMember(name); }
2694 GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2695 GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2696#if RAPIDJSON_HAS_STDSTRING
2697 GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2699 template <
typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,
internal::IsGenericValue<T> >), (ValueType&)) AddMember(ValueType& name, T value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2700#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2701 GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2702 GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2703 GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2704 GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2706 GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2707 GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2708 template <
typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,
internal::IsGenericValue<T> >), (
GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2709 void RemoveAllMembers() { value_.RemoveAllMembers(); }
2710 bool RemoveMember(
const Ch* name)
const {
return value_.RemoveMember(name); }
2711#if RAPIDJSON_HAS_STDSTRING
2712 bool RemoveMember(
const std::basic_string<Ch>& name)
const {
return value_.RemoveMember(name); }
2718 bool EraseMember(
const Ch* name)
const {
return value_.EraseMember(name); }
2719#if RAPIDJSON_HAS_STDSTRING
2720 bool EraseMember(
const std::basic_string<Ch>& name)
const {
return EraseMember(ValueType(
StringRef(name))); }
2724#if RAPIDJSON_HAS_CXX11_RANGE_FOR
Helper class for accessing Value of array type.
Definition document.h:2598
A document for parsing JSON text as DOM.
Definition document.h:2207
friend void swap(GenericDocument &a, GenericDocument &b) RAPIDJSON_NOEXCEPT
free-standing swap function helper
Definition document.h:2314
Allocator & GetAllocator()
Get the allocator of this document.
Definition document.h:2495
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string.
Definition document.h:2385
Encoding::Ch Ch
Character type derived from Encoding.
Definition document.h:2209
GenericDocument & Swap(GenericDocument &rhs) RAPIDJSON_NOEXCEPT
Exchange the contents of this document with those of another.
Definition document.h:2289
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string.
Definition document.h:2419
GenericDocument(Type type, Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
Definition document.h:2220
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
Definition document.h:2471
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream.
Definition document.h:2361
GenericDocument(Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
Definition document.h:2233
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with kParseDefaultFlags)
Definition document.h:2371
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with Encoding conversion)
Definition document.h:2342
GenericDocument & Parse(const typename SourceEncoding::Ch *str)
Parse JSON text from a read-only string (with Encoding conversion)
Definition document.h:2408
ParseErrorCode GetParseError() const
Get the ParseErrorCode of last parsing.
Definition document.h:2474
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string (with kParseDefaultFlags)
Definition document.h:2394
size_t GetStackCapacity() const
Get the capacity of stack in bytes.
Definition document.h:2501
GenericDocument & Populate(Generator &g)
Populate this document by a generator which produces SAX events.
Definition document.h:2322
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
Definition document.h:2477
Allocator AllocatorType
Allocator type from template parameter.
Definition document.h:2211
GenericValue< Encoding, Allocator > ValueType
Value type of the document.
Definition document.h:2210
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string (with kParseDefaultFlags)
Definition document.h:2426
Name-value pair in a JSON object value.
Definition document.h:112
GenericValue< Encoding, Allocator > name
name of member (must be a string)
Definition document.h:114
GenericValue< Encoding, Allocator > value
value of member.
Definition document.h:115
GenericMember & operator=(GenericMember &rhs) RAPIDJSON_NOEXCEPT
Assignment with move semantics.
Definition document.h:134
(Constant) member iterator for a JSON object value
Definition document.h:178
difference_type DifferenceType
Signed integer type (e.g. ptrdiff_t)
Definition document.h:208
GenericMemberIterator< true, Encoding, Allocator > ConstIterator
Constant iterator type.
Definition document.h:190
GenericMemberIterator(const NonConstIterator &it)
Iterator conversions to more const.
Definition document.h:232
GenericMemberIterator()
Default constructor (singular value)
Definition document.h:214
GenericMemberIterator Iterator
Iterator type itself.
Definition document.h:188
GenericMemberIterator< false, Encoding, Allocator > NonConstIterator
Non-constant iterator type.
Definition document.h:192
reference Reference
Reference to (const) GenericMember.
Definition document.h:206
DifferenceType operator-(ConstIterator that) const
Distance.
Definition document.h:274
pointer Pointer
Pointer to (const) GenericMember.
Definition document.h:204
Helper class for accessing Value of object type.
Definition document.h:2652
Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
Definition pointer.h:79
SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator.
Definition reader.h:539
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
Definition document.h:660
Encoding EncodingType
Encoding type from template parameter.
Definition document.h:664
GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame< bool, T >))) RAPIDJSON_NOEXCEPT
Constructor for boolean value.
Definition document.h:783
void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT
Initialize this value as constant string, without calling destructor.
Definition document.h:2143
~GenericValue()
Destructor.
Definition document.h:882
GenericValue(double d) RAPIDJSON_NOEXCEPT
Constructor for double value.
Definition document.h:833
void SetObjectRaw(Member *members, SizeType count, Allocator &allocator)
Initialize this value as object with initial data, without calling destructor.
Definition document.h:2130
GenericValue & operator=(StringRefType str) RAPIDJSON_NOEXCEPT
Assignment of constant string reference (no copy)
Definition document.h:938
GenericMember< Encoding, Allocator > Member
Name-value pair in an object.
Definition document.h:663
Encoding::Ch Ch
Character type derived from Encoding.
Definition document.h:666
RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer< T >),(GenericValue &)) operator
Assignment with primitive types.
GenericValue(const Ch *s, SizeType length) RAPIDJSON_NOEXCEPT
Constructor for constant string (i.e. do not make a copy of string)
Definition document.h:839
GenericValue * ValueIterator
Value iterator for iterating in array.
Definition document.h:670
GenericStringRef< Ch > StringRefType
Reference to a constant string.
Definition document.h:667
GenericValue(const GenericValue< Encoding, SourceAllocator > &rhs, Allocator &allocator, bool copyConstStrings=false)
Explicit copy constructor (with allocator)
Definition document.h:734
Allocator AllocatorType
Allocator type from template parameter.
Definition document.h:665
GenericValue(Type type) RAPIDJSON_NOEXCEPT
Constructor with JSON value type.
Definition document.h:712
GenericValue(Array a) RAPIDJSON_NOEXCEPT
Constructor for Array.
Definition document.h:863
GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT
Constructor for int64_t value.
Definition document.h:806
GenericValue(unsigned u) RAPIDJSON_NOEXCEPT
Constructor for unsigned value.
Definition document.h:800
GenericValue(const Ch *s, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
Definition document.h:848
GenericValue(Object o) RAPIDJSON_NOEXCEPT
Constructor for Object.
Definition document.h:874
GenericValue(const Ch *s, SizeType length, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
Definition document.h:845
GenericMemberIterator< false, Encoding, Allocator >::Iterator MemberIterator
Member iterator for iterating in object.
Definition document.h:668
GenericValue(int i) RAPIDJSON_NOEXCEPT
Constructor for int value.
Definition document.h:794
GenericValue() RAPIDJSON_NOEXCEPT
Default constructor creates a null value.
Definition document.h:682
GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT
Constructor for constant string (i.e. do not make a copy of string)
Definition document.h:842
void RawAssign(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment without calling destructor.
Definition document.h:2167
GenericValue(float f) RAPIDJSON_NOEXCEPT
Constructor for float value.
Definition document.h:836
GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT
Constructor for uint64_t value.
Definition document.h:821
void SetStringRaw(StringRefType s, Allocator &allocator)
Initialize this value as copy string with initial data, without calling destructor.
Definition document.h:2150
GenericValue & operator=(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment with move semantics.
Definition document.h:918
GenericValue< Encoding, Allocator > ValueType
Value type of itself.
Definition document.h:672
GenericMemberIterator< true, Encoding, Allocator >::Iterator ConstMemberIterator
Constant member iterator for iterating in object.
Definition document.h:669
const GenericValue * ConstValueIterator
Constant value iterator for iterating in array.
Definition document.h:671
A type-unsafe stack for storing different types of data.
Definition stack.h:37
Concept for allocating, resizing and freeing memory block.
Concept for encoding of Unicode characters.
Concept for receiving events from GenericReader upon parsing. The functions return true if no error o...
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition document.h:2193
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
Definition document.h:446
GenericDocument< UTF8<> > Document
GenericDocument with UTF8 encoding.
Definition document.h:2589
#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
User defined kDefaultArrayCapacity value.
Definition document.h:102
#define RAPIDJSON_NOEXCEPT_ASSERT(x)
Assertion (in non-throwing contexts).
Definition rapidjson.h:638
#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
User defined kDefaultObjectCapacity value.
Definition document.h:91
#define RAPIDJSON_LIKELY(x)
Compiler branching hint for expression with high probability to be true.
Definition rapidjson.h:463
#define RAPIDJSON_UNLIKELY(x)
Compiler branching hint for expression with low probability to be true.
Definition rapidjson.h:476
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition rapidjson.h:406
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
Definition rapidjson.h:121
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Definition rapidjson.h:124
ParseErrorCode
Error code of parsing.
Definition error.h:64
Type
Type of JSON value.
Definition rapidjson.h:680
@ kFalseType
false
Definition rapidjson.h:682
@ kObjectType
object
Definition rapidjson.h:684
@ kTrueType
true
Definition rapidjson.h:683
@ kStringType
string
Definition rapidjson.h:686
@ kNullType
null
Definition rapidjson.h:681
@ kArrayType
array
Definition rapidjson.h:685
@ kNumberType
number
Definition rapidjson.h:687
#define RAPIDJSON_DELETE(x)
! customization point for global delete
Definition rapidjson.h:667
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition rapidjson.h:384
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition rapidjson.h:289
#define RAPIDJSON_NEW(TypeName)
! customization point for global new
Definition rapidjson.h:663
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
Definition rapidjson.h:445
@ kParseInsituFlag
In-situ(destructive) parsing.
Definition reader.h:148
Definition gtest_pred_impl_unittest.cc:56
A read-write string stream.
Definition stream.h:188
Reference to a constant string (not taking a copy)
Definition document.h:338
CharType Ch
character type of the string
Definition document.h:339
const SizeType length
length of the string (excluding the trailing NULL terminator)
Definition document.h:412
GenericStringRef< CharType > StringRef(const CharType *str, size_t length)
Mark a character pointer as constant string.
Definition document.h:466
GenericStringRef(const CharType *str, SizeType len)
Create constant string reference from pointer and length.
Definition document.h:403
GenericStringRef(const CharType *str)
Explicitly create string reference from const character pointer.
Definition document.h:391
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
Definition document.h:446
GenericStringRef(const CharType(&str)[N]) RAPIDJSON_NOEXCEPT
Create string reference from const character array.
Definition document.h:367
const Ch *const s
plain CharType pointer
Definition document.h:411
Read-only string stream.
Definition stream.h:154
Definition document.h:2094
Definition document.h:2028
Definition document.h:2065
Definition document.h:2069
Definition document.h:2088
Definition document.h:2053
Definition document.h:2039
SizeType hashcode
reserved
Definition document.h:2041
Represents an in-memory input byte stream.
Definition memorystream.h:40
Result of parsing (wraps ParseErrorCode)
Definition error.h:106
ParseErrorCode Code() const
Get the error code.
Definition error.h:116
bool IsError() const
Whether the result is an error.
Definition error.h:123
size_t Offset() const
Get the error offset, if IsError(), 0 otherwise.
Definition error.h:118
Definition document.h:501
Definition document.h:494
Definition document.h:511
Definition document.h:2100
Definition document.h:2063