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
33 RAPIDJSON_DIAG_OFF(padded)
34 RAPIDJSON_DIAG_OFF(
switch-
enum)
35 RAPIDJSON_DIAG_OFF(c++98-compat)
36 #elif defined(_MSC_VER)
37 RAPIDJSON_DIAG_OFF(4127)
38 RAPIDJSON_DIAG_OFF(4244)
42 RAPIDJSON_DIAG_OFF(effc++)
45 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
49 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
53 RAPIDJSON_NAMESPACE_BEGIN
56 template <
typename Encoding,
typename Allocator>
59 template <
typename Encoding,
typename Allocator,
typename StackAllocator>
60 class GenericDocument;
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
110 template <
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);
149 GenericMember(
const GenericMember& rhs);
155 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
176 template <
bool Const,
typename Encoding,
typename Allocator>
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;
232 Iterator& operator=(
const NonConstIterator & it) { ptr_ = it.ptr_;
return *
this; }
236 Iterator& operator++(){ ++ptr_;
return *
this; }
237 Iterator& operator--(){ --ptr_;
return *
this; }
238 Iterator operator++(
int){ Iterator old(*
this); ++ptr_;
return old; }
239 Iterator operator--(
int){ Iterator old(*
this); --ptr_;
return old; }
244 Iterator operator+(DifferenceType n)
const {
return Iterator(ptr_+n); }
245 Iterator operator-(DifferenceType n)
const {
return Iterator(ptr_-n); }
247 Iterator& operator+=(DifferenceType n) { ptr_+=n;
return *
this; }
248 Iterator& operator-=(DifferenceType n) { ptr_-=n;
return *
this; }
253 template <
bool Const_>
bool operator==(
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ == that.ptr_; }
254 template <
bool Const_>
bool operator!=(
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ != that.ptr_; }
255 template <
bool Const_>
bool operator<=(
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ <= that.ptr_; }
256 template <
bool Const_>
bool operator>=(
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ >= that.ptr_; }
257 template <
bool Const_>
bool operator< (
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ < that.ptr_; }
258 template <
bool Const_>
bool operator> (
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ > that.ptr_; }
260 #ifdef __cpp_lib_three_way_comparison
261 template <
bool Const_> std::strong_ordering operator<=>(
const GenericMemberIterator<Const_, Encoding, Allocator>& that)
const {
return ptr_ <=> that.ptr_; }
267 Reference operator*()
const {
return *ptr_; }
268 Pointer operator->()
const {
return ptr_; }
269 Reference operator[](DifferenceType n)
const {
return ptr_[n]; }
282 #else // RAPIDJSON_NOMEMBERITERATORCLASS
286 template <
bool Const,
typename Encoding,
typename Allocator>
287 class GenericMemberIterator;
290 template <
typename Encoding,
typename Allocator>
293 typedef GenericMember<Encoding,Allocator>* Iterator;
296 template <
typename Encoding,
typename Allocator>
299 typedef const GenericMember<Encoding,Allocator>* Iterator;
302 #endif // RAPIDJSON_NOMEMBERITERATORCLASS
334 template<
typename CharType>
339 #ifndef __clang__ // -Wdocumentation
365 : s(str), length(N-1) {}
368 #ifndef __clang__ // -Wdocumentation
389 : s(str), length(NotNullStrLen(str)) {}
392 #ifndef __clang__ // -Wdocumentation
406 operator const Ch *()
const {
return s; }
412 SizeType NotNullStrLen(
const CharType* str) {
414 return internal::StrLen(str);
418 static const Ch emptyString[];
427 template<
typename CharType>
428 const CharType GenericStringRef<CharType>::emptyString[] = { CharType() };
442 template<
typename CharType>
462 template<
typename CharType>
467 #if RAPIDJSON_HAS_STDSTRING
480 template<
typename CharType>
490 template <
typename T,
typename Encoding =
void,
typename Allocator =
void>
491 struct IsGenericValueImpl : FalseType {};
494 template <
typename T>
struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>
::Type, typename Void<typename T::AllocatorType>
::Type>
495 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>
::Type {};
498 template <
typename T>
struct IsGenericValue : IsGenericValueImpl<T>
::Type {};
507 template <
typename ValueType,
typename T>
508 struct TypeHelper {};
510 template<
typename ValueType>
511 struct TypeHelper<ValueType, bool> {
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); }
518 template<
typename ValueType>
519 struct TypeHelper<ValueType, int> {
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); }
526 template<
typename ValueType>
527 struct TypeHelper<ValueType, unsigned> {
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); }
536 template<
typename ValueType>
537 struct TypeHelper<ValueType, long> {
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); }
545 template<
typename ValueType>
546 struct 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); }
554 template<
typename ValueType>
555 struct TypeHelper<ValueType, int64_t> {
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); }
562 template<
typename ValueType>
563 struct TypeHelper<ValueType, uint64_t> {
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); }
570 template<
typename ValueType>
571 struct TypeHelper<ValueType, double> {
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); }
578 template<
typename ValueType>
579 struct TypeHelper<ValueType, float> {
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); }
586 template<
typename ValueType>
587 struct TypeHelper<ValueType, const typename ValueType::Ch*> {
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
596 template<
typename ValueType>
597 struct 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); }
605 template<
typename ValueType>
606 struct TypeHelper<ValueType, typename ValueType::Array> {
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; }
614 template<
typename ValueType>
615 struct 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(); }
621 template<
typename ValueType>
622 struct TypeHelper<ValueType, typename ValueType::Object> {
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; }
630 template<
typename ValueType>
631 struct 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(); }
640 template <
bool,
typename>
class GenericArray;
641 template <
bool,
typename>
class GenericObject;
656 template <
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;
690 GenericValue(
const GenericValue& rhs);
692 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
694 template <
typename StackAllocator>
695 GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
698 template <
typename StackAllocator>
699 GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
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 // hide SFINAE from Doxygen
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>
953 RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (
GenericValue&))
966 template <
typename SourceAllocator>
968 RAPIDJSON_ASSERT(
static_cast<void*
>(
this) !=
static_cast<void const*
>(&rhs));
970 new (
this)
GenericValue(rhs, allocator, copyConstStrings);
981 temp.RawAssign(*
this);
983 other.RawAssign(temp);
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();
1045 return a >= b && a <= b;
1048 return data_.n.u64 == rhs.data_.n.u64;
1058 #if RAPIDJSON_HAS_STDSTRING
1068 template <
typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (
bool))
operator==(
const T& rhs)
const {
return *
this ==
GenericValue(rhs); }
1073 template <
typename SourceAllocator>
1082 template <
typename T> RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (
bool))
operator!=(
const T& rhs)
const {
return !(*
this == rhs); }
1087 template <
typename T>
friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (
bool))
operator==(
const T& lhs,
const GenericValue& rhs) {
return rhs == lhs; }
1092 template <
typename T>
friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (
bool))
operator!=(
const T& lhs,
const GenericValue& rhs) {
return !(rhs == lhs); }
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;
1156 GenericValue& SetNull() { this->~GenericValue();
new (
this) GenericValue();
return *
this; }
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);
1317 ConstMemberIterator FindMember(
const Ch* name)
const {
return const_cast<GenericValue&
>(*this).
FindMember(name); }
1332 template <
typename SourceAllocator>
1337 for ( ; member != MemberEnd(); ++member)
1338 if (name.StringEqual(member->name))
1344 #if RAPIDJSON_HAS_STDSTRING
1353 ConstMemberIterator FindMember(
const std::basic_string<Ch>& name)
const {
return FindMember(
GenericValue(
StringRef(name))); }
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>
1428 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (
GenericValue&))
1431 return AddMember(name, v, allocator);
1434 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
1436 return AddMember(name, value, allocator);
1438 GenericValue& AddMember(GenericValue&& name, GenericValue& value,
Allocator& allocator) {
1439 return AddMember(name, value, allocator);
1441 GenericValue& AddMember(GenericValue& name, GenericValue&& value,
Allocator& allocator) {
1442 return AddMember(name, value, allocator);
1444 GenericValue& AddMember(StringRefType name, GenericValue&& value,
Allocator& allocator) {
1445 GenericValue n(name);
1446 return AddMember(n, value, allocator);
1448 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
1463 return AddMember(n, value, allocator);
1477 return AddMember(name, v, allocator);
1497 template <
typename T>
1498 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (
GenericValue&))
1501 return AddMember(n, value, allocator);
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>
1533 bool RemoveMember(
const GenericValue<Encoding, SourceAllocator>& name) {
1534 MemberIterator m = FindMember(name);
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);
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>
1619 bool EraseMember(
const GenericValue<Encoding, SourceAllocator>& name) {
1620 MemberIterator m = FindMember(name);
1621 if (m != MemberEnd()) {
1630 ConstObject GetObject()
const {
RAPIDJSON_ASSERT(IsObject());
return ConstObject(*
this); }
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);
1724 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
1736 return (*this).template PushBack<StringRefType>(value, allocator);
1756 template <
typename T>
1757 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (
GenericValue&))
1760 return PushBack(v, allocator);
1770 GetElementsPointer()[--data_.a.size].~GenericValue();
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; }
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);
1837 return static_cast<float>(GetDouble());
1841 GenericValue& SetUint(
unsigned u) { this->~GenericValue();
new (
this) GenericValue(u);
return *
this; }
1842 GenericValue& SetInt64(int64_t i64) { this->~GenericValue();
new (
this) GenericValue(i64);
return *
this; }
1843 GenericValue& SetUint64(uint64_t u64) { this->~GenericValue();
new (
this) GenericValue(u64);
return *
this; }
1844 GenericValue& SetDouble(
double d) { this->~GenericValue();
new (
this) GenericValue(d);
return *
this; }
1845 GenericValue& SetFloat(
float f) { this->~GenericValue();
new (
this) GenericValue(
static_cast<double>(f));
return *
this; }
1852 const Ch* GetString()
const {
RAPIDJSON_ASSERT(IsString());
return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); }
1902 #if RAPIDJSON_HAS_STDSTRING
1922 template <
typename T>
1923 bool Is()
const {
return internal::TypeHelper<ValueType, T>::Is(*
this); }
1925 template <
typename T>
1926 T Get()
const {
return internal::TypeHelper<ValueType, T>::Get(*
this); }
1928 template <
typename T>
1929 T Get() {
return internal::TypeHelper<ValueType, T>::Get(*
this); }
1931 template<
typename T>
1932 ValueType& Set(
const T& data) {
return internal::TypeHelper<ValueType, T>::Set(*
this, data); }
1934 template<
typename T>
1935 ValueType& Set(
const T& data, AllocatorType& allocator) {
return internal::TypeHelper<ValueType, T>::Set(*
this, data, allocator); }
1946 template <
typename Handler>
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];
2049 struct ShortString {
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); }
2108 RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) {
return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, 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;
2116 GenericValue* e =
static_cast<GenericValue*
>(allocator.Malloc(count *
sizeof(GenericValue)));
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;
2129 Member* m =
static_cast<Member*
>(allocator.Malloc(count *
sizeof(Member)));
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;
2139 void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT {
2140 data_.f.flags = kConstStringFlag;
2141 SetStringPointer(s);
2142 data_.s.length = s.length;
2146 void SetStringRaw(StringRefType s,
Allocator& allocator) {
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));
2159 str[s.length] =
'\0';
2163 void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
2166 rhs.data_.f.flags = kNullFlag;
2169 template <
typename SourceAllocator>
2170 bool StringEqual(
const GenericValue<Encoding, SourceAllocator>& rhs)
const {
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);
2202 template <
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;
2251 ~GenericDocument() {
2255 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
2257 GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
2261 ValueType::operator=(std::forward<ValueType>(rhs));
2266 allocator_ = rhs.allocator_;
2267 ownAllocator_ = rhs.ownAllocator_;
2268 stack_ = std::move(rhs.stack_);
2269 parseResult_ = rhs.parseResult_;
2272 rhs.ownAllocator_ = 0;
2273 rhs.parseResult_ = ParseResult();
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);
2322 ValueType::operator=(*stack_.template Pop<ValueType>(1));
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);
2345 ValueType::operator=(*stack_.template Pop<ValueType>(1));
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>
2427 GenericDocument& Parse(
const typename SourceEncoding::Ch* str,
size_t length) {
2429 MemoryStream ms(
reinterpret_cast<const char*
>(str), length *
sizeof(
typename SourceEncoding::Ch));
2431 ParseStream<parseFlags, SourceEncoding>(is);
2435 template <
unsigned parseFlags>
2436 GenericDocument& Parse(
const Ch* str,
size_t length) {
2437 return Parse<parseFlags, Encoding>(str, length);
2440 GenericDocument& Parse(
const Ch* str,
size_t length) {
2441 return Parse<kParseDefaultFlags>(str, length);
2444 #if RAPIDJSON_HAS_STDSTRING
2445 template <
unsigned parseFlags,
typename SourceEncoding>
2446 GenericDocument& Parse(
const std::basic_string<typename SourceEncoding::Ch>& str) {
2448 return Parse<parseFlags, SourceEncoding>(str.c_str());
2451 template <
unsigned parseFlags>
2452 GenericDocument& Parse(
const std::basic_string<Ch>& str) {
2453 return Parse<parseFlags, Encoding>(str.c_str());
2456 GenericDocument& Parse(
const std::basic_string<Ch>& str) {
2457 return Parse<kParseDefaultFlags>(str);
2459 #endif // RAPIDJSON_HAS_STDSTRING
2476 #ifndef __clang // -Wdocumentation
2501 struct ClearStackOnExit {
2503 ~ClearStackOnExit() { d_.ClearStack(); }
2505 ClearStackOnExit(
const ClearStackOnExit&);
2506 ClearStackOnExit& operator=(
const ClearStackOnExit&);
2507 GenericDocument& d_;
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) {
2526 new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
2528 new (stack_.template Push<ValueType>()) ValueType(str, length);
2532 bool String(
const Ch* str,
SizeType length,
bool copy) {
2534 new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
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());
2560 GenericDocument(
const GenericDocument&);
2562 GenericDocument& operator=(
const GenericDocument&);
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;
2580 internal::Stack<StackAllocator> stack_;
2581 ParseResult parseResult_;
2593 template <
bool Const,
typename ValueT>
2598 typedef ValueT PlainType;
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; }
2623 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
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(); }
2646 template <
bool Const,
typename ValueT>
2651 typedef ValueT PlainType;
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; }
2699 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
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
2729 RAPIDJSON_NAMESPACE_END
2732 #endif // RAPIDJSON_DOCUMENT_H_