/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/document.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/document.h Source File#

Composable Kernel: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/document.h Source File
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.
 //
 // 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>
 #ifdef __cpp_lib_three_way_comparison
 #include <compare>
 #endif
  
 RAPIDJSON_DIAG_PUSH
 #ifdef __clang__
 RAPIDJSON_DIAG_OFF(padded)
 RAPIDJSON_DIAG_OFF(switch - enum)
 RAPIDJSON_DIAG_OFF(c++ 98 - compat)
 #elif defined(_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 __GNUC__
 RAPIDJSON_DIAG_OFF(effc++)
 #endif // __GNUC__
  
 #ifdef GetObject
 // see https://github.com/Tencent/rapidjson/issues/1448
 // a former included windows.h might have defined a macro called GetObject, which affects
 // GetObject defined here. This ensures the macro does not get applied
 #pragma push_macro("GetObject")
 #define RAPIDJSON_WINDOWS_GETOBJECT_WORKAROUND_APPLIED
 #undef GetObject
 #endif
  
 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
 #include <iterator> // std::random_access_iterator_tag
 #endif
  
 #if RAPIDJSON_USE_MEMBERSMAP
 #include <map> // std::multimap
 #endif
  
 RAPIDJSON_NAMESPACE_BEGIN
  
 // Forward declaration.
 template <typename Encoding, typename Allocator>
 class GenericValue;
  
 template <typename Encoding, typename Allocator, typename StackAllocator>
 class GenericDocument;
  
 #ifndef RAPIDJSON_DEFAULT_ALLOCATOR
 #define RAPIDJSON_DEFAULT_ALLOCATOR \
     ::RAPIDJSON_NAMESPACE::MemoryPoolAllocator<::RAPIDJSON_NAMESPACE::CrtAllocator>
 #endif
  
 #ifndef RAPIDJSON_DEFAULT_STACK_ALLOCATOR
 #define RAPIDJSON_DEFAULT_STACK_ALLOCATOR ::RAPIDJSON_NAMESPACE::CrtAllocator
 #endif
  
 #ifndef RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
 // number of objects that rapidjson::Value allocates memory for by default
 #define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY 16
 #endif
  
 #ifndef RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
 // number of array elements that rapidjson::Value allocates memory for by default
 #define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY 16
 #endif
  
  
 template <typename Encoding, typename Allocator>
 class GenericMember
 {
     public:
     GenericValue<Encoding, Allocator> name;  
     GenericValue<Encoding, Allocator> value; 
  
 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
     GenericMember(GenericMember&& rhs) RAPIDJSON_NOEXCEPT : name(std::move(rhs.name)),
                                                             value(std::move(rhs.value))
     {
     }
  
     GenericMember& operator=(GenericMember&& rhs) RAPIDJSON_NOEXCEPT
     {
         return *this = static_cast<GenericMember&>(rhs);
     }
 #endif
  
  
     GenericMember& operator=(GenericMember& rhs) RAPIDJSON_NOEXCEPT
     {
         if(RAPIDJSON_LIKELY(this != &rhs))
         {
             name  = rhs.name;
             value = rhs.value;
         }
         return *this;
     }
  
     // swap() for std::sort() and other potential use in STL.
     friend inline void swap(GenericMember& a, GenericMember& b) RAPIDJSON_NOEXCEPT
     {
         a.name.Swap(b.name);
         a.value.Swap(b.value);
     }
  
     private:
     GenericMember(const GenericMember& rhs);
 };
  
 // GenericMemberIterator
  
 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
  
  
 template <bool Const, typename Encoding, typename Allocator>
 class GenericMemberIterator
 {
  
     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;
  
     public:
     typedef GenericMemberIterator Iterator;
     typedef GenericMemberIterator<true, Encoding, Allocator> ConstIterator;
     typedef GenericMemberIterator<false, Encoding, Allocator> NonConstIterator;
  
     typedef ValueType value_type;
     typedef ValueType* pointer;
     typedef ValueType& reference;
     typedef std::ptrdiff_t difference_type;
     typedef std::random_access_iterator_tag iterator_category;
  
     typedef pointer Pointer;
     typedef reference Reference;
     typedef 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;
     }
  
  
     template <bool Const_>
     bool operator==(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ == that.ptr_;
     }
     template <bool Const_>
     bool operator!=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ != that.ptr_;
     }
     template <bool Const_>
     bool operator<=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ <= that.ptr_;
     }
     template <bool Const_>
     bool operator>=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ >= that.ptr_;
     }
     template <bool Const_>
     bool operator<(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ < that.ptr_;
     }
     template <bool Const_>
     bool operator>(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ > that.ptr_;
     }
  
 #ifdef __cpp_lib_three_way_comparison
     template <bool Const_>
     std::strong_ordering
     operator<=>(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const
     {
         return ptr_ <=> that.ptr_;
     }
 #endif
  
  
     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>
 class GenericMemberIterator;
  
 template <typename Encoding, typename Allocator>
 class GenericMemberIterator<false, Encoding, Allocator>
 {
     public:
     typedef GenericMember<Encoding, Allocator>* Iterator;
 };
 template <typename Encoding, typename Allocator>
 class GenericMemberIterator<true, Encoding, Allocator>
 {
     public:
     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(NotNullStrLen(str)) {}
  
 #ifndef __clang__ // -Wdocumentation
 #endif
     GenericStringRef(const CharType* str, SizeType len)
         : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len)
     {
         RAPIDJSON_ASSERT(str != 0 || len == 0u);
     }
  
     GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {}
  
     operator const Ch*() const { return s; }
  
     const Ch* const s;     
     const SizeType length; 
  
     private:
     SizeType NotNullStrLen(const CharType* str)
     {
         RAPIDJSON_ASSERT(str != 0);
         return internal::StrLen(str);
     }
  
     static const Ch emptyString[];
  
     template <SizeType N>
     GenericStringRef(CharType (&str)[N]) /* = delete */;
     GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */;
 };
  
 template <typename CharType>
 const CharType GenericStringRef<CharType>::emptyString[] = {CharType()};
  
  
 template <typename CharType>
 inline GenericStringRef<CharType> StringRef(const CharType* str)
 {
     return GenericStringRef<CharType>(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);
     }
 };
  
 #ifdef _MSC_VER
 RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
 template <typename ValueType>
 struct TypeHelper<ValueType, long>
 {
     static bool Is(const ValueType& v) { return v.IsInt(); }
     static long Get(const ValueType& v) { return v.GetInt(); }
     static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }
     static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&)
     {
         return v.SetInt(data);
     }
 };
  
 RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
 template <typename ValueType>
 struct TypeHelper<ValueType, unsigned long>
 {
     static bool Is(const ValueType& v) { return v.IsUint(); }
     static unsigned long Get(const ValueType& v) { return v.GetUint(); }
     static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }
     static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&)
     {
         return v.SetUint(data);
     }
 };
 #endif
  
 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&)
     {
         return 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 = RAPIDJSON_DEFAULT_ALLOCATOR>
 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[] = {kNullFlag,
                                                 kFalseFlag,
                                                 kTrueFlag,
                                                 kObjectFlag,
                                                 kArrayFlag,
                                                 kShortStringFlag,
                                                 kNumberAnyFlag};
         RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && 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,
                  bool copyConstStrings = false)
     {
         switch(rhs.GetType())
         {
         case kObjectType: DoCopyMembers(rhs, allocator, copyConstStrings); break;
         case kArrayType: {
             SizeType count = rhs.data_.a.size;
             GenericValue* le =
                 reinterpret_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
             const GenericValue<Encoding, SourceAllocator>* re = rhs.GetElementsPointer();
             for(SizeType i = 0; i < count; i++)
                 new(&le[i]) GenericValue(re[i], allocator, copyConstStrings);
             data_.f.flags = kArrayFlag;
             data_.a.size = data_.a.capacity = count;
             SetElementsPointer(le);
         }
         break;
         case kStringType:
             if(rhs.data_.f.flags == kConstStringFlag && !copyConstStrings)
             {
                 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;
         }
     }
  
  
 #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;
     }
  
     explicit GenericValue(float f) RAPIDJSON_NOEXCEPT : data_()
     {
         data_.n.d     = static_cast<double>(f);
         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()
     {
         // With RAPIDJSON_USE_MEMBERSMAP, the maps need to be destroyed to release
         // their Allocator if it's refcounted (e.g. MemoryPoolAllocator).
         if(Allocator::kNeedFree ||
            (RAPIDJSON_USE_MEMBERSMAP + 0 && internal::IsRefCounted<Allocator>::Value))
         {
             switch(data_.f.flags)
             {
             case kArrayFlag: {
                 GenericValue* e = GetElementsPointer();
                 for(GenericValue* v = e; v != e + data_.a.size; ++v)
                     v->~GenericValue();
                 if(Allocator::kNeedFree)
                 { // Shortcut by Allocator's trait
                     Allocator::Free(e);
                 }
             }
             break;
  
             case kObjectFlag: DoFreeMembers(); break;
  
             case kCopyStringFlag:
                 if(Allocator::kNeedFree)
                 { // Shortcut by Allocator's trait
                     Allocator::Free(const_cast<Ch*>(GetStringPointer()));
                 }
                 break;
  
             default: break; // Do nothing for other types.
             }
         }
     }
  
  
  
  
  
     GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT
     {
         if(RAPIDJSON_LIKELY(this != &rhs))
         {
             // Can't destroy "this" before assigning "rhs", otherwise "rhs"
             // could be used after free if it's an sub-Value of "this",
             // hence the temporary danse.
             GenericValue temp;
             temp.RawAssign(rhs);
             this->~GenericValue();
             RawAssign(temp);
         }
         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,
                            bool copyConstStrings = false)
     {
         RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));
         this->~GenericValue();
         new(this) GenericValue(rhs, allocator, copyConstStrings);
         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);
     }
  
 #ifndef __cpp_impl_three_way_comparison
  
     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);
     }
 #endif
  
  
  
     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;
     }
  
     SizeType MemberCapacity() const
     {
         RAPIDJSON_ASSERT(IsObject());
         return data_.o.capacity;
     }
  
     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
  
 #if RAPIDJSON_HAS_CXX11
             // Use thread-local storage to prevent races between threads.
             // Use static buffer and placement-new to prevent destruction, with
             // alignas() to ensure proper alignment.
             alignas(GenericValue) thread_local static char buffer[sizeof(GenericValue)];
             return *new(buffer) GenericValue();
 #elif defined(_MSC_VER) && _MSC_VER < 1900
             // There's no way to solve both thread locality and proper alignment
             // simultaneously.
             __declspec(thread) static char buffer[sizeof(GenericValue)];
             return *new(buffer) GenericValue();
 #elif defined(__GNUC__) || defined(__clang__)
                                          // This will generate -Wexit-time-destructors in clang, but
                                          // that's
                 // better than having under-alignment.
                 __thread static GenericValue buffer;
                 return buffer;
 #else
                                          // Don't know what compiler this is, so don't know how to
                                          // ensure
                 // thread-locality.
                 static GenericValue buffer;
                 return buffer;
 #endif
         }
     }
     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);
     }
  
  
     GenericValue& MemberReserve(SizeType newCapacity, Allocator& allocator)
     {
         RAPIDJSON_ASSERT(IsObject());
         DoReserveMembers(newCapacity, allocator);
         return *this;
     }
  
  
     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());
         return DoFindMember(name);
     }
     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());
         DoAddMember(name, value, allocator);
         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());
         DoClearMembers();
     }
  
  
     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());
         return DoRemoveMember(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());
         return DoEraseMembers(first, last);
     }
  
  
     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);
     }
     Object GetObj()
     {
         RAPIDJSON_ASSERT(IsObject());
         return Object(*this);
     }
     ConstObject GetObject() const
     {
         RAPIDJSON_ASSERT(IsObject());
         return ConstObject(*this);
     }
     ConstObject GetObj() 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(static_cast<void*>(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(static_cast<double>(f));
         return *this;
     }
  
  
  
  
     const Ch* GetString() const
     {
         RAPIDJSON_ASSERT(IsString());
         return DataString(data_);
     }
  
  
     SizeType GetStringLength() const
     {
         RAPIDJSON_ASSERT(IsString());
         return DataStringLength(data_);
     }
  
  
     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)
     {
         return SetString(StringRef(s, length), allocator);
     }
  
  
     GenericValue& SetString(const Ch* s, Allocator& allocator)
     {
         return SetString(StringRef(s), allocator);
     }
  
  
     GenericValue& SetString(StringRefType s, Allocator& allocator)
     {
         this->~GenericValue();
         SetStringRaw(s, allocator);
         return *this;
     }
  
 #if RAPIDJSON_HAS_STDSTRING
  
     GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator)
     {
         return SetString(StringRef(s), 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(ConstValueIterator 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,
         // These casts are added to suppress the warning on MSVC about bitwise operations between
         // enums of different types.
         kTrueFlag  = static_cast<int>(kTrueType) | static_cast<int>(kBoolFlag),
         kFalseFlag = static_cast<int>(kFalseType) | static_cast<int>(kBoolFlag),
         kNumberIntFlag =
             static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag),
         kNumberUintFlag = static_cast<int>(kNumberType) |
                           static_cast<int>(kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag),
         kNumberInt64Flag =
             static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kInt64Flag),
         kNumberUint64Flag =
             static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUint64Flag),
         kNumberDoubleFlag =
             static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kDoubleFlag),
         kNumberAnyFlag =
             static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag |
                                                              kUintFlag | kUint64Flag | kDoubleFlag),
         kConstStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag),
         kCopyStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag),
         kShortStringFlag = static_cast<int>(kStringType) |
                            static_cast<int>(kStringFlag | kCopyFlag | kInlineStrFlag),
         kObjectFlag = kObjectType,
         kArrayFlag  = kArrayType,
  
         kTypeMask = 0x07
     };
  
     static const SizeType kDefaultArrayCapacity  = RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY;
     static const SizeType kDefaultObjectCapacity = RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY;
  
     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
  
     static RAPIDJSON_FORCEINLINE const Ch* DataString(const Data& data)
     {
         return (data.f.flags & kInlineStrFlag) ? data.ss.str : RAPIDJSON_GETPOINTER(Ch, data.s.str);
     }
     static RAPIDJSON_FORCEINLINE SizeType DataStringLength(const Data& data)
     {
         return (data.f.flags & kInlineStrFlag) ? data.ss.GetLength() : data.s.length;
     }
  
     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);
     }
  
 #if RAPIDJSON_USE_MEMBERSMAP
  
     struct MapTraits
     {
         struct Less
         {
             bool operator()(const Data& s1, const Data& s2) const
             {
                 SizeType n1 = DataStringLength(s1), n2 = DataStringLength(s2);
                 int cmp =
                     std::memcmp(DataString(s1), DataString(s2), sizeof(Ch) * (n1 < n2 ? n1 : n2));
                 return cmp < 0 || (cmp == 0 && n1 < n2);
             }
         };
         typedef std::pair<const Data, SizeType> Pair;
         typedef std::multimap<Data, SizeType, Less, StdAllocator<Pair, Allocator>> Map;
         typedef typename Map::iterator Iterator;
     };
     typedef typename MapTraits::Map Map;
     typedef typename MapTraits::Less MapLess;
     typedef typename MapTraits::Pair MapPair;
     typedef typename MapTraits::Iterator MapIterator;
  
     //
     // Layout of the members' map/array, re(al)located according to the needed capacity:
     //
     //    {Map*}<>{capacity}<>{Member[capacity]}<>{MapIterator[capacity]}
     //
     // (where <> stands for the RAPIDJSON_ALIGN-ment, if needed)
     //
  
     static RAPIDJSON_FORCEINLINE size_t GetMapLayoutSize(SizeType capacity)
     {
         return RAPIDJSON_ALIGN(sizeof(Map*)) + RAPIDJSON_ALIGN(sizeof(SizeType)) +
                RAPIDJSON_ALIGN(capacity * sizeof(Member)) + capacity * sizeof(MapIterator);
     }
  
     static RAPIDJSON_FORCEINLINE SizeType& GetMapCapacity(Map*& map)
     {
         return *reinterpret_cast<SizeType*>(reinterpret_cast<uintptr_t>(&map) +
                                             RAPIDJSON_ALIGN(sizeof(Map*)));
     }
  
     static RAPIDJSON_FORCEINLINE Member* GetMapMembers(Map*& map)
     {
         return reinterpret_cast<Member*>(reinterpret_cast<uintptr_t>(&map) +
                                          RAPIDJSON_ALIGN(sizeof(Map*)) +
                                          RAPIDJSON_ALIGN(sizeof(SizeType)));
     }
  
     static RAPIDJSON_FORCEINLINE MapIterator* GetMapIterators(Map*& map)
     {
         return reinterpret_cast<MapIterator*>(
             reinterpret_cast<uintptr_t>(&map) + RAPIDJSON_ALIGN(sizeof(Map*)) +
             RAPIDJSON_ALIGN(sizeof(SizeType)) +
             RAPIDJSON_ALIGN(GetMapCapacity(map) * sizeof(Member)));
     }
  
     static RAPIDJSON_FORCEINLINE Map*& GetMap(Member* members)
     {
         RAPIDJSON_ASSERT(members != 0);
         return *reinterpret_cast<Map**>(reinterpret_cast<uintptr_t>(members) -
                                         RAPIDJSON_ALIGN(sizeof(SizeType)) -
                                         RAPIDJSON_ALIGN(sizeof(Map*)));
     }
  
     // Some compilers' debug mechanisms want all iterators to be destroyed, for their accounting..
     RAPIDJSON_FORCEINLINE MapIterator DropMapIterator(MapIterator& rhs)
     {
 #if RAPIDJSON_HAS_CXX11
         MapIterator ret = std::move(rhs);
 #else
         MapIterator ret = rhs;
 #endif
         rhs.~MapIterator();
         return ret;
     }
  
     Map*& DoReallocMap(Map** oldMap, SizeType newCapacity, Allocator& allocator)
     {
         Map** newMap = static_cast<Map**>(allocator.Malloc(GetMapLayoutSize(newCapacity)));
         GetMapCapacity(*newMap) = newCapacity;
         if(!oldMap)
         {
             *newMap = new(allocator.Malloc(sizeof(Map))) Map(MapLess(), allocator);
         }
         else
         {
             *newMap      = *oldMap;
             size_t count = (*oldMap)->size();
             std::memcpy(static_cast<void*>(GetMapMembers(*newMap)),
                         static_cast<void*>(GetMapMembers(*oldMap)),
                         count * sizeof(Member));
             MapIterator *oldIt = GetMapIterators(*oldMap), *newIt = GetMapIterators(*newMap);
             while(count--)
             {
                 new(&newIt[count]) MapIterator(DropMapIterator(oldIt[count]));
             }
             Allocator::Free(oldMap);
         }
         return *newMap;
     }
  
     RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator)
     {
         return GetMapMembers(DoReallocMap(0, capacity, allocator));
     }
  
     void DoReserveMembers(SizeType newCapacity, Allocator& allocator)
     {
         ObjectData& o = data_.o;
         if(newCapacity > o.capacity)
         {
             Member* oldMembers = GetMembersPointer();
             Map **oldMap       = oldMembers ? &GetMap(oldMembers) : 0,
                 *&newMap       = DoReallocMap(oldMap, newCapacity, allocator);
             RAPIDJSON_SETPOINTER(Member, o.members, GetMapMembers(newMap));
             o.capacity = newCapacity;
         }
     }
  
     template <typename SourceAllocator>
     MemberIterator DoFindMember(const GenericValue<Encoding, SourceAllocator>& name)
     {
         if(Member* members = GetMembersPointer())
         {
             Map*& map       = GetMap(members);
             MapIterator mit = map->find(reinterpret_cast<const Data&>(name.data_));
             if(mit != map->end())
             {
                 return MemberIterator(&members[mit->second]);
             }
         }
         return MemberEnd();
     }
  
     void DoClearMembers()
     {
         if(Member* members = GetMembersPointer())
         {
             Map*& map        = GetMap(members);
             MapIterator* mit = GetMapIterators(map);
             for(SizeType i = 0; i < data_.o.size; i++)
             {
                 map->erase(DropMapIterator(mit[i]));
                 members[i].~Member();
             }
             data_.o.size = 0;
         }
     }
  
     void DoFreeMembers()
     {
         if(Member* members = GetMembersPointer())
         {
             GetMap(members)->~Map();
             for(SizeType i = 0; i < data_.o.size; i++)
             {
                 members[i].~Member();
             }
             if(Allocator::kNeedFree)
             { // Shortcut by Allocator's trait
                 Map** map = &GetMap(members);
                 Allocator::Free(*map);
                 Allocator::Free(map);
             }
         }
     }
  
 #else // !RAPIDJSON_USE_MEMBERSMAP
  
     RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator)
     {
         return Malloc<Member>(allocator, capacity);
     }
  
     void DoReserveMembers(SizeType newCapacity, Allocator& allocator)
     {
         ObjectData& o = data_.o;
         if(newCapacity > o.capacity)
         {
             Member* newMembers =
                 Realloc<Member>(allocator, GetMembersPointer(), o.capacity, newCapacity);
             RAPIDJSON_SETPOINTER(Member, o.members, newMembers);
             o.capacity = newCapacity;
         }
     }
  
     template <typename SourceAllocator>
     MemberIterator DoFindMember(const GenericValue<Encoding, SourceAllocator>& name)
     {
         MemberIterator member = MemberBegin();
         for(; member != MemberEnd(); ++member)
             if(name.StringEqual(member->name))
                 break;
         return member;
     }
  
     void DoClearMembers()
     {
         for(MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
             m->~Member();
         data_.o.size = 0;
     }
  
     void DoFreeMembers()
     {
         for(MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
             m->~Member();
         Allocator::Free(GetMembersPointer());
     }
  
 #endif // !RAPIDJSON_USE_MEMBERSMAP
  
     void DoAddMember(GenericValue& name, GenericValue& value, Allocator& allocator)
     {
         ObjectData& o = data_.o;
         if(o.size >= o.capacity)
             DoReserveMembers(o.capacity ? (o.capacity + (o.capacity + 1) / 2)
                                         : kDefaultObjectCapacity,
                              allocator);
         Member* members = GetMembersPointer();
         Member* m       = members + o.size;
         m->name.RawAssign(name);
         m->value.RawAssign(value);
 #if RAPIDJSON_USE_MEMBERSMAP
         Map*& map        = GetMap(members);
         MapIterator* mit = GetMapIterators(map);
         new(&mit[o.size]) MapIterator(map->insert(MapPair(m->name.data_, o.size)));
 #endif
         ++o.size;
     }
  
     MemberIterator DoRemoveMember(MemberIterator m)
     {
         ObjectData& o   = data_.o;
         Member* members = GetMembersPointer();
 #if RAPIDJSON_USE_MEMBERSMAP
         Map*& map        = GetMap(members);
         MapIterator* mit = GetMapIterators(map);
         SizeType mpos    = static_cast<SizeType>(&*m - members);
         map->erase(DropMapIterator(mit[mpos]));
 #endif
         MemberIterator last(members + (o.size - 1));
         if(o.size > 1 && m != last)
         {
 #if RAPIDJSON_USE_MEMBERSMAP
             new(&mit[mpos]) MapIterator(DropMapIterator(mit[&*last - members]));
             mit[mpos]->second = mpos;
 #endif
             *m = *last; // Move the last one to this place
         }
         else
         {
             m->~Member(); // Only one left, just destroy
         }
         --o.size;
         return m;
     }
  
     MemberIterator DoEraseMembers(ConstMemberIterator first, ConstMemberIterator last)
     {
         ObjectData& o      = data_.o;
         MemberIterator beg = MemberBegin(), pos = beg + (first - beg), end = MemberEnd();
 #if RAPIDJSON_USE_MEMBERSMAP
         Map*& map        = GetMap(GetMembersPointer());
         MapIterator* mit = GetMapIterators(map);
 #endif
         for(MemberIterator itr = pos; itr != last; ++itr)
         {
 #if RAPIDJSON_USE_MEMBERSMAP
             map->erase(DropMapIterator(mit[itr - beg]));
 #endif
             itr->~Member();
         }
 #if RAPIDJSON_USE_MEMBERSMAP
         if(first != last)
         {
             // Move remaining members/iterators
             MemberIterator next = pos + (last - first);
             for(MemberIterator itr = pos; next != end; ++itr, ++next)
             {
                 std::memcpy(static_cast<void*>(&*itr), &*next, sizeof(Member));
                 SizeType mpos = static_cast<SizeType>(itr - beg);
                 new(&mit[mpos]) MapIterator(DropMapIterator(mit[next - beg]));
                 mit[mpos]->second = mpos;
             }
         }
 #else
         std::memmove(
             static_cast<void*>(&*pos), &*last, static_cast<size_t>(end - last) * sizeof(Member));
 #endif
         o.size -= static_cast<SizeType>(last - first);
         return pos;
     }
  
     template <typename SourceAllocator>
     void DoCopyMembers(const GenericValue<Encoding, SourceAllocator>& rhs,
                        Allocator& allocator,
                        bool copyConstStrings)
     {
         RAPIDJSON_ASSERT(rhs.GetType() == kObjectType);
  
         data_.f.flags  = kObjectFlag;
         SizeType count = rhs.data_.o.size;
         Member* lm     = DoAllocMembers(count, allocator);
         const typename GenericValue<Encoding, SourceAllocator>::Member* rm =
             rhs.GetMembersPointer();
 #if RAPIDJSON_USE_MEMBERSMAP
         Map*& map        = GetMap(lm);
         MapIterator* mit = GetMapIterators(map);
 #endif
         for(SizeType i = 0; i < count; i++)
         {
             new(&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings);
             new(&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings);
 #if RAPIDJSON_USE_MEMBERSMAP
             new(&mit[i]) MapIterator(map->insert(MapPair(lm[i].name.data_, i)));
 #endif
         }
         data_.o.size = data_.o.capacity = count;
         SetMembersPointer(lm);
     }
  
     // 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(static_cast<void*>(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 = DoAllocMembers(count, allocator);
             SetMembersPointer(m);
             std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
 #if RAPIDJSON_USE_MEMBERSMAP
             Map*& map        = GetMap(m);
             MapIterator* mit = GetMapIterators(map);
             for(SizeType i = 0; i < count; i++)
             {
                 new(&mit[i]) MapIterator(map->insert(MapPair(m[i].name.data_, i)));
             }
 #endif
         }
         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;
             std::memmove(str, s, s.length * sizeof(Ch));
         }
         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      = RAPIDJSON_DEFAULT_ALLOCATOR,
           typename StackAllocator = RAPIDJSON_DEFAULT_STACK_ALLOCATOR>
 class GenericDocument : public GenericValue<Encoding, Allocator>
 {
     public:
     typedef typename Encoding::Ch Ch;                    
     typedef GenericValue<Encoding, Allocator> ValueType; 
     typedef Allocator AllocatorType;           
     typedef StackAllocator StackAllocatorType; 
  
  
     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()
     {
         // Clear the ::ValueType before ownAllocator is destroyed, ~ValueType()
         // runs last and may access its elements or members which would be freed
         // with an allocator like MemoryPoolAllocator (CrtAllocator does not
         // free its data when destroyed, but MemoryPoolAllocator does).
         if(ownAllocator_)
         {
             ValueType::SetNull();
         }
         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;
     }
  
     // Allow Swap with ValueType.
     // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names.
     using ValueType::Swap;
  
  
     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(reinterpret_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;
  
  
 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() {}
  
     operator ValueType&() const { return value_; }
     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() {}
  
     operator ValueType&() const { return value_; }
     SizeType MemberCount() const { return value_.MemberCount(); }
     SizeType MemberCapacity() const { return value_.MemberCapacity(); }
     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(); }
     GenericObject MemberReserve(SizeType newCapacity, AllocatorType& allocator) const
     {
         value_.MemberReserve(newCapacity, allocator);
         return *this;
     }
     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() { 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
  
 #ifdef RAPIDJSON_WINDOWS_GETOBJECT_WORKAROUND_APPLIED
 #pragma pop_macro("GetObject")
 #undef RAPIDJSON_WINDOWS_GETOBJECT_WORKAROUND_APPLIED
 #endif
  
 #endif // RAPIDJSON_DOCUMENT_H_