15#ifndef RAPIDJSON_DOCUMENT_H_
16#define RAPIDJSON_DOCUMENT_H_
21#include "internal/meta.h"
22#include "internal/strfunc.h"
23#include "memorystream.h"
24#include "encodedstream.h"
27#ifdef __cpp_lib_three_way_comparison
33RAPIDJSON_DIAG_OFF(padded)
34RAPIDJSON_DIAG_OFF(
switch-
enum)
35RAPIDJSON_DIAG_OFF(c++98-compat)
36#elif defined(_MSC_VER)
37RAPIDJSON_DIAG_OFF(4127)
38RAPIDJSON_DIAG_OFF(4244)
42RAPIDJSON_DIAG_OFF(effc++)
45#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
49#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
56template <
typename Encoding,
typename Allocator>
59template <
typename Encoding,
typename Allocator,
typename StackAllocator>
68#ifndef RAPIDJSON_DEFAULT_ALLOCATOR
69#define RAPIDJSON_DEFAULT_ALLOCATOR MemoryPoolAllocator<CrtAllocator>
78#ifndef RAPIDJSON_DEFAULT_STACK_ALLOCATOR
79#define RAPIDJSON_DEFAULT_STACK_ALLOCATOR CrtAllocator
88#ifndef RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
90#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY 16
99#ifndef RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
101#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY 16
110template <
typename Encoding,
typename Allocator>
116#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
119 :
name(std::move(rhs.name)),
120 value(std::move(rhs.value))
144 a.value.Swap(b.value);
155#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
176template <
bool Const,
typename Encoding,
typename Allocator>
183 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
195 typedef ValueType value_type;
196 typedef ValueType * pointer;
197 typedef ValueType & reference;
198 typedef std::ptrdiff_t difference_type;
199 typedef std::random_access_iterator_tag iterator_category;
236 Iterator& operator++(){ ++ptr_;
return *
this; }
237 Iterator& operator--(){ --ptr_;
return *
this; }
260#ifdef __cpp_lib_three_way_comparison
267 Reference operator*()
const {
return *ptr_; }
268 Pointer operator->()
const {
return ptr_; }
286template <
bool Const,
typename Encoding,
typename Allocator>
290template <
typename Encoding,
typename Allocator>
296template <
typename Encoding,
typename Allocator>
334template<
typename CharType>
389 :
s(str),
length(NotNullStrLen(str)) {}
406 operator const Ch *()
const {
return s; }
412 SizeType NotNullStrLen(
const CharType* str) {
414 return internal::StrLen(str);
418 static const Ch emptyString[];
427template<
typename CharType>
442template<
typename CharType>
462template<
typename CharType>
467#if RAPIDJSON_HAS_STDSTRING
480template<
typename CharType>
490template <
typename T,
typename Encoding =
void,
typename Allocator =
void>
495 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>
::Type {};
507template <
typename ValueType,
typename T>
510template<
typename ValueType>
512 static bool Is(
const ValueType& v) {
return v.IsBool(); }
513 static bool Get(
const ValueType& v) {
return v.GetBool(); }
514 static ValueType& Set(ValueType& v,
bool data) {
return v.SetBool(data); }
515 static ValueType& Set(ValueType& v,
bool data,
typename ValueType::AllocatorType&) {
return v.SetBool(data); }
518template<
typename ValueType>
520 static bool Is(
const ValueType& v) {
return v.IsInt(); }
521 static int Get(
const ValueType& v) {
return v.GetInt(); }
522 static ValueType& Set(ValueType& v,
int data) {
return v.SetInt(data); }
523 static ValueType& Set(ValueType& v,
int data,
typename ValueType::AllocatorType&) {
return v.SetInt(data); }
526template<
typename ValueType>
528 static bool Is(
const ValueType& v) {
return v.IsUint(); }
529 static unsigned Get(
const ValueType& v) {
return v.GetUint(); }
530 static ValueType& Set(ValueType& v,
unsigned data) {
return v.SetUint(data); }
531 static ValueType& Set(ValueType& v,
unsigned data,
typename ValueType::AllocatorType&) {
return v.SetUint(data); }
536template<
typename ValueType>
538 static bool Is(
const ValueType& v) {
return v.IsInt(); }
539 static long Get(
const ValueType& v) {
return v.GetInt(); }
540 static ValueType& Set(ValueType& v,
long data) {
return v.SetInt(data); }
541 static ValueType& Set(ValueType& v,
long data,
typename ValueType::AllocatorType&) {
return v.SetInt(data); }
545template<
typename ValueType>
546struct TypeHelper<ValueType, unsigned long> {
547 static bool Is(
const ValueType& v) {
return v.IsUint(); }
548 static unsigned long Get(
const ValueType& v) {
return v.GetUint(); }
549 static ValueType& Set(ValueType& v,
unsigned long data) {
return v.SetUint(data); }
550 static ValueType& Set(ValueType& v,
unsigned long data,
typename ValueType::AllocatorType&) {
return v.SetUint(data); }
554template<
typename ValueType>
556 static bool Is(
const ValueType& v) {
return v.IsInt64(); }
557 static int64_t Get(
const ValueType& v) {
return v.GetInt64(); }
558 static ValueType& Set(ValueType& v, int64_t data) {
return v.SetInt64(data); }
559 static ValueType& Set(ValueType& v, int64_t data,
typename ValueType::AllocatorType&) {
return v.SetInt64(data); }
562template<
typename ValueType>
564 static bool Is(
const ValueType& v) {
return v.IsUint64(); }
565 static uint64_t Get(
const ValueType& v) {
return v.GetUint64(); }
566 static ValueType& Set(ValueType& v, uint64_t data) {
return v.SetUint64(data); }
567 static ValueType& Set(ValueType& v, uint64_t data,
typename ValueType::AllocatorType&) {
return v.SetUint64(data); }
570template<
typename ValueType>
572 static bool Is(
const ValueType& v) {
return v.IsDouble(); }
573 static double Get(
const ValueType& v) {
return v.GetDouble(); }
574 static ValueType& Set(ValueType& v,
double data) {
return v.SetDouble(data); }
575 static ValueType& Set(ValueType& v,
double data,
typename ValueType::AllocatorType&) {
return v.SetDouble(data); }
578template<
typename ValueType>
580 static bool Is(
const ValueType& v) {
return v.IsFloat(); }
581 static float Get(
const ValueType& v) {
return v.GetFloat(); }
582 static ValueType& Set(ValueType& v,
float data) {
return v.SetFloat(data); }
583 static ValueType& Set(ValueType& v,
float data,
typename ValueType::AllocatorType&) {
return v.SetFloat(data); }
586template<
typename ValueType>
588 typedef const typename ValueType::Ch* StringType;
589 static bool Is(
const ValueType& v) {
return v.IsString(); }
590 static StringType Get(
const ValueType& v) {
return v.GetString(); }
591 static ValueType& Set(ValueType& v,
const StringType data) {
return v.SetString(
typename ValueType::StringRefType(data)); }
592 static ValueType& Set(ValueType& v,
const StringType data,
typename ValueType::AllocatorType& a) {
return v.SetString(data, a); }
595#if RAPIDJSON_HAS_STDSTRING
596template<
typename ValueType>
597struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
598 typedef std::basic_string<typename ValueType::Ch> StringType;
599 static bool Is(
const ValueType& v) {
return v.IsString(); }
600 static StringType Get(
const ValueType& v) {
return StringType(v.GetString(), v.GetStringLength()); }
601 static ValueType& Set(ValueType& v,
const StringType& data,
typename ValueType::AllocatorType& a) {
return v.SetString(data, a); }
605template<
typename ValueType>
607 typedef typename ValueType::Array ArrayType;
608 static bool Is(
const ValueType& v) {
return v.IsArray(); }
609 static ArrayType Get(ValueType& v) {
return v.GetArray(); }
610 static ValueType& Set(ValueType& v, ArrayType data) {
return v = data; }
611 static ValueType& Set(ValueType& v, ArrayType data,
typename ValueType::AllocatorType&) {
return v = data; }
614template<
typename ValueType>
615struct TypeHelper<ValueType, typename ValueType::ConstArray> {
616 typedef typename ValueType::ConstArray ArrayType;
617 static bool Is(
const ValueType& v) {
return v.IsArray(); }
618 static ArrayType Get(
const ValueType& v) {
return v.GetArray(); }
621template<
typename ValueType>
623 typedef typename ValueType::Object ObjectType;
624 static bool Is(
const ValueType& v) {
return v.IsObject(); }
625 static ObjectType Get(ValueType& v) {
return v.GetObject(); }
626 static ValueType& Set(ValueType& v, ObjectType data) {
return v = data; }
627 static ValueType& Set(ValueType& v, ObjectType data,
typename ValueType::AllocatorType&) {
return v = data; }
630template<
typename ValueType>
631struct TypeHelper<ValueType, typename ValueType::ConstObject> {
632 typedef typename ValueType::ConstObject ObjectType;
633 static bool Is(
const ValueType& v) {
return v.IsObject(); }
634 static ObjectType Get(
const ValueType& v) {
return v.GetObject(); }
656template <
typename Encoding,
typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR >
663 typedef typename Encoding::Ch
Ch;
679 GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }
681#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
684 rhs.data_.f.flags = kNullFlag;
692#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
694 template <
typename StackAllocator>
698 template <
typename StackAllocator>
710 static const uint16_t defaultFlags[] = {
711 kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
715 data_.f.flags = defaultFlags[type];
719 data_.ss.SetLength(0);
730 template <
typename SourceAllocator>
732 switch (rhs.GetType()) {
737 for (
SizeType i = 0; i < count; i++) {
741 data_.f.flags = kObjectFlag;
742 data_.o.size = data_.o.capacity = count;
743 SetMembersPointer(lm);
750 for (
SizeType i = 0; i < count; i++)
751 new (&le[i])
GenericValue(re[i], allocator, copyConstStrings);
752 data_.f.flags = kArrayFlag;
753 data_.a.size = data_.a.capacity = count;
754 SetElementsPointer(le);
758 if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {
759 data_.f.flags = rhs.data_.f.flags;
760 data_ = *
reinterpret_cast<const Data*
>(&rhs.data_);
766 data_.f.flags = rhs.data_.f.flags;
767 data_ = *
reinterpret_cast<const Data*
>(&rhs.data_);
778#ifndef RAPIDJSON_DOXYGEN_RUNNING
779 template <
typename T>
780 explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) RAPIDJSON_NOEXCEPT
787 data_.f.flags = b ? kTrueFlag : kFalseFlag;
793 data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
799 data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
805 data_.f.flags = kNumberInt64Flag;
807 data_.f.flags |= kNumberUint64Flag;
809 data_.f.flags |= kUintFlag;
811 data_.f.flags |= kIntFlag;
814 data_.f.flags |= kIntFlag;
820 data_.f.flags = kNumberUint64Flag;
822 data_.f.flags |= kInt64Flag;
824 data_.f.flags |= kUintFlag;
826 data_.f.flags |= kIntFlag;
830 explicit GenericValue(
double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }
833 explicit GenericValue(
float f) RAPIDJSON_NOEXCEPT : data_() { data_.n.d =
static_cast<double>(f); data_.f.flags = kNumberDoubleFlag; }
847#if RAPIDJSON_HAS_STDSTRING
861 a.value_.data_ =
Data();
862 a.value_.data_.f.flags = kArrayFlag;
872 o.value_.data_ =
Data();
873 o.value_.data_.f.flags = kObjectFlag;
880 if (Allocator::kNeedFree) {
881 switch(data_.f.flags) {
894 Allocator::Free(GetMembersPointer());
897 case kCopyStringFlag:
898 Allocator::Free(
const_cast<Ch*
>(GetStringPointer()));
923#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
926 return *
this = rhs.Move();
952 template <
typename T>
966 template <
typename SourceAllocator>
968 RAPIDJSON_ASSERT(
static_cast<void*
>(
this) !=
static_cast<void const*
>(&rhs));
970 new (
this)
GenericValue(rhs, allocator, copyConstStrings);
983 other.RawAssign(temp);
1003 GenericValue& Move() RAPIDJSON_NOEXCEPT {
return *
this; }
1013 template <
typename SourceAllocator>
1016 if (GetType() != rhs.GetType())
1019 switch (GetType()) {
1021 if (data_.o.size != rhs.data_.o.size)
1023 for (
ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
1024 typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
1025 if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
1031 if (data_.a.size != rhs.data_.a.size)
1033 for (
SizeType i = 0; i < data_.a.size; i++)
1034 if ((*
this)[i] != rhs[i])
1039 return StringEqual(rhs);
1042 if (IsDouble() || rhs.IsDouble()) {
1043 double a = GetDouble();
1044 double b = rhs.GetDouble();
1045 return a >= b && a <= b;
1048 return data_.n.u64 == rhs.data_.n.u64;
1058#if RAPIDJSON_HAS_STDSTRING
1062 bool operator==(
const std::basic_string<Ch>& rhs)
const {
return *
this ==
GenericValue(
StringRef(rhs)); }
1073 template <
typename SourceAllocator>
1077 bool operator!=(
const Ch* rhs)
const {
return !(*
this == rhs); }
1098 Type GetType()
const {
return static_cast<Type>(data_.f.flags & kTypeMask); }
1099 bool IsNull()
const {
return data_.f.flags == kNullFlag; }
1100 bool IsFalse()
const {
return data_.f.flags == kFalseFlag; }
1101 bool IsTrue()
const {
return data_.f.flags == kTrueFlag; }
1102 bool IsBool()
const {
return (data_.f.flags & kBoolFlag) != 0; }
1103 bool IsObject()
const {
return data_.f.flags == kObjectFlag; }
1104 bool IsArray()
const {
return data_.f.flags == kArrayFlag; }
1105 bool IsNumber()
const {
return (data_.f.flags & kNumberFlag) != 0; }
1106 bool IsInt()
const {
return (data_.f.flags & kIntFlag) != 0; }
1107 bool IsUint()
const {
return (data_.f.flags & kUintFlag) != 0; }
1108 bool IsInt64()
const {
return (data_.f.flags & kInt64Flag) != 0; }
1109 bool IsUint64()
const {
return (data_.f.flags & kUint64Flag) != 0; }
1110 bool IsDouble()
const {
return (data_.f.flags & kDoubleFlag) != 0; }
1111 bool IsString()
const {
return (data_.f.flags & kStringFlag) != 0; }
1114 bool IsLosslessDouble()
const {
1115 if (!IsNumber())
return false;
1117 uint64_t u = GetUint64();
1118 volatile double d =
static_cast<double>(u);
1120 && (d < static_cast<double>((std::numeric_limits<uint64_t>::max)()))
1121 && (u ==
static_cast<uint64_t
>(d));
1124 int64_t i = GetInt64();
1125 volatile double d =
static_cast<double>(i);
1126 return (d >=
static_cast<double>((std::numeric_limits<int64_t>::min)()))
1127 && (d <
static_cast<double>((std::numeric_limits<int64_t>::max)()))
1128 && (i ==
static_cast<int64_t
>(d));
1134 bool IsFloat()
const {
1135 if ((data_.f.flags & kDoubleFlag) == 0)
1137 double d = GetDouble();
1138 return d >= -3.4028234e38 && d <= 3.4028234e38;
1141 bool IsLosslessFloat()
const {
1142 if (!IsNumber())
return false;
1143 double a = GetDouble();
1144 if (a <
static_cast<double>(-(std::numeric_limits<float>::max)())
1145 || a >
static_cast<double>((std::numeric_limits<float>::max)()))
1147 double b =
static_cast<double>(
static_cast<float>(a));
1148 return a >= b && a <= b;
1163 bool GetBool()
const {
RAPIDJSON_ASSERT(IsBool());
return data_.f.flags == kTrueFlag; }
1184 bool ObjectEmpty()
const {
RAPIDJSON_ASSERT(IsObject());
return data_.o.size == 0; }
1195 template <
typename T>
1200 template <
typename T>
1212 template <
typename SourceAllocator>
1215 if (member != MemberEnd())
1216 return member->value;
1229 template <
typename SourceAllocator>
1232#if RAPIDJSON_HAS_STDSTRING
1259 if (newCapacity > data_.o.capacity) {
1260 SetMembersPointer(
reinterpret_cast<Member*
>(allocator.Realloc(GetMembersPointer(), data_.o.capacity *
sizeof(
Member), newCapacity *
sizeof(
Member))));
1261 data_.o.capacity = newCapacity;
1274 bool HasMember(
const Ch* name)
const {
return FindMember(name) != MemberEnd(); }
1276#if RAPIDJSON_HAS_STDSTRING
1285 bool HasMember(
const std::basic_string<Ch>& name)
const {
return FindMember(name) != MemberEnd(); }
1297 template <
typename SourceAllocator>
1314 return FindMember(n);
1332 template <
typename SourceAllocator>
1337 for ( ; member != MemberEnd(); ++member)
1338 if (name.StringEqual(member->name))
1344#if RAPIDJSON_HAS_STDSTRING
1370 ObjectData& o = data_.o;
1371 if (o.size >= o.capacity)
1372 MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
1373 Member* members = GetMembersPointer();
1374 members[o.size].name.RawAssign(name);
1375 members[o.size].value.RawAssign(value);
1391 return AddMember(name, v, allocator);
1394#if RAPIDJSON_HAS_STDSTRING
1406 return AddMember(name, v, allocator);
1427 template <
typename T>
1431 return AddMember(name, v, allocator);
1434#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
1436 return AddMember(name, value, allocator);
1439 return AddMember(name, value, allocator);
1442 return AddMember(name, value, allocator);
1446 return AddMember(n, value, allocator);
1463 return AddMember(n, value, allocator);
1477 return AddMember(name, v, allocator);
1497 template <
typename T>
1501 return AddMember(n, value, allocator);
1508 void RemoveAllMembers() {
1523 bool RemoveMember(
const Ch* name) {
1525 return RemoveMember(n);
1528#if RAPIDJSON_HAS_STDSTRING
1529 bool RemoveMember(
const std::basic_string<Ch>& name) {
return RemoveMember(
GenericValue(
StringRef(name))); }
1532 template <
typename SourceAllocator>
1535 if (m != MemberEnd()) {
1558 if (data_.o.size > 1 && m != last)
1576 return EraseMember(pos, pos +1);
1599 std::memmove(
static_cast<void*
>(&*pos), &*last,
static_cast<size_t>(MemberEnd() - last) *
sizeof(
Member));
1600 data_.o.size -=
static_cast<SizeType>(last - first);
1609 bool EraseMember(
const Ch* name) {
1611 return EraseMember(n);
1614#if RAPIDJSON_HAS_STDSTRING
1615 bool EraseMember(
const std::basic_string<Ch>& name) {
return EraseMember(
GenericValue(
StringRef(name))); }
1618 template <
typename SourceAllocator>
1621 if (m != MemberEnd()) {
1630 ConstObject GetObject()
const {
RAPIDJSON_ASSERT(IsObject());
return ConstObject(*
this); }
1648 bool Empty()
const {
RAPIDJSON_ASSERT(IsArray());
return data_.a.size == 0; }
1670 return GetElementsPointer()[index];
1695 if (newCapacity > data_.a.capacity) {
1697 data_.a.capacity = newCapacity;
1714 if (data_.a.size >= data_.a.capacity)
1715 Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
1716 GetElementsPointer()[data_.a.size++].
RawAssign(value);
1720#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
1722 return PushBack(value, allocator);
1736 return (*this).template PushBack<StringRefType>(value, allocator);
1756 template <
typename T>
1758 PushBack(T value,
Allocator& allocator) {
1760 return PushBack(v, allocator);
1782 return Erase(pos, pos + 1);
1803 std::memmove(
static_cast<void*
>(pos), last,
static_cast<size_t>(End() - last) *
sizeof(
GenericValue));
1804 data_.a.size -=
static_cast<SizeType>(last - first);
1809 ConstArray GetArray()
const {
RAPIDJSON_ASSERT(IsArray());
return ConstArray(*
this); }
1816 int GetInt()
const {
RAPIDJSON_ASSERT(data_.f.flags & kIntFlag);
return data_.n.i.i; }
1817 unsigned GetUint()
const {
RAPIDJSON_ASSERT(data_.f.flags & kUintFlag);
return data_.n.u.u; }
1818 int64_t GetInt64()
const {
RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag);
return data_.n.i64; }
1819 uint64_t GetUint64()
const {
RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag);
return data_.n.u64; }
1824 double GetDouble()
const {
1826 if ((data_.f.flags & kDoubleFlag) != 0)
return data_.n.d;
1827 if ((data_.f.flags & kIntFlag) != 0)
return data_.n.i.i;
1828 if ((data_.f.flags & kUintFlag) != 0)
return data_.n.u.u;
1829 if ((data_.f.flags & kInt64Flag) != 0)
return static_cast<double>(data_.n.i64);
1830 RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0);
return static_cast<double>(data_.n.u64);
1836 float GetFloat()
const {
1837 return static_cast<float>(GetDouble());
1852 const Ch* GetString()
const {
RAPIDJSON_ASSERT(IsString());
return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); }
1857 SizeType GetStringLength()
const {
RAPIDJSON_ASSERT(IsString());
return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }
1902#if RAPIDJSON_HAS_STDSTRING
1922 template <
typename T>
1925 template <
typename T>
1928 template <
typename T>
1931 template<
typename T>
1934 template<
typename T>
1946 template <
typename Handler>
1947 bool Accept(
Handler& handler)
const {
1951 case kTrueType:
return handler.Bool(
true);
1958 if (
RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
1963 return handler.EndObject(data_.o.size);
1971 return handler.EndArray(data_.a.size);
1974 return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
1978 if (IsDouble())
return handler.Double(data_.n.d);
1979 else if (IsInt())
return handler.Int(data_.n.i.i);
1980 else if (IsUint())
return handler.Uint(data_.n.u.u);
1981 else if (IsInt64())
return handler.Int64(data_.n.i64);
1982 else return handler.Uint64(data_.n.u64);
1987 template <
typename,
typename>
friend class GenericValue;
1992 kNumberFlag = 0x0010,
1995 kInt64Flag = 0x0080,
1996 kUint64Flag = 0x0100,
1997 kDoubleFlag = 0x0200,
1998 kStringFlag = 0x0400,
2000 kInlineStrFlag = 0x1000,
2006 kNumberIntFlag =
kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
2007 kNumberUintFlag =
kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
2008 kNumberInt64Flag =
kNumberType | kNumberFlag | kInt64Flag,
2009 kNumberUint64Flag =
kNumberType | kNumberFlag | kUint64Flag,
2010 kNumberDoubleFlag =
kNumberType | kNumberFlag | kDoubleFlag,
2011 kNumberAnyFlag =
kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
2013 kCopyStringFlag =
kStringType | kStringFlag | kCopyFlag,
2014 kShortStringFlag =
kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
2025#if RAPIDJSON_48BITPOINTER_OPTIMIZATION
2026 char payload[
sizeof(
SizeType) * 2 + 6];
2027#elif RAPIDJSON_64BIT
2028 char payload[
sizeof(
SizeType) * 2 +
sizeof(
void*) + 6];
2030 char payload[
sizeof(
SizeType) * 2 +
sizeof(
void*) + 2];
2050 enum { MaxChars =
sizeof(
static_cast<Flag*
>(0)->payload) /
sizeof(
Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
2053 inline static bool Usable(
SizeType len) {
return (MaxSize >= len); }
2054 inline void SetLength(
SizeType len) { str[LenPos] =
static_cast<Ch>(MaxSize - len); }
2055 inline SizeType GetLength()
const {
return static_cast<SizeType>(MaxSize - str[LenPos]); }
2060#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
2105 RAPIDJSON_FORCEINLINE
const Ch* GetStringPointer()
const {
return RAPIDJSON_GETPOINTER(
Ch, data_.s.str); }
2106 RAPIDJSON_FORCEINLINE
const Ch* SetStringPointer(
const Ch* str) {
return RAPIDJSON_SETPOINTER(
Ch, data_.s.str, str); }
2107 RAPIDJSON_FORCEINLINE
GenericValue* GetElementsPointer()
const {
return RAPIDJSON_GETPOINTER(
GenericValue, data_.a.elements); }
2109 RAPIDJSON_FORCEINLINE
Member* GetMembersPointer()
const {
return RAPIDJSON_GETPOINTER(
Member, data_.o.members); }
2110 RAPIDJSON_FORCEINLINE
Member* SetMembersPointer(
Member* members) {
return RAPIDJSON_SETPOINTER(
Member, data_.o.members, members); }
2114 data_.f.flags = kArrayFlag;
2117 SetElementsPointer(e);
2118 std::memcpy(
static_cast<void*
>(e), values, count *
sizeof(
GenericValue));
2121 SetElementsPointer(0);
2122 data_.a.size = data_.a.capacity = count;
2127 data_.f.flags = kObjectFlag;
2130 SetMembersPointer(m);
2131 std::memcpy(
static_cast<void*
>(m), members, count *
sizeof(
Member));
2134 SetMembersPointer(0);
2135 data_.o.size = data_.o.capacity = count;
2140 data_.f.flags = kConstStringFlag;
2141 SetStringPointer(s);
2142 data_.s.length = s.length;
2148 if (ShortString::Usable(s.
length)) {
2149 data_.f.flags = kShortStringFlag;
2150 data_.ss.SetLength(s.
length);
2153 data_.f.flags = kCopyStringFlag;
2154 data_.s.length = s.
length;
2155 str =
static_cast<Ch *
>(allocator.Malloc((s.
length + 1) *
sizeof(
Ch)));
2156 SetStringPointer(str);
2158 std::memcpy(str, s, s.
length *
sizeof(
Ch));
2166 rhs.data_.f.flags = kNullFlag;
2169 template <
typename SourceAllocator>
2174 const SizeType len1 = GetStringLength();
2175 const SizeType len2 = rhs.GetStringLength();
2176 if(len1 != len2) {
return false; }
2178 const Ch*
const str1 = GetString();
2179 const Ch*
const str2 = rhs.GetString();
2180 if(str1 == str2) {
return true; }
2182 return (std::memcmp(str1, str2,
sizeof(
Ch) * len1) == 0);
2202template <
typename Encoding,
typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR,
typename StackAllocator = RAPIDJSON_DEFAULT_STACK_ALLOCATOR >
2205 typedef typename Encoding::Ch
Ch;
2230 allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
2236#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2239 :
ValueType(std::forward<ValueType>(rhs)),
2240 allocator_(rhs.allocator_),
2241 ownAllocator_(rhs.ownAllocator_),
2242 stack_(std::move(rhs.stack_)),
2243 parseResult_(rhs.parseResult_)
2246 rhs.ownAllocator_ = 0;
2255#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2266 allocator_ = rhs.allocator_;
2267 ownAllocator_ = rhs.ownAllocator_;
2268 stack_ = std::move(rhs.stack_);
2269 parseResult_ = rhs.parseResult_;
2272 rhs.ownAllocator_ = 0;
2286 ValueType::Swap(rhs);
2287 stack_.Swap(rhs.stack_);
2288 internal::Swap(allocator_, rhs.allocator_);
2289 internal::Swap(ownAllocator_, rhs.ownAllocator_);
2290 internal::Swap(parseResult_, rhs.parseResult_);
2296 using ValueType::Swap;
2317 template <
typename Generator>
2319 ClearStackOnExit scope(*
this);
2337 template <
unsigned parseFlags,
typename SourceEncoding,
typename InputStream>
2340 stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
2341 ClearStackOnExit scope(*
this);
2342 parseResult_ = reader.template Parse<parseFlags>(is, *
this);
2356 template <
unsigned parseFlags,
typename InputStream>
2358 return ParseStream<parseFlags, Encoding, InputStream>(is);
2366 template <
typename InputStream>
2368 return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
2380 template <
unsigned parseFlags>
2383 return ParseStream<parseFlags | kParseInsituFlag>(s);
2391 return ParseInsitu<kParseDefaultFlags>(str);
2403 template <
unsigned parseFlags,
typename SourceEncoding>
2407 return ParseStream<parseFlags, SourceEncoding>(s);
2414 template <
unsigned parseFlags>
2416 return Parse<parseFlags, Encoding>(str);
2423 return Parse<kParseDefaultFlags>(str);
2426 template <
unsigned parseFlags,
typename SourceEncoding>
2429 MemoryStream ms(
reinterpret_cast<const char*
>(str), length *
sizeof(
typename SourceEncoding::Ch));
2431 ParseStream<parseFlags, SourceEncoding>(is);
2435 template <
unsigned parseFlags>
2437 return Parse<parseFlags, Encoding>(str, length);
2441 return Parse<kParseDefaultFlags>(str, length);
2444#if RAPIDJSON_HAS_STDSTRING
2445 template <
unsigned parseFlags,
typename SourceEncoding>
2448 return Parse<parseFlags, SourceEncoding>(str.c_str());
2451 template <
unsigned parseFlags>
2453 return Parse<parseFlags, Encoding>(str.c_str());
2457 return Parse<kParseDefaultFlags>(str);
2501 struct ClearStackOnExit {
2503 ~ClearStackOnExit() { d_.ClearStack(); }
2505 ClearStackOnExit(
const ClearStackOnExit&);
2506 ClearStackOnExit& operator=(
const ClearStackOnExit&);
2512 template <
typename,
typename>
friend class GenericValue;
2516 bool Null() {
new (stack_.template Push<ValueType>())
ValueType();
return true; }
2517 bool Bool(
bool b) {
new (stack_.template Push<ValueType>())
ValueType(b);
return true; }
2518 bool Int(
int i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2519 bool Uint(
unsigned i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2520 bool Int64(int64_t i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2521 bool Uint64(uint64_t i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2522 bool Double(
double d) {
new (stack_.template Push<ValueType>())
ValueType(d);
return true; }
2524 bool RawNumber(
const Ch* str,
SizeType length,
bool copy) {
2528 new (stack_.template Push<ValueType>())
ValueType(str, length);
2532 bool String(
const Ch* str,
SizeType length,
bool copy) {
2536 new (stack_.template Push<ValueType>())
ValueType(str, length);
2540 bool StartObject() {
new (stack_.template Push<ValueType>())
ValueType(
kObjectType);
return true; }
2542 bool Key(
const Ch* str,
SizeType length,
bool copy) {
return String(str, length, copy); }
2544 bool EndObject(
SizeType memberCount) {
2545 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
2546 stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount,
GetAllocator());
2550 bool StartArray() {
new (stack_.template Push<ValueType>())
ValueType(
kArrayType);
return true; }
2552 bool EndArray(
SizeType elementCount) {
2553 ValueType* elements = stack_.template Pop<ValueType>(elementCount);
2554 stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount,
GetAllocator());
2565 if (Allocator::kNeedFree)
2566 while (stack_.GetSize() > 0)
2567 (stack_.template Pop<ValueType>(1))->~
ValueType();
2570 stack_.ShrinkToFit();
2577 static const size_t kDefaultStackCapacity = 1024;
2593template <
bool Const,
typename ValueT>
2598 typedef ValueT PlainType;
2599 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
2600 typedef ValueType* ValueIterator;
2601 typedef const ValueT* ConstValueIterator;
2602 typedef typename ValueType::AllocatorType AllocatorType;
2603 typedef typename ValueType::StringRefType StringRefType;
2605 template <
typename,
typename>
2612 SizeType Size()
const {
return value_.Size(); }
2613 SizeType Capacity()
const {
return value_.Capacity(); }
2614 bool Empty()
const {
return value_.Empty(); }
2615 void Clear()
const { value_.Clear(); }
2616 ValueType& operator[](
SizeType index)
const {
return value_[index]; }
2617 ValueIterator Begin()
const {
return value_.Begin(); }
2618 ValueIterator End()
const {
return value_.End(); }
2619 GenericArray Reserve(
SizeType newCapacity, AllocatorType &allocator)
const { value_.Reserve(newCapacity, allocator);
return *
this; }
2620 GenericArray PushBack(ValueType& value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2621#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2622 GenericArray PushBack(ValueType&& value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2624 GenericArray PushBack(StringRefType value, AllocatorType& allocator)
const { value_.PushBack(value, allocator);
return *
this; }
2625 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; }
2626 GenericArray PopBack()
const { value_.PopBack();
return *
this; }
2627 ValueIterator Erase(ConstValueIterator pos)
const {
return value_.Erase(pos); }
2628 ValueIterator Erase(ConstValueIterator first, ConstValueIterator last)
const {
return value_.Erase(first, last); }
2630#if RAPIDJSON_HAS_CXX11_RANGE_FOR
2631 ValueIterator begin()
const {
return value_.Begin(); }
2632 ValueIterator end()
const {
return value_.End(); }
2646template <
bool Const,
typename ValueT>
2651 typedef ValueT PlainType;
2652 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
2655 typedef typename ValueType::AllocatorType AllocatorType;
2656 typedef typename ValueType::StringRefType StringRefType;
2657 typedef typename ValueType::EncodingType EncodingType;
2658 typedef typename ValueType::Ch Ch;
2660 template <
typename,
typename>
2667 SizeType MemberCount()
const {
return value_.MemberCount(); }
2668 SizeType MemberCapacity()
const {
return value_.MemberCapacity(); }
2669 bool ObjectEmpty()
const {
return value_.ObjectEmpty(); }
2670 template <
typename T> ValueType& operator[](T* name)
const {
return value_[name]; }
2672#if RAPIDJSON_HAS_STDSTRING
2673 ValueType& operator[](
const std::basic_string<Ch>& name)
const {
return value_[name]; }
2675 MemberIterator MemberBegin()
const {
return value_.MemberBegin(); }
2677 GenericObject MemberReserve(
SizeType newCapacity, AllocatorType &allocator)
const { value_.MemberReserve(newCapacity, allocator);
return *
this; }
2678 bool HasMember(
const Ch* name)
const {
return value_.HasMember(name); }
2679#if RAPIDJSON_HAS_STDSTRING
2680 bool HasMember(
const std::basic_string<Ch>& name)
const {
return value_.HasMember(name); }
2683 MemberIterator FindMember(
const Ch* name)
const {
return value_.FindMember(name); }
2685#if RAPIDJSON_HAS_STDSTRING
2686 MemberIterator FindMember(
const std::basic_string<Ch>& name)
const {
return value_.FindMember(name); }
2688 GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2689 GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2690#if RAPIDJSON_HAS_STDSTRING
2691 GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2693 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; }
2694#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2695 GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2696 GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2697 GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2698 GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2700 GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2701 GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator)
const { value_.AddMember(name, value, allocator);
return *
this; }
2702 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; }
2703 void RemoveAllMembers() { value_.RemoveAllMembers(); }
2704 bool RemoveMember(
const Ch* name)
const {
return value_.RemoveMember(name); }
2705#if RAPIDJSON_HAS_STDSTRING
2706 bool RemoveMember(
const std::basic_string<Ch>& name)
const {
return value_.RemoveMember(name); }
2712 bool EraseMember(
const Ch* name)
const {
return value_.EraseMember(name); }
2713#if RAPIDJSON_HAS_STDSTRING
2714 bool EraseMember(
const std::basic_string<Ch>& name)
const {
return EraseMember(ValueType(
StringRef(name))); }
2718#if RAPIDJSON_HAS_CXX11_RANGE_FOR
Helper class for accessing Value of array type.
A document for parsing JSON text as DOM.
friend void swap(GenericDocument &a, GenericDocument &b) RAPIDJSON_NOEXCEPT
free-standing swap function helper
Allocator & GetAllocator()
Get the allocator of this document.
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string.
GenericDocument & Swap(GenericDocument &rhs) RAPIDJSON_NOEXCEPT
Exchange the contents of this document with those of another.
Allocator AllocatorType
Allocator type from template parameter.
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string.
GenericDocument(Type type, Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream.
GenericDocument(Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
Encoding::Ch Ch
Character type derived from Encoding.
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with kParseDefaultFlags)
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with Encoding conversion)
GenericValue< Encoding, Allocator > ValueType
Value type of the document.
GenericDocument & Parse(const typename SourceEncoding::Ch *str)
Parse JSON text from a read-only string (with Encoding conversion)
ParseErrorCode GetParseError() const
Get the ParseErrorCode of last parsing.
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string (with kParseDefaultFlags)
size_t GetStackCapacity() const
Get the capacity of stack in bytes.
GenericDocument & Populate(Generator &g)
Populate this document by a generator which produces SAX events.
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string (with kParseDefaultFlags)
(Constant) member iterator for a JSON object value
GenericMemberIterator(const NonConstIterator &it)
Iterator conversions to more const.
GenericMemberIterator()
Default constructor (singular value)
reference Reference
Reference to (const) GenericMember.
difference_type DifferenceType
Signed integer type (e.g. ptrdiff_t)
GenericMemberIterator< false, Encoding, Allocator > NonConstIterator
Non-constant iterator type.
pointer Pointer
Pointer to (const) GenericMember.
GenericMemberIterator Iterator
Iterator type itself.
DifferenceType operator-(ConstIterator that) const
Distance.
GenericMemberIterator< true, Encoding, Allocator > ConstIterator
Constant iterator type.
Name-value pair in a JSON object value.
GenericValue< Encoding, Allocator > name
name of member (must be a string)
GenericValue< Encoding, Allocator > value
value of member.
GenericMember & operator=(GenericMember &rhs) RAPIDJSON_NOEXCEPT
Assignment with move semantics.
Helper class for accessing Value of object type.
Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator.
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame< bool, T >))) RAPIDJSON_NOEXCEPT
Constructor for boolean value.
void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT
Initialize this value as constant string, without calling destructor.
~GenericValue()
Destructor.
GenericValue(double d) RAPIDJSON_NOEXCEPT
Constructor for double value.
void SetObjectRaw(Member *members, SizeType count, Allocator &allocator)
Initialize this value as object with initial data, without calling destructor.
Encoding EncodingType
Encoding type from template parameter.
GenericValue & operator=(StringRefType str) RAPIDJSON_NOEXCEPT
Assignment of constant string reference (no copy)
GenericStringRef< Ch > StringRefType
Reference to a constant string.
GenericMemberIterator< false, Encoding, Allocator >::Iterator MemberIterator
Member iterator for iterating in object.
GenericValue< Encoding, Allocator > ValueType
Value type of itself.
const GenericValue * ConstValueIterator
Constant value iterator for iterating in array.
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)
GenericValue(const GenericValue< Encoding, SourceAllocator > &rhs, Allocator &allocator, bool copyConstStrings=false)
Explicit copy constructor (with allocator)
Allocator AllocatorType
Allocator type from template parameter.
GenericMember< Encoding, Allocator > Member
Name-value pair in an object.
GenericValue(Type type) RAPIDJSON_NOEXCEPT
Constructor with JSON value type.
GenericValue(Array a) RAPIDJSON_NOEXCEPT
Constructor for Array.
GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT
Constructor for int64_t value.
GenericValue(unsigned u) RAPIDJSON_NOEXCEPT
Constructor for unsigned value.
GenericValue(const Ch *s, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
GenericValue(Object o) RAPIDJSON_NOEXCEPT
Constructor for Object.
GenericValue(const Ch *s, SizeType length, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
GenericMemberIterator< true, Encoding, Allocator >::Iterator ConstMemberIterator
Constant member iterator for iterating in object.
GenericValue(int i) RAPIDJSON_NOEXCEPT
Constructor for int value.
GenericValue() RAPIDJSON_NOEXCEPT
Default constructor creates a null value.
GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT
Constructor for constant string (i.e. do not make a copy of string)
void RawAssign(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment without calling destructor.
GenericValue(float f) RAPIDJSON_NOEXCEPT
Constructor for float value.
GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT
Constructor for uint64_t value.
void SetStringRaw(StringRefType s, Allocator &allocator)
Initialize this value as copy string with initial data, without calling destructor.
GenericValue & operator=(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment with move semantics.
Encoding::Ch Ch
Character type derived from Encoding.
GenericValue * ValueIterator
Value iterator for iterating in array.
A type-unsafe stack for storing different types of data.
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.
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
GenericDocument< UTF8<> > Document
GenericDocument with UTF8 encoding.
#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
User defined kDefaultArrayCapacity value.
#define RAPIDJSON_NOEXCEPT_ASSERT(x)
Assertion (in non-throwing contexts).
#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
User defined kDefaultObjectCapacity value.
#define RAPIDJSON_LIKELY(x)
Compiler branching hint for expression with high probability to be true.
#define RAPIDJSON_UNLIKELY(x)
Compiler branching hint for expression with low probability to be true.
#define RAPIDJSON_ASSERT(x)
Assertion.
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
ParseErrorCode
Error code of parsing.
#define RAPIDJSON_DELETE(x)
! customization point for global delete
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
#define RAPIDJSON_NEW(TypeName)
! customization point for global new
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
@ kParseInsituFlag
In-situ(destructive) parsing.
A read-write string stream.
Reference to a constant string (not taking a copy)
CharType Ch
character type of the string
const SizeType length
length of the string (excluding the trailing NULL terminator)
GenericStringRef< CharType > StringRef(const CharType *str, size_t length)
Mark a character pointer as constant string.
GenericStringRef(const CharType *str, SizeType len)
Create constant string reference from pointer and length.
GenericStringRef(const CharType *str)
Explicitly create string reference from const character pointer.
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
GenericStringRef(const CharType(&str)[N]) RAPIDJSON_NOEXCEPT
Create string reference from const character array.
const Ch *const s
plain CharType pointer
SizeType hashcode
reserved
Represents an in-memory input byte stream.
Result of parsing (wraps ParseErrorCode)
ParseErrorCode Code() const
Get the error code.
bool IsError() const
Whether the result is an error.
size_t Offset() const
Get the error offset, if IsError(), 0 otherwise.