document.h

Go to the documentation of this file.

// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef RAPIDJSON_DOCUMENT_H_
#define RAPIDJSON_DOCUMENT_H_

#include "reader.h"
#include "internal/meta.h"
#include "internal/strfunc.h"
#include "memorystream.h"
#include "encodedstream.h"
#include <new> // placement new
#include <limits>

RAPIDJSON_DIAG_PUSH
#ifdef _MSC_VER
RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
#endif

#ifdef __clang__
RAPIDJSON_DIAG_OFF(padded)
RAPIDJSON_DIAG_OFF(switch-enum)
RAPIDJSON_DIAG_OFF(c++98-compat)
#endif

#ifdef __GNUC__
RAPIDJSON_DIAG_OFF(effc++)
#if __GNUC__ >= 6
RAPIDJSON_DIAG_OFF(terminate) // ignore throwing RAPIDJSON_ASSERT in RAPIDJSON_NOEXCEPT functions
#endif
#endif // __GNUC__

#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
#include <iterator> // std::iterator, std::random_access_iterator_tag
#endif

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
#include <utility> // std::move
#endif

RAPIDJSON_NAMESPACE_BEGIN

// Forward declaration.
template <typename Encoding, typename Allocator>
class GenericValue;

template <typename Encoding, typename Allocator, typename StackAllocator>
class GenericDocument;


template <typename Encoding, typename Allocator> 
struct GenericMember { 
 GenericValue<Encoding, Allocator> name; 
 GenericValue<Encoding, Allocator> value; 
};

// GenericMemberIterator

#ifndef RAPIDJSON_NOMEMBERITERATORCLASS


template <bool Const, typename Encoding, typename Allocator>
class GenericMemberIterator
 : public std::iterator<std::random_access_iterator_tag
 , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {

 friend class GenericValue<Encoding,Allocator>;
 template <bool, typename, typename> friend class GenericMemberIterator;

 typedef GenericMember<Encoding,Allocator> PlainType;
 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
 typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;

public:
 typedef GenericMemberIterator Iterator;
 typedef GenericMemberIterator<true,Encoding,Allocator> ConstIterator;
 typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;

 typedef typename BaseType::pointer Pointer;
 typedef typename BaseType::reference Reference;
 typedef typename BaseType::difference_type DifferenceType;


 GenericMemberIterator() : ptr_() {}


 GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}
 Iterator& operator=(const NonConstIterator & it) { ptr_ = it.ptr_; return *this; }


 Iterator& operator++(){ ++ptr_; return *this; }
 Iterator& operator--(){ --ptr_; return *this; }
 Iterator operator++(int){ Iterator old(*this); ++ptr_; return old; }
 Iterator operator--(int){ Iterator old(*this); --ptr_; return old; }


 Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); }
 Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); }

 Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; }
 Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; }


 bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
 bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
 bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
 bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
 bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; }
 bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; }


 Reference operator*() const { return *ptr_; }
 Pointer operator->() const { return ptr_; }
 Reference operator[](DifferenceType n) const { return ptr_[n]; }

 DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; }

private:
 explicit GenericMemberIterator(Pointer p) : ptr_(p) {}

 Pointer ptr_; 
};

#else // RAPIDJSON_NOMEMBERITERATORCLASS

// class-based member iterator implementation disabled, use plain pointers

template <bool Const, typename Encoding, typename Allocator>
struct GenericMemberIterator;

template <typename Encoding, typename Allocator>
struct GenericMemberIterator<false,Encoding,Allocator> {
 typedef GenericMember<Encoding,Allocator>* Iterator;
};
template <typename Encoding, typename Allocator>
struct GenericMemberIterator<true,Encoding,Allocator> {
 typedef const GenericMember<Encoding,Allocator>* Iterator;
};

#endif // RAPIDJSON_NOMEMBERITERATORCLASS

// GenericStringRef


template<typename CharType>
struct GenericStringRef {
 typedef CharType Ch; 

#ifndef __clang__ // -Wdocumentation

#endif
 template<SizeType N>
 GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT
 : s(str), length(N-1) {}

#ifndef __clang__ // -Wdocumentation

#endif
 explicit GenericStringRef(const CharType* str)
 : s(str), length(internal::StrLen(str)){ RAPIDJSON_ASSERT(s != 0); }

#ifndef __clang__ // -Wdocumentation

#endif
 GenericStringRef(const CharType* str, SizeType len)
 : s(str), length(len) { RAPIDJSON_ASSERT(s != 0); }

 GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {}

 GenericStringRef& operator=(const GenericStringRef& rhs) { s = rhs.s; length = rhs.length; }

 operator const Ch *() const { return s; }

 const Ch* const s; 
 const SizeType length; 

private:
 template<SizeType N>
 GenericStringRef(CharType (&str)[N]) /* = delete */;
};


template<typename CharType>
inline GenericStringRef<CharType> StringRef(const CharType* str) {
 return GenericStringRef<CharType>(str, internal::StrLen(str));
}


template<typename CharType>
inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {
 return GenericStringRef<CharType>(str, SizeType(length));
}

#if RAPIDJSON_HAS_STDSTRING

template<typename CharType>
inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) {
 return GenericStringRef<CharType>(str.data(), SizeType(str.size()));
}
#endif

// GenericValue type traits
namespace internal {

template <typename T, typename Encoding = void, typename Allocator = void>
struct IsGenericValueImpl : FalseType {};

// select candidates according to nested encoding and allocator types
template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type>
 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {};

// helper to match arbitrary GenericValue instantiations, including derived classes
template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};

} // namespace internal

// TypeHelper

namespace internal {

template <typename ValueType, typename T>
struct TypeHelper {};

template<typename ValueType> 
struct TypeHelper<ValueType, bool> {
 static bool Is(const ValueType& v) { return v.IsBool(); }
 static bool Get(const ValueType& v) { return v.GetBool(); }
 static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); }
 static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, int> {
 static bool Is(const ValueType& v) { return v.IsInt(); }
 static int Get(const ValueType& v) { return v.GetInt(); }
 static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); }
 static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, unsigned> {
 static bool Is(const ValueType& v) { return v.IsUint(); }
 static unsigned Get(const ValueType& v) { return v.GetUint(); }
 static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); }
 static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, int64_t> {
 static bool Is(const ValueType& v) { return v.IsInt64(); }
 static int64_t Get(const ValueType& v) { return v.GetInt64(); }
 static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); }
 static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, uint64_t> {
 static bool Is(const ValueType& v) { return v.IsUint64(); }
 static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
 static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); }
 static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, double> {
 static bool Is(const ValueType& v) { return v.IsDouble(); }
 static double Get(const ValueType& v) { return v.GetDouble(); }
 static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); }
 static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, float> {
 static bool Is(const ValueType& v) { return v.IsFloat(); }
 static float Get(const ValueType& v) { return v.GetFloat(); }
 static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); }
 static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, const typename ValueType::Ch*> {
 typedef const typename ValueType::Ch* StringType;
 static bool Is(const ValueType& v) { return v.IsString(); }
 static StringType Get(const ValueType& v) { return v.GetString(); }
 static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); }
 static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
};

#if RAPIDJSON_HAS_STDSTRING
template<typename ValueType> 
struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
 typedef std::basic_string<typename ValueType::Ch> StringType;
 static bool Is(const ValueType& v) { return v.IsString(); }
 static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); }
 static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
};
#endif

template<typename ValueType> 
struct TypeHelper<ValueType, typename ValueType::Array> {
 typedef typename ValueType::Array ArrayType;
 static bool Is(const ValueType& v) { return v.IsArray(); }
 static ArrayType Get(ValueType& v) { return v.GetArray(); }
 static ValueType& Set(ValueType& v, ArrayType data) { return v = data; }
 static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }
};

template<typename ValueType> 
struct TypeHelper<ValueType, typename ValueType::ConstArray> {
 typedef typename ValueType::ConstArray ArrayType;
 static bool Is(const ValueType& v) { return v.IsArray(); }
 static ArrayType Get(const ValueType& v) { return v.GetArray(); }
};

template<typename ValueType> 
struct TypeHelper<ValueType, typename ValueType::Object> {
 typedef typename ValueType::Object ObjectType;
 static bool Is(const ValueType& v) { return v.IsObject(); }
 static ObjectType Get(ValueType& v) { return v.GetObject(); }
 static ValueType& Set(ValueType& v, ObjectType data) { return v = data; }
 static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { v = data; }
};

template<typename ValueType> 
struct TypeHelper<ValueType, typename ValueType::ConstObject> {
 typedef typename ValueType::ConstObject ObjectType;
 static bool Is(const ValueType& v) { return v.IsObject(); }
 static ObjectType Get(const ValueType& v) { return v.GetObject(); }
};

} // namespace internal

// Forward declarations
template <bool, typename> class GenericArray;
template <bool, typename> class GenericObject;

// GenericValue


template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
class GenericValue {
public:
 typedef GenericMember<Encoding, Allocator> Member;
 typedef Encoding EncodingType; 
 typedef Allocator AllocatorType; 
 typedef typename Encoding::Ch Ch; 
 typedef GenericStringRef<Ch> StringRefType; 
 typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator; 
 typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator; 
 typedef GenericValue* ValueIterator; 
 typedef const GenericValue* ConstValueIterator; 
 typedef GenericValue<Encoding, Allocator> ValueType; 
 typedef GenericArray<false, ValueType> Array;
 typedef GenericArray<true, ValueType> ConstArray;
 typedef GenericObject<false, ValueType> Object;
 typedef GenericObject<true, ValueType> ConstObject;



 GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_) {
 rhs.data_.f.flags = kNullFlag; // give up contents
 }
#endif

private:
 GenericValue(const GenericValue& rhs);

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 template <typename StackAllocator>
 GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);

 template <typename StackAllocator>
 GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
#endif

public:


 explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
 static const uint16_t defaultFlags[7] = {
 kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
 kNumberAnyFlag
 };
 RAPIDJSON_ASSERT(type <= kNumberType);
 data_.f.flags = defaultFlags[type];

 // Use ShortString to store empty string.
 if (type == kStringType)
 data_.ss.SetLength(0);
 }


 template< typename SourceAllocator >
 GenericValue(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator & allocator);


#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
 template <typename T>
 explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) RAPIDJSON_NOEXCEPT // See #472
#else
 explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT
#endif
 : data_() {
 // safe-guard against failing SFINAE
 RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));
 data_.f.flags = b ? kTrueFlag : kFalseFlag;
 }

 explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() {
 data_.n.i64 = i;
 data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
 }

 explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() {
 data_.n.u64 = u; 
 data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
 }

 explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
 data_.n.i64 = i64;
 data_.f.flags = kNumberInt64Flag;
 if (i64 >= 0) {
 data_.f.flags |= kNumberUint64Flag;
 if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
 data_.f.flags |= kUintFlag;
 if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
 data_.f.flags |= kIntFlag;
 }
 else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
 data_.f.flags |= kIntFlag;
 }

 explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
 data_.n.u64 = u64;
 data_.f.flags = kNumberUint64Flag;
 if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
 data_.f.flags |= kInt64Flag;
 if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
 data_.f.flags |= kUintFlag;
 if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
 data_.f.flags |= kIntFlag;
 }

 explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }

 GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }

 explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(s); }

 GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); }

 GenericValue(const Ch*s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }

#if RAPIDJSON_HAS_STDSTRING

 GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
#endif


 GenericValue(Array a) RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {
 a.value_.data_ = Data();
 a.value_.data_.f.flags = kArrayFlag;
 }


 GenericValue(Object o) RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {
 o.value_.data_ = Data();
 o.value_.data_.f.flags = kObjectFlag;
 }


 ~GenericValue() {
 if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
 switch(data_.f.flags) {
 case kArrayFlag:
 {
 GenericValue* e = GetElementsPointer();
 for (GenericValue* v = e; v != e + data_.a.size; ++v)
 v->~GenericValue();
 Allocator::Free(e);
 }
 break;

 case kObjectFlag:
 for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
 m->~Member();
 Allocator::Free(GetMembersPointer());
 break;

 case kCopyStringFlag:
 Allocator::Free(const_cast<Ch*>(GetStringPointer()));
 break;

 default:
 break; // Do nothing for other types.
 }
 }
 }





 GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
 RAPIDJSON_ASSERT(this != &rhs);
 this->~GenericValue();
 RawAssign(rhs);
 return *this;
 }

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT {
 return *this = rhs.Move();
 }
#endif


 GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT {
 GenericValue s(str);
 return *this = s;
 }


 template <typename T>
 RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&))
 operator=(T value) {
 GenericValue v(value);
 return *this = v;
 }


 template <typename SourceAllocator>
 GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator) {
 RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));
 this->~GenericValue();
 new (this) GenericValue(rhs, allocator);
 return *this;
 }


 GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT {
 GenericValue temp;
 temp.RawAssign(*this);
 RawAssign(other);
 other.RawAssign(temp);
 return *this;
 }


 friend inline void swap(GenericValue& a, GenericValue& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }


 GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; }



 template <typename SourceAllocator>
 bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
 typedef GenericValue<Encoding, SourceAllocator> RhsType;
 if (GetType() != rhs.GetType())
 return false;

 switch (GetType()) {
 case kObjectType: // Warning: O(n^2) inner-loop
 if (data_.o.size != rhs.data_.o.size)
 return false; 
 for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
 typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
 if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
 return false;
 }
 return true;
 
 case kArrayType:
 if (data_.a.size != rhs.data_.a.size)
 return false;
 for (SizeType i = 0; i < data_.a.size; i++)
 if ((*this)[i] != rhs[i])
 return false;
 return true;

 case kStringType:
 return StringEqual(rhs);

 case kNumberType:
 if (IsDouble() || rhs.IsDouble()) {
 double a = GetDouble(); // May convert from integer to double.
 double b = rhs.GetDouble(); // Ditto
 return a >= b && a <= b; // Prevent -Wfloat-equal
 }
 else
 return data_.n.u64 == rhs.data_.n.u64;

 default:
 return true;
 }
 }

 bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); }

#if RAPIDJSON_HAS_STDSTRING

 bool operator==(const std::basic_string<Ch>& rhs) const { return *this == GenericValue(StringRef(rhs)); }
#endif


 template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); }


 template <typename SourceAllocator>
 bool operator!=(const GenericValue<Encoding, SourceAllocator>& rhs) const { return !(*this == rhs); }

 bool operator!=(const Ch* rhs) const { return !(*this == rhs); }


 template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); }


 template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; }


 template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); }



 Type GetType() const { return static_cast<Type>(data_.f.flags & kTypeMask); }
 bool IsNull() const { return data_.f.flags == kNullFlag; }
 bool IsFalse() const { return data_.f.flags == kFalseFlag; }
 bool IsTrue() const { return data_.f.flags == kTrueFlag; }
 bool IsBool() const { return (data_.f.flags & kBoolFlag) != 0; }
 bool IsObject() const { return data_.f.flags == kObjectFlag; }
 bool IsArray() const { return data_.f.flags == kArrayFlag; }
 bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; }
 bool IsInt() const { return (data_.f.flags & kIntFlag) != 0; }
 bool IsUint() const { return (data_.f.flags & kUintFlag) != 0; }
 bool IsInt64() const { return (data_.f.flags & kInt64Flag) != 0; }
 bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; }
 bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; }
 bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }

 // Checks whether a number can be losslessly converted to a double.
 bool IsLosslessDouble() const {
 if (!IsNumber()) return false;
 if (IsUint64()) {
 uint64_t u = GetUint64();
 volatile double d = static_cast<double>(u);
 return (d >= 0.0)
 && (d < static_cast<double>(std::numeric_limits<uint64_t>::max()))
 && (u == static_cast<uint64_t>(d));
 }
 if (IsInt64()) {
 int64_t i = GetInt64();
 volatile double d = static_cast<double>(i);
 return (d >= static_cast<double>(std::numeric_limits<int64_t>::min()))
 && (d < static_cast<double>(std::numeric_limits<int64_t>::max()))
 && (i == static_cast<int64_t>(d));
 }
 return true; // double, int, uint are always lossless
 }

 // Checks whether a number is a float (possible lossy).
 bool IsFloat() const {
 if ((data_.f.flags & kDoubleFlag) == 0)
 return false;
 double d = GetDouble();
 return d >= -3.4028234e38 && d <= 3.4028234e38;
 }
 // Checks whether a number can be losslessly converted to a float.
 bool IsLosslessFloat() const {
 if (!IsNumber()) return false;
 double a = GetDouble();
 if (a < static_cast<double>(-std::numeric_limits<float>::max())
 || a > static_cast<double>(std::numeric_limits<float>::max()))
 return false;
 double b = static_cast<double>(static_cast<float>(a));
 return a >= b && a <= b; // Prevent -Wfloat-equal
 }




 GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }




 bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return data_.f.flags == kTrueFlag; }

 GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }





 GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }

 SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }

 bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }


 template <typename T>
 RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) {
 GenericValue n(StringRef(name));
 return (*this)[n];
 }
 template <typename T>
 RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }


 template <typename SourceAllocator>
 GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
 MemberIterator member = FindMember(name);
 if (member != MemberEnd())
 return member->value;
 else {
 RAPIDJSON_ASSERT(false); // see above note

 // This will generate -Wexit-time-destructors in clang
 // static GenericValue NullValue;
 // return NullValue;

 // Use static buffer and placement-new to prevent destruction
 static char buffer[sizeof(GenericValue)];
 return *new (buffer) GenericValue();
 }
 }
 template <typename SourceAllocator>
 const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }

#if RAPIDJSON_HAS_STDSTRING
 GenericValue& operator[](const std::basic_string<Ch>& name) { return (*this)[GenericValue(StringRef(name))]; }
 const GenericValue& operator[](const std::basic_string<Ch>& name) const { return (*this)[GenericValue(StringRef(name))]; }
#endif


 ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); }

 ConstMemberIterator MemberEnd() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); }

 MemberIterator MemberBegin() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer()); }

 MemberIterator MemberEnd() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); }


 bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); }

#if RAPIDJSON_HAS_STDSTRING

 bool HasMember(const std::basic_string<Ch>& name) const { return FindMember(name) != MemberEnd(); }
#endif


 template <typename SourceAllocator>
 bool HasMember(const GenericValue<Encoding, SourceAllocator>& name) const { return FindMember(name) != MemberEnd(); }


 MemberIterator FindMember(const Ch* name) {
 GenericValue n(StringRef(name));
 return FindMember(n);
 }

 ConstMemberIterator FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); }


 template <typename SourceAllocator>
 MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
 RAPIDJSON_ASSERT(IsObject());
 RAPIDJSON_ASSERT(name.IsString());
 MemberIterator member = MemberBegin();
 for ( ; member != MemberEnd(); ++member)
 if (name.StringEqual(member->name))
 break;
 return member;
 }
 template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); }

#if RAPIDJSON_HAS_STDSTRING

 MemberIterator FindMember(const std::basic_string<Ch>& name) { return FindMember(GenericValue(StringRef(name))); }
 ConstMemberIterator FindMember(const std::basic_string<Ch>& name) const { return FindMember(GenericValue(StringRef(name))); }
#endif


 GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
 RAPIDJSON_ASSERT(IsObject());
 RAPIDJSON_ASSERT(name.IsString());

 ObjectData& o = data_.o;
 if (o.size >= o.capacity) {
 if (o.capacity == 0) {
 o.capacity = kDefaultObjectCapacity;
 SetMembersPointer(reinterpret_cast<Member*>(allocator.Malloc(o.capacity * sizeof(Member))));
 }
 else {
 SizeType oldCapacity = o.capacity;
 o.capacity += (oldCapacity + 1) / 2; // grow by factor 1.5
 SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), oldCapacity * sizeof(Member), o.capacity * sizeof(Member))));
 }
 }
 Member* members = GetMembersPointer();
 members[o.size].name.RawAssign(name);
 members[o.size].value.RawAssign(value);
 o.size++;
 return *this;
 }


 GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) {
 GenericValue v(value);
 return AddMember(name, v, allocator);
 }

#if RAPIDJSON_HAS_STDSTRING

 GenericValue& AddMember(GenericValue& name, std::basic_string<Ch>& value, Allocator& allocator) {
 GenericValue v(value, allocator);
 return AddMember(name, v, allocator);
 }
#endif


 template <typename T>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
 AddMember(GenericValue& name, T value, Allocator& allocator) {
 GenericValue v(value);
 return AddMember(name, v, allocator);
 }

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) {
 return AddMember(name, value, allocator);
 }
 GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) {
 return AddMember(name, value, allocator);
 }
 GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) {
 return AddMember(name, value, allocator);
 }
 GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) {
 GenericValue n(name);
 return AddMember(n, value, allocator);
 }
#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS



 GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) {
 GenericValue n(name);
 return AddMember(n, value, allocator);
 }


 GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) {
 GenericValue v(value);
 return AddMember(name, v, allocator);
 }


 template <typename T>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
 AddMember(StringRefType name, T value, Allocator& allocator) {
 GenericValue n(name);
 return AddMember(n, value, allocator);
 }


 void RemoveAllMembers() {
 RAPIDJSON_ASSERT(IsObject()); 
 for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
 m->~Member();
 data_.o.size = 0;
 }


 bool RemoveMember(const Ch* name) {
 GenericValue n(StringRef(name));
 return RemoveMember(n);
 }

#if RAPIDJSON_HAS_STDSTRING
 bool RemoveMember(const std::basic_string<Ch>& name) { return RemoveMember(GenericValue(StringRef(name))); }
#endif

 template <typename SourceAllocator>
 bool RemoveMember(const GenericValue<Encoding, SourceAllocator>& name) {
 MemberIterator m = FindMember(name);
 if (m != MemberEnd()) {
 RemoveMember(m);
 return true;
 }
 else
 return false;
 }


 MemberIterator RemoveMember(MemberIterator m) {
 RAPIDJSON_ASSERT(IsObject());
 RAPIDJSON_ASSERT(data_.o.size > 0);
 RAPIDJSON_ASSERT(GetMembersPointer() != 0);
 RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd());

 MemberIterator last(GetMembersPointer() + (data_.o.size - 1));
 if (data_.o.size > 1 && m != last)
 *m = *last; // Move the last one to this place
 else
 m->~Member(); // Only one left, just destroy
 --data_.o.size;
 return m;
 }


 MemberIterator EraseMember(ConstMemberIterator pos) {
 return EraseMember(pos, pos +1);
 }


 MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) {
 RAPIDJSON_ASSERT(IsObject());
 RAPIDJSON_ASSERT(data_.o.size > 0);
 RAPIDJSON_ASSERT(GetMembersPointer() != 0);
 RAPIDJSON_ASSERT(first >= MemberBegin());
 RAPIDJSON_ASSERT(first <= last);
 RAPIDJSON_ASSERT(last <= MemberEnd());

 MemberIterator pos = MemberBegin() + (first - MemberBegin());
 for (MemberIterator itr = pos; itr != last; ++itr)
 itr->~Member();
 std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
 data_.o.size -= static_cast<SizeType>(last - first);
 return pos;
 }


 bool EraseMember(const Ch* name) {
 GenericValue n(StringRef(name));
 return EraseMember(n);
 }

#if RAPIDJSON_HAS_STDSTRING
 bool EraseMember(const std::basic_string<Ch>& name) { return EraseMember(GenericValue(StringRef(name))); }
#endif

 template <typename SourceAllocator>
 bool EraseMember(const GenericValue<Encoding, SourceAllocator>& name) {
 MemberIterator m = FindMember(name);
 if (m != MemberEnd()) {
 EraseMember(m);
 return true;
 }
 else
 return false;
 }

 Object GetObject() { RAPIDJSON_ASSERT(IsObject()); return Object(*this); }
 ConstObject GetObject() const { RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); }





 GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }

 SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }

 SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }

 bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }


 void Clear() {
 RAPIDJSON_ASSERT(IsArray()); 
 GenericValue* e = GetElementsPointer();
 for (GenericValue* v = e; v != e + data_.a.size; ++v)
 v->~GenericValue();
 data_.a.size = 0;
 }


 GenericValue& operator[](SizeType index) {
 RAPIDJSON_ASSERT(IsArray());
 RAPIDJSON_ASSERT(index < data_.a.size);
 return GetElementsPointer()[index];
 }
 const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }


 ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); }

 ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; }

 ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }

 ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }


 GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {
 RAPIDJSON_ASSERT(IsArray());
 if (newCapacity > data_.a.capacity) {
 SetElementsPointer(reinterpret_cast<GenericValue*>(allocator.Realloc(GetElementsPointer(), data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue))));
 data_.a.capacity = newCapacity;
 }
 return *this;
 }


 GenericValue& PushBack(GenericValue& value, Allocator& allocator) {
 RAPIDJSON_ASSERT(IsArray());
 if (data_.a.size >= data_.a.capacity)
 Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
 GetElementsPointer()[data_.a.size++].RawAssign(value);
 return *this;
 }

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericValue& PushBack(GenericValue&& value, Allocator& allocator) {
 return PushBack(value, allocator);
 }
#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS


 GenericValue& PushBack(StringRefType value, Allocator& allocator) {
 return (*this).template PushBack<StringRefType>(value, allocator);
 }


 template <typename T>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
 PushBack(T value, Allocator& allocator) {
 GenericValue v(value);
 return PushBack(v, allocator);
 }


 GenericValue& PopBack() {
 RAPIDJSON_ASSERT(IsArray());
 RAPIDJSON_ASSERT(!Empty());
 GetElementsPointer()[--data_.a.size].~GenericValue();
 return *this;
 }


 ValueIterator Erase(ConstValueIterator pos) {
 return Erase(pos, pos + 1);
 }


 ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
 RAPIDJSON_ASSERT(IsArray());
 RAPIDJSON_ASSERT(data_.a.size > 0);
 RAPIDJSON_ASSERT(GetElementsPointer() != 0);
 RAPIDJSON_ASSERT(first >= Begin());
 RAPIDJSON_ASSERT(first <= last);
 RAPIDJSON_ASSERT(last <= End());
 ValueIterator pos = Begin() + (first - Begin());
 for (ValueIterator itr = pos; itr != last; ++itr)
 itr->~GenericValue(); 
 std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
 data_.a.size -= static_cast<SizeType>(last - first);
 return pos;
 }

 Array GetArray() { RAPIDJSON_ASSERT(IsArray()); return Array(*this); }
 ConstArray GetArray() const { RAPIDJSON_ASSERT(IsArray()); return ConstArray(*this); }




 int GetInt() const { RAPIDJSON_ASSERT(data_.f.flags & kIntFlag); return data_.n.i.i; }
 unsigned GetUint() const { RAPIDJSON_ASSERT(data_.f.flags & kUintFlag); return data_.n.u.u; }
 int64_t GetInt64() const { RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag); return data_.n.i64; }
 uint64_t GetUint64() const { RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag); return data_.n.u64; }


 double GetDouble() const {
 RAPIDJSON_ASSERT(IsNumber());
 if ((data_.f.flags & kDoubleFlag) != 0) return data_.n.d; // exact type, no conversion.
 if ((data_.f.flags & kIntFlag) != 0) return data_.n.i.i; // int -> double
 if ((data_.f.flags & kUintFlag) != 0) return data_.n.u.u; // unsigned -> double
 if ((data_.f.flags & kInt64Flag) != 0) return static_cast<double>(data_.n.i64); // int64_t -> double (may lose precision)
 RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0); return static_cast<double>(data_.n.u64); // uint64_t -> double (may lose precision)
 }


 float GetFloat() const {
 return static_cast<float>(GetDouble());
 }

 GenericValue& SetInt(int i) { this->~GenericValue(); new (this) GenericValue(i); return *this; }
 GenericValue& SetUint(unsigned u) { this->~GenericValue(); new (this) GenericValue(u); return *this; }
 GenericValue& SetInt64(int64_t i64) { this->~GenericValue(); new (this) GenericValue(i64); return *this; }
 GenericValue& SetUint64(uint64_t u64) { this->~GenericValue(); new (this) GenericValue(u64); return *this; }
 GenericValue& SetDouble(double d) { this->~GenericValue(); new (this) GenericValue(d); return *this; }
 GenericValue& SetFloat(float f) { this->~GenericValue(); new (this) GenericValue(f); return *this; }




 const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); }


 SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }


 GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); }


 GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; }


 GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(StringRef(s, length), allocator); return *this; }


 GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(s, internal::StrLen(s), allocator); }

#if RAPIDJSON_HAS_STDSTRING

 GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(s.data(), SizeType(s.size()), allocator); }
#endif





 template <typename T>
 bool Is() const { return internal::TypeHelper<ValueType, T>::Is(*this); }

 template <typename T>
 T Get() const { return internal::TypeHelper<ValueType, T>::Get(*this); }

 template <typename T>
 T Get() { return internal::TypeHelper<ValueType, T>::Get(*this); }

 template<typename T>
 ValueType& Set(const T& data) { return internal::TypeHelper<ValueType, T>::Set(*this, data); }

 template<typename T>
 ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper<ValueType, T>::Set(*this, data, allocator); }



 template <typename Handler>
 bool Accept(Handler& handler) const {
 switch(GetType()) {
 case kNullType: return handler.Null();
 case kFalseType: return handler.Bool(false);
 case kTrueType: return handler.Bool(true);

 case kObjectType:
 if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
 return false;
 for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
 RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator.
 if (RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
 return false;
 if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler)))
 return false;
 }
 return handler.EndObject(data_.o.size);

 case kArrayType:
 if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
 return false;
 for (const GenericValue* v = Begin(); v != End(); ++v)
 if (RAPIDJSON_UNLIKELY(!v->Accept(handler)))
 return false;
 return handler.EndArray(data_.a.size);
 
 case kStringType:
 return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
 
 default:
 RAPIDJSON_ASSERT(GetType() == kNumberType);
 if (IsDouble()) return handler.Double(data_.n.d);
 else if (IsInt()) return handler.Int(data_.n.i.i);
 else if (IsUint()) return handler.Uint(data_.n.u.u);
 else if (IsInt64()) return handler.Int64(data_.n.i64);
 else return handler.Uint64(data_.n.u64);
 }
 }

private:
 template <typename, typename> friend class GenericValue;
 template <typename, typename, typename> friend class GenericDocument;

 enum {
 kBoolFlag = 0x0008,
 kNumberFlag = 0x0010,
 kIntFlag = 0x0020,
 kUintFlag = 0x0040,
 kInt64Flag = 0x0080,
 kUint64Flag = 0x0100,
 kDoubleFlag = 0x0200,
 kStringFlag = 0x0400,
 kCopyFlag = 0x0800,
 kInlineStrFlag = 0x1000,

 // Initial flags of different types.
 kNullFlag = kNullType,
 kTrueFlag = kTrueType | kBoolFlag,
 kFalseFlag = kFalseType | kBoolFlag,
 kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
 kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
 kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
 kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
 kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
 kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
 kConstStringFlag = kStringType | kStringFlag,
 kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
 kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
 kObjectFlag = kObjectType,
 kArrayFlag = kArrayType,

 kTypeMask = 0x07
 };

 static const SizeType kDefaultArrayCapacity = 16;
 static const SizeType kDefaultObjectCapacity = 16;

 struct Flag {
#if RAPIDJSON_48BITPOINTER_OPTIMIZATION
 char payload[sizeof(SizeType) * 2 + 6]; // 2 x SizeType + lower 48-bit pointer
#elif RAPIDJSON_64BIT
 char payload[sizeof(SizeType) * 2 + sizeof(void*) + 6]; // 6 padding bytes
#else
 char payload[sizeof(SizeType) * 2 + sizeof(void*) + 2]; // 2 padding bytes
#endif
 uint16_t flags;
 };

 struct String {
 SizeType length;
 SizeType hashcode; 
 const Ch* str;
 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

 // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars
 // (excluding the terminating zero) and store a value to determine the length of the contained
 // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string
 // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as
 // the string terminator as well. For getting the string length back from that value just use
 // "MaxSize - str[LenPos]".
 // This allows to store 13-chars strings in 32-bit mode, 21-chars strings in 64-bit mode,
 // 13-chars strings for RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded strings).
 struct ShortString {
 enum { MaxChars = sizeof(static_cast<Flag*>(0)->payload) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
 Ch str[MaxChars];

 inline static bool Usable(SizeType len) { return (MaxSize >= len); }
 inline void SetLength(SizeType len) { str[LenPos] = static_cast<Ch>(MaxSize - len); }
 inline SizeType GetLength() const { return static_cast<SizeType>(MaxSize - str[LenPos]); }
 }; // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

 // By using proper binary layout, retrieval of different integer types do not need conversions.
 union Number {
#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
 struct I {
 int i;
 char padding[4];
 }i;
 struct U {
 unsigned u;
 char padding2[4];
 }u;
#else
 struct I {
 char padding[4];
 int i;
 }i;
 struct U {
 char padding2[4];
 unsigned u;
 }u;
#endif
 int64_t i64;
 uint64_t u64;
 double d;
 }; // 8 bytes

 struct ObjectData {
 SizeType size;
 SizeType capacity;
 Member* members;
 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

 struct ArrayData {
 SizeType size;
 SizeType capacity;
 GenericValue* elements;
 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

 union Data {
 String s;
 ShortString ss;
 Number n;
 ObjectData o;
 ArrayData a;
 Flag f;
 }; // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit with RAPIDJSON_48BITPOINTER_OPTIMIZATION

 RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return RAPIDJSON_GETPOINTER(Ch, data_.s.str); }
 RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); }
 RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); }
 RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); }
 RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return RAPIDJSON_GETPOINTER(Member, data_.o.members); }
 RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return RAPIDJSON_SETPOINTER(Member, data_.o.members, members); }

 // Initialize this value as array with initial data, without calling destructor.
 void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
 data_.f.flags = kArrayFlag;
 if (count) {
 GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
 SetElementsPointer(e);
 std::memcpy(e, values, count * sizeof(GenericValue));
 }
 else
 SetElementsPointer(0);
 data_.a.size = data_.a.capacity = count;
 }

 void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
 data_.f.flags = kObjectFlag;
 if (count) {
 Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
 SetMembersPointer(m);
 std::memcpy(m, members, count * sizeof(Member));
 }
 else
 SetMembersPointer(0);
 data_.o.size = data_.o.capacity = count;
 }

 void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT {
 data_.f.flags = kConstStringFlag;
 SetStringPointer(s);
 data_.s.length = s.length;
 }

 void SetStringRaw(StringRefType s, Allocator& allocator) {
 Ch* str = 0;
 if (ShortString::Usable(s.length)) {
 data_.f.flags = kShortStringFlag;
 data_.ss.SetLength(s.length);
 str = data_.ss.str;
 } else {
 data_.f.flags = kCopyStringFlag;
 data_.s.length = s.length;
 str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
 SetStringPointer(str);
 }
 std::memcpy(str, s, s.length * sizeof(Ch));
 str[s.length] = '\0';
 }

 void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
 data_ = rhs.data_;
 // data_.f.flags = rhs.data_.f.flags;
 rhs.data_.f.flags = kNullFlag;
 }

 template <typename SourceAllocator>
 bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
 RAPIDJSON_ASSERT(IsString());
 RAPIDJSON_ASSERT(rhs.IsString());

 const SizeType len1 = GetStringLength();
 const SizeType len2 = rhs.GetStringLength();
 if(len1 != len2) { return false; }

 const Ch* const str1 = GetString();
 const Ch* const str2 = rhs.GetString();
 if(str1 == str2) { return true; } // fast path for constant string

 return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
 }

 Data data_;
};

typedef GenericValue<UTF8<> > Value;

// GenericDocument 


template <typename Encoding, typename Allocator = MemoryPoolAllocator<>, typename StackAllocator = CrtAllocator>
class GenericDocument : public GenericValue<Encoding, Allocator> {
public:
 typedef typename Encoding::Ch Ch; 
 typedef GenericValue<Encoding, Allocator> ValueType; 
 typedef Allocator AllocatorType; 


 explicit GenericDocument(Type type, Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
 GenericValue<Encoding, Allocator>(type), allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
 {
 if (!allocator_)
 ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
 }


 GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : 
 allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
 {
 if (!allocator_)
 ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
 }

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
 : ValueType(std::forward<ValueType>(rhs)), // explicit cast to avoid prohibited move from Document
 allocator_(rhs.allocator_),
 ownAllocator_(rhs.ownAllocator_),
 stack_(std::move(rhs.stack_)),
 parseResult_(rhs.parseResult_)
 {
 rhs.allocator_ = 0;
 rhs.ownAllocator_ = 0;
 rhs.parseResult_ = ParseResult();
 }
#endif

 ~GenericDocument() {
 Destroy();
 }

#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
 {
 // The cast to ValueType is necessary here, because otherwise it would
 // attempt to call GenericValue's templated assignment operator.
 ValueType::operator=(std::forward<ValueType>(rhs));

 // Calling the destructor here would prematurely call stack_'s destructor
 Destroy();

 allocator_ = rhs.allocator_;
 ownAllocator_ = rhs.ownAllocator_;
 stack_ = std::move(rhs.stack_);
 parseResult_ = rhs.parseResult_;

 rhs.allocator_ = 0;
 rhs.ownAllocator_ = 0;
 rhs.parseResult_ = ParseResult();

 return *this;
 }
#endif


 GenericDocument& Swap(GenericDocument& rhs) RAPIDJSON_NOEXCEPT {
 ValueType::Swap(rhs);
 stack_.Swap(rhs.stack_);
 internal::Swap(allocator_, rhs.allocator_);
 internal::Swap(ownAllocator_, rhs.ownAllocator_);
 internal::Swap(parseResult_, rhs.parseResult_);
 return *this;
 }


 friend inline void swap(GenericDocument& a, GenericDocument& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }


 template <typename Generator>
 GenericDocument& Populate(Generator& g) {
 ClearStackOnExit scope(*this);
 if (g(*this)) {
 RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
 ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
 }
 return *this;
 }



 template <unsigned parseFlags, typename SourceEncoding, typename InputStream>
 GenericDocument& ParseStream(InputStream& is) {
 GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
 stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
 ClearStackOnExit scope(*this);
 parseResult_ = reader.template Parse<parseFlags>(is, *this);
 if (parseResult_) {
 RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
 ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
 }
 return *this;
 }


 template <unsigned parseFlags, typename InputStream>
 GenericDocument& ParseStream(InputStream& is) {
 return ParseStream<parseFlags, Encoding, InputStream>(is);
 }


 template <typename InputStream>
 GenericDocument& ParseStream(InputStream& is) {
 return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
 }



 template <unsigned parseFlags>
 GenericDocument& ParseInsitu(Ch* str) {
 GenericInsituStringStream<Encoding> s(str);
 return ParseStream<parseFlags | kParseInsituFlag>(s);
 }


 GenericDocument& ParseInsitu(Ch* str) {
 return ParseInsitu<kParseDefaultFlags>(str);
 }



 template <unsigned parseFlags, typename SourceEncoding>
 GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
 RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
 GenericStringStream<SourceEncoding> s(str);
 return ParseStream<parseFlags, SourceEncoding>(s);
 }


 template <unsigned parseFlags>
 GenericDocument& Parse(const Ch* str) {
 return Parse<parseFlags, Encoding>(str);
 }


 GenericDocument& Parse(const Ch* str) {
 return Parse<kParseDefaultFlags>(str);
 }

 template <unsigned parseFlags, typename SourceEncoding>
 GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) {
 RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
 MemoryStream ms(static_cast<const char*>(str), length * sizeof(typename SourceEncoding::Ch));
 EncodedInputStream<SourceEncoding, MemoryStream> is(ms);
 ParseStream<parseFlags, SourceEncoding>(is);
 return *this;
 }

 template <unsigned parseFlags>
 GenericDocument& Parse(const Ch* str, size_t length) {
 return Parse<parseFlags, Encoding>(str, length);
 }
 
 GenericDocument& Parse(const Ch* str, size_t length) {
 return Parse<kParseDefaultFlags>(str, length);
 }

#if RAPIDJSON_HAS_STDSTRING
 template <unsigned parseFlags, typename SourceEncoding>
 GenericDocument& Parse(const std::basic_string<typename SourceEncoding::Ch>& str) {
 // c_str() is constant complexity according to standard. Should be faster than Parse(const char*, size_t)
 return Parse<parseFlags, SourceEncoding>(str.c_str());
 }

 template <unsigned parseFlags>
 GenericDocument& Parse(const std::basic_string<Ch>& str) {
 return Parse<parseFlags, Encoding>(str.c_str());
 }

 GenericDocument& Parse(const std::basic_string<Ch>& str) {
 return Parse<kParseDefaultFlags>(str);
 }
#endif // RAPIDJSON_HAS_STDSTRING 



 bool HasParseError() const { return parseResult_.IsError(); }

 ParseErrorCode GetParseError() const { return parseResult_.Code(); }

 size_t GetErrorOffset() const { return parseResult_.Offset(); }

#ifndef __clang // -Wdocumentation

#endif
 operator ParseResult() const { return parseResult_; }

 Allocator& GetAllocator() {
 RAPIDJSON_ASSERT(allocator_);
 return *allocator_;
 }

 size_t GetStackCapacity() const { return stack_.GetCapacity(); }

private:
 // clear stack on any exit from ParseStream, e.g. due to exception
 struct ClearStackOnExit {
 explicit ClearStackOnExit(GenericDocument& d) : d_(d) {}
 ~ClearStackOnExit() { d_.ClearStack(); }
 private:
 ClearStackOnExit(const ClearStackOnExit&);
 ClearStackOnExit& operator=(const ClearStackOnExit&);
 GenericDocument& d_;
 };

 // callers of the following private Handler functions
 // template <typename,typename,typename> friend class GenericReader; // for parsing
 template <typename, typename> friend class GenericValue; // for deep copying

public:
 // Implementation of Handler
 bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; }
 bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; }
 bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
 bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
 bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
 bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
 bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }

 bool RawNumber(const Ch* str, SizeType length, bool copy) { 
 if (copy) 
 new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
 else
 new (stack_.template Push<ValueType>()) ValueType(str, length);
 return true;
 }

 bool String(const Ch* str, SizeType length, bool copy) { 
 if (copy) 
 new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
 else
 new (stack_.template Push<ValueType>()) ValueType(str, length);
 return true;
 }

 bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
 
 bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }

 bool EndObject(SizeType memberCount) {
 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
 stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount, GetAllocator());
 return true;
 }

 bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
 
 bool EndArray(SizeType elementCount) {
 ValueType* elements = stack_.template Pop<ValueType>(elementCount);
 stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
 return true;
 }

private:
 GenericDocument(const GenericDocument&);
 GenericDocument& operator=(const GenericDocument&);

 void ClearStack() {
 if (Allocator::kNeedFree)
 while (stack_.GetSize() > 0) // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
 (stack_.template Pop<ValueType>(1))->~ValueType();
 else
 stack_.Clear();
 stack_.ShrinkToFit();
 }

 void Destroy() {
 RAPIDJSON_DELETE(ownAllocator_);
 }

 static const size_t kDefaultStackCapacity = 1024;
 Allocator* allocator_;
 Allocator* ownAllocator_;
 internal::Stack<StackAllocator> stack_;
 ParseResult parseResult_;
};

typedef GenericDocument<UTF8<> > Document;

// defined here due to the dependency on GenericDocument
template <typename Encoding, typename Allocator>
template <typename SourceAllocator>
inline
GenericValue<Encoding,Allocator>::GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator)
{
 switch (rhs.GetType()) {
 case kObjectType:
 case kArrayType: { // perform deep copy via SAX Handler
 GenericDocument<Encoding,Allocator> d(&allocator);
 rhs.Accept(d);
 RawAssign(*d.stack_.template Pop<GenericValue>(1));
 }
 break;
 case kStringType:
 if (rhs.data_.f.flags == kConstStringFlag) {
 data_.f.flags = rhs.data_.f.flags;
 data_ = *reinterpret_cast<const Data*>(&rhs.data_);
 } else {
 SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
 }
 break;
 default:
 data_.f.flags = rhs.data_.f.flags;
 data_ = *reinterpret_cast<const Data*>(&rhs.data_);
 break;
 }
}


template <bool Const, typename ValueT>
class GenericArray {
public:
 typedef GenericArray<true, ValueT> ConstArray;
 typedef GenericArray<false, ValueT> Array;
 typedef ValueT PlainType;
 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
 typedef ValueType* ValueIterator; // This may be const or non-const iterator
 typedef const ValueT* ConstValueIterator;
 typedef typename ValueType::AllocatorType AllocatorType;
 typedef typename ValueType::StringRefType StringRefType;

 template <typename, typename>
 friend class GenericValue;

 GenericArray(const GenericArray& rhs) : value_(rhs.value_) {}
 GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
 ~GenericArray() {}

 SizeType Size() const { return value_.Size(); }
 SizeType Capacity() const { return value_.Capacity(); }
 bool Empty() const { return value_.Empty(); }
 void Clear() const { value_.Clear(); }
 ValueType& operator[](SizeType index) const { return value_[index]; }
 ValueIterator Begin() const { return value_.Begin(); }
 ValueIterator End() const { return value_.End(); }
 GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const { value_.Reserve(newCapacity, allocator); return *this; }
 GenericArray PushBack(ValueType& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericArray PushBack(StringRefType value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
 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; }
 GenericArray PopBack() const { value_.PopBack(); return *this; }
 ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(pos); }
 ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const { return value_.Erase(first, last); }

#if RAPIDJSON_HAS_CXX11_RANGE_FOR
 ValueIterator begin() const { return value_.Begin(); }
 ValueIterator end() const { return value_.End(); }
#endif

private:
 GenericArray();
 GenericArray(ValueType& value) : value_(value) {}
 ValueType& value_;
};


template <bool Const, typename ValueT>
class GenericObject {
public:
 typedef GenericObject<true, ValueT> ConstObject;
 typedef GenericObject<false, ValueT> Object;
 typedef ValueT PlainType;
 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
 typedef GenericMemberIterator<Const, typename ValueT::EncodingType, typename ValueT::AllocatorType> MemberIterator; // This may be const or non-const iterator
 typedef GenericMemberIterator<true, typename ValueT::EncodingType, typename ValueT::AllocatorType> ConstMemberIterator;
 typedef typename ValueType::AllocatorType AllocatorType;
 typedef typename ValueType::StringRefType StringRefType;
 typedef typename ValueType::EncodingType EncodingType;
 typedef typename ValueType::Ch Ch;

 template <typename, typename>
 friend class GenericValue;

 GenericObject(const GenericObject& rhs) : value_(rhs.value_) {}
 GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
 ~GenericObject() {}

 SizeType MemberCount() const { return value_.MemberCount(); }
 bool ObjectEmpty() const { return value_.ObjectEmpty(); }
 template <typename T> ValueType& operator[](T* name) const { return value_[name]; }
 template <typename SourceAllocator> ValueType& operator[](const GenericValue<EncodingType, SourceAllocator>& name) const { return value_[name]; }
#if RAPIDJSON_HAS_STDSTRING
 ValueType& operator[](const std::basic_string<Ch>& name) const { return value_[name]; }
#endif
 MemberIterator MemberBegin() const { return value_.MemberBegin(); }
 MemberIterator MemberEnd() const { return value_.MemberEnd(); }
 bool HasMember(const Ch* name) const { return value_.HasMember(name); }
#if RAPIDJSON_HAS_STDSTRING
 bool HasMember(const std::basic_string<Ch>& name) const { return value_.HasMember(name); }
#endif
 template <typename SourceAllocator> bool HasMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.HasMember(name); }
 MemberIterator FindMember(const Ch* name) const { return value_.FindMember(name); }
 template <typename SourceAllocator> MemberIterator FindMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.FindMember(name); }
#if RAPIDJSON_HAS_STDSTRING
 MemberIterator FindMember(const std::basic_string<Ch>& name) const { return value_.FindMember(name); }
#endif
 GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
 GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#if RAPIDJSON_HAS_STDSTRING
 GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#endif
 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; }
#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
 GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
 GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
 GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
 GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
 GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
 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; }
 void RemoveAllMembers() { return value_.RemoveAllMembers(); }
 bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); }
#if RAPIDJSON_HAS_STDSTRING
 bool RemoveMember(const std::basic_string<Ch>& name) const { return value_.RemoveMember(name); }
#endif
 template <typename SourceAllocator> bool RemoveMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.RemoveMember(name); }
 MemberIterator RemoveMember(MemberIterator m) const { return value_.RemoveMember(m); }
 MemberIterator EraseMember(ConstMemberIterator pos) const { return value_.EraseMember(pos); }
 MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const { return value_.EraseMember(first, last); }
 bool EraseMember(const Ch* name) const { return value_.EraseMember(name); }
#if RAPIDJSON_HAS_STDSTRING
 bool EraseMember(const std::basic_string<Ch>& name) const { return EraseMember(ValueType(StringRef(name))); }
#endif
 template <typename SourceAllocator> bool EraseMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.EraseMember(name); }

#if RAPIDJSON_HAS_CXX11_RANGE_FOR
 MemberIterator begin() const { return value_.MemberBegin(); }
 MemberIterator end() const { return value_.MemberEnd(); }
#endif

private:
 GenericObject();
 GenericObject(ValueType& value) : value_(value) {}
 ValueType& value_;
};

RAPIDJSON_NAMESPACE_END
RAPIDJSON_DIAG_POP

#endif // RAPIDJSON_DOCUMENT_H_