no longer need to pass the size to rapidjson

31 files changed, 3762 insertions, 1142 deletions

diff --git a/external/rapidjson/allocators.h b/external/rapidjson/allocators.h
index c99485e50..05e3b0cea 100644
--- a/external/rapidjson/allocators.h
+++ b/external/rapidjson/allocators.h
@@ -1,29 +1,23 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_ALLOCATORS_H_

 #define RAPIDJSON_ALLOCATORS_H_

 

 #include "rapidjson.h"

 

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 

 ///////////////////////////////////////////////////////////////////////////////

 // Allocator

@@ -68,8 +62,20 @@ concept Allocator {
 class CrtAllocator {

 public:

     static const bool kNeedFree = true;

-    void* Malloc(size_t size) { return std::malloc(size); }

-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { (void)originalSize; return std::realloc(originalPtr, newSize); }

+    void* Malloc(size_t size) { 

+        if (size) //  behavior of malloc(0) is implementation defined.

+            return std::malloc(size);

+        else

+            return NULL; // standardize to returning NULL.

+    }

+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {

+        (void)originalSize;

+        if (newSize == 0) {

+            std::free(originalPtr);

+            return NULL;

+        }

+        return std::realloc(originalPtr, newSize);

+    }

     static void Free(void *ptr) { std::free(ptr); }

 };

 

@@ -104,9 +110,6 @@ public:
     MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 

         chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)

     {

-        if (!baseAllocator_)

-            ownBaseAllocator_ = baseAllocator_ = new BaseAllocator();

-        AddChunk(chunk_capacity_);

     }

 

     //! Constructor with user-supplied buffer.

@@ -135,16 +138,18 @@ public:
     */

     ~MemoryPoolAllocator() {

         Clear();

-        delete ownBaseAllocator_;

+        RAPIDJSON_DELETE(ownBaseAllocator_);

     }

 

     //! Deallocates all memory chunks, excluding the user-supplied buffer.

     void Clear() {

-        while(chunkHead_ != 0 && chunkHead_ != userBuffer_) {

+        while (chunkHead_ && chunkHead_ != userBuffer_) {

             ChunkHeader* next = chunkHead_->next;

             baseAllocator_->Free(chunkHead_);

             chunkHead_ = next;

         }

+        if (chunkHead_ && chunkHead_ == userBuffer_)

+            chunkHead_->size = 0; // Clear user buffer

     }

 

     //! Computes the total capacity of allocated memory chunks.

@@ -169,11 +174,14 @@ public:
 

     //! Allocates a memory block. (concept Allocator)

     void* Malloc(size_t size) {

+        if (!size)

+            return NULL;

+

         size = RAPIDJSON_ALIGN(size);

         if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)

             AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size);

 

-        void *buffer = reinterpret_cast<char *>(chunkHead_ + 1) + chunkHead_->size;

+        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;

         chunkHead_->size += size;

         return buffer;

     }

@@ -183,12 +191,15 @@ public:
         if (originalPtr == 0)

             return Malloc(newSize);

 

+        if (newSize == 0)

+            return NULL;

+

         // Do not shrink if new size is smaller than original

         if (originalSize >= newSize)

             return originalPtr;

 

         // Simply expand it if it is the last allocation and there is sufficient space

-        if (originalPtr == (char *)(chunkHead_ + 1) + chunkHead_->size - originalSize) {

+        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {

             size_t increment = static_cast<size_t>(newSize - originalSize);

             increment = RAPIDJSON_ALIGN(increment);

             if (chunkHead_->size + increment <= chunkHead_->capacity) {

@@ -200,7 +211,9 @@ public:
         // Realloc process: allocate and copy memory, do not free original buffer.

         void* newBuffer = Malloc(newSize);

         RAPIDJSON_ASSERT(newBuffer != 0);   // Do not handle out-of-memory explicitly.

-        return std::memcpy(newBuffer, originalPtr, originalSize);

+        if (originalSize)

+            std::memcpy(newBuffer, originalPtr, originalSize);

+        return newBuffer;

     }

 

     //! Frees a memory block (concept Allocator)

@@ -216,7 +229,9 @@ private:
     /*! \param capacity Capacity of the chunk in bytes.

     */

     void AddChunk(size_t capacity) {

-        ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(sizeof(ChunkHeader) + capacity));

+        if (!baseAllocator_)

+            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator());

+        ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity));

         chunk->capacity = capacity;

         chunk->size = 0;

         chunk->next = chunkHead_;

@@ -241,6 +256,6 @@ private:
     BaseAllocator* ownBaseAllocator_;   //!< base allocator created by this object.

 };

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_ENCODINGS_H_

diff --git a/external/rapidjson/document.h b/external/rapidjson/document.h
index ea161ceed..095aa406b 100644
--- a/external/rapidjson/document.h
+++ b/external/rapidjson/document.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_

@@ -26,50 +20,41 @@
 #include "reader.h"

 #include "internal/meta.h"

 #include "internal/strfunc.h"

-#include "memorystream.h"

-#include "encodedstream.h"

 #include <new>      // placement new

 

 #ifdef _MSC_VER

 RAPIDJSON_DIAG_PUSH

 RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant

-#elif defined(__GNUC__)

-RAPIDJSON_DIAG_PUSH

-RAPIDJSON_DIAG_OFF(effc++)

 #endif

 

-///////////////////////////////////////////////////////////////////////////////

-// RAPIDJSON_HAS_STDSTRING

-

-#ifndef RAPIDJSON_HAS_STDSTRING

-#ifdef RAPIDJSON_DOXYGEN_RUNNING

-#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation

-#else

-#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default

+#ifdef __clang__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(padded)

+RAPIDJSON_DIAG_OFF(switch-enum)

 #endif

-/*! \def RAPIDJSON_HAS_STDSTRING

-    \ingroup RAPIDJSON_CONFIG

-    \brief Enable RapidJSON support for \c std::string

-

-    By defining this preprocessor symbol to \c 1, several convenience functions for using

-    \ref rapidjson::GenericValue with \c std::string are enabled, especially

-    for construction and comparison.

 

-    \hideinitializer

-*/

-#include <string>

-#endif // RAPIDJSON_HAS_STDSTRING

+#ifdef __GNUC__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(effc++)

+#endif

 

 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS

 #include <iterator> // std::iterator, std::random_access_iterator_tag

 #endif

 

-namespace rapidjson {

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+#include <utility> // std::move

+#endif

+

+RAPIDJSON_NAMESPACE_BEGIN

 

 // Forward declaration.

 template <typename Encoding, typename Allocator>

 class GenericValue;

 

+template <typename Encoding, typename Allocator, typename StackAllocator>

+class GenericDocument;

+

 //! Name-value pair in a JSON object value.

 /*!

     This class was internal to GenericValue. It used to be a inner struct.

@@ -258,6 +243,7 @@ struct GenericStringRef {
     typedef CharType Ch; //!< character type of the string

 

     //! Create string reference from \c const character array

+#ifndef __clang__ // -Wdocumentation

     /*!

         This constructor implicitly creates a constant string reference from

         a \c const character array.  It has better performance than

@@ -280,11 +266,13 @@ struct GenericStringRef {
             In such cases, the referenced string should be \b copied to the

             GenericValue instead.

      */

+#endif

     template<SizeType N>

     GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT

         : s(str), length(N-1) {}

 

     //! Explicitly create string reference from \c const character pointer

+#ifndef __clang__ // -Wdocumentation

     /*!

         This constructor can be used to \b explicitly  create a reference to

         a constant string pointer.

@@ -303,16 +291,19 @@ struct GenericStringRef {
             In such cases, the referenced string should be \b copied to the

             GenericValue instead.

      */

+#endif

     explicit GenericStringRef(const CharType* str)

         : s(str), length(internal::StrLen(str)){ RAPIDJSON_ASSERT(s != NULL); }

 

     //! Create constant string reference from pointer and length

+#ifndef __clang__ // -Wdocumentation

     /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue

         \param len length of the string, excluding the trailing NULL terminator

 

         \post \ref s == str && \ref length == len

         \note Constant complexity.

      */

+#endif

     GenericStringRef(const CharType* str, SizeType len)

         : s(str), length(len) { RAPIDJSON_ASSERT(s != NULL); }

 

@@ -428,6 +419,7 @@ public:
     typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator;  //!< Constant member iterator for iterating in object.

     typedef GenericValue* ValueIterator;            //!< Value iterator for iterating in array.

     typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array.

+    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of itself.

 

     //!@name Constructors and destructor.

     //@{

@@ -446,6 +438,16 @@ private:
     //! Copy constructor is not permitted.

     GenericValue(const GenericValue& rhs);

 

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    //! Moving from a GenericDocument is not permitted.

+    template <typename StackAllocator>

+    GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);

+

+    //! Move assignment from a GenericDocument is not permitted.

+    template <typename StackAllocator>

+    GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);

+#endif

+

 public:

 

     //! Constructor with JSON value type.

@@ -453,13 +455,17 @@ public:
         \param type Type of the value.

         \note Default content for number is zero.

     */

-    GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_(), flags_() {

+    explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_(), flags_() {

         static const unsigned defaultFlags[7] = {

-            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kConstStringFlag,

+            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,

             kNumberAnyFlag

         };

         RAPIDJSON_ASSERT(type <= kNumberType);

         flags_ = defaultFlags[type];

+

+        // Use ShortString to store empty string.

+        if (type == kStringType)

+            data_.ss.SetLength(0);

     }

 

     //! Explicit copy constructor (with allocator)

@@ -637,7 +643,7 @@ public:
      */

     template <typename SourceAllocator>

     GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator) {

-        RAPIDJSON_ASSERT((void*)this != (void const*)&rhs);

+        RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));

         this->~GenericValue();

         new (this) GenericValue(rhs, allocator);

         return *this;

@@ -656,6 +662,20 @@ public:
         return *this;

     }

 

+    //! free-standing swap function helper

+    /*!

+        Helper function to enable support for common swap implementation pattern based on \c std::swap:

+        \code

+        void swap(MyClass& a, MyClass& b) {

+            using std::swap;

+            swap(a.value, b.value);

+            // ...

+        }

+        \endcode

+        \see Swap()

+     */

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

+

     //! Prepare Value for move semantics

     /*! \return *this */

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

@@ -697,12 +717,15 @@ public:
             return StringEqual(rhs);

 

         case kNumberType:

-            if (IsDouble() || rhs.IsDouble())

-                return GetDouble() == rhs.GetDouble(); // May convert one operand from integer to double.

+            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: // kTrueType, kFalseType, kNullType

+        default:

             return true;

         }

     }

@@ -797,22 +820,32 @@ public:
     //! Check whether the object is empty.

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

 

-    //! Get the value associated with the name.

-    /*!

+    //! Get a value from an object associated with the name.

+    /*! \pre IsObject() == true

+        \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType))

         \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7.

         Since 0.2, if the name is not correct, it will assert.

         If user is unsure whether a member exists, user should use HasMember() first.

         A better approach is to use FindMember().

         \note Linear time complexity.

     */

-    GenericValue& operator[](const Ch* name) {

+    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];

     }

-    const GenericValue& operator[](const Ch* name) const { return const_cast<GenericValue&>(*this)[name]; }

+    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]; }

+

+    //! Get a value from an object associated with the name.

+    /*! \pre IsObject() == true

+        \tparam SourceAllocator Allocator of the \c name value

 

-    // This version is faster because it does not need a StrLen(). 

-    // It can also handle string with null character.

+        \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen().

+        And it can also handle strings with embedded null characters.

+

+        \note Linear time complexity.

+    */

     template <typename SourceAllocator>

     GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {

         MemberIterator member = FindMember(name);

@@ -820,13 +853,25 @@ public:
             return member->value;

         else {

             RAPIDJSON_ASSERT(false);    // see above note

-            static GenericValue NullValue;

-            return NullValue;

+

+            // This will generate -Wexit-time-destructors in clang

+            // static GenericValue NullValue;

+            // return NullValue;

+

+            // Use static buffer and placement-new to prevent destruction

+            static char buffer[sizeof(GenericValue)];

+            return *new (buffer) GenericValue();

         }

     }

     template <typename SourceAllocator>

     const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }

 

+#if RAPIDJSON_HAS_STDSTRING

+    //! Get a value from an object associated with name (string object).

+    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

+

     //! Const member iterator

     /*! \pre IsObject() == true */

     ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(data_.o.members); }

@@ -850,6 +895,18 @@ public:
     */

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

 

+#if RAPIDJSON_HAS_STDSTRING

+    //! Check whether a member exists in the object with string object.

+    /*!

+        \param name Member name to be searched.

+        \pre IsObject() == true

+        \return Whether a member with that name exists.

+        \note It is better to use FindMember() directly if you need the obtain the value as well.

+        \note Linear time complexity.

+    */

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

+#endif

+

     //! Check whether a member exists in the object with GenericValue name.

     /*!

         This version is faster because it does not need a StrLen(). It can also handle string with null character.

@@ -906,6 +963,18 @@ public:
     }

     template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); }

 

+#if RAPIDJSON_HAS_STDSTRING

+    //! Find member by string object name.

+    /*!

+        \param name Member name to be searched.

+        \pre IsObject() == true

+        \return Iterator to member, if it exists.

+            Otherwise returns \ref MemberEnd().

+    */

+    MemberIterator FindMember(const std::basic_string<Ch>& name) { return FindMember(StringRef(name)); }

+    ConstMemberIterator FindMember(const std::basic_string<Ch>& name) const { return FindMember(StringRef(name)); }

+#endif

+

     //! Add a member (name-value pair) to the object.

     /*! \param name A string value as name of member.

         \param value Value of any type.

@@ -938,6 +1007,60 @@ public:
         return *this;

     }

 

+    //! Add a constant string value as member (name-value pair) to the object.

+    /*! \param name A string value as name of member.

+        \param value constant string reference as value of member.

+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().

+        \return The value itself for fluent API.

+        \pre  IsObject()

+        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.

+        \note Amortized Constant time complexity.

+    */

+    GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) {

+        GenericValue v(value);

+        return AddMember(name, v, allocator);

+    }

+

+#if RAPIDJSON_HAS_STDSTRING

+    //! Add a string object as member (name-value pair) to the object.

+    /*! \param name A string value as name of member.

+        \param value constant string reference as value of member.

+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().

+        \return The value itself for fluent API.

+        \pre  IsObject()

+        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.

+        \note Amortized Constant time complexity.

+    */

+    GenericValue& AddMember(GenericValue& name, std::basic_string<Ch>& value, Allocator& allocator) {

+        GenericValue v(value, allocator);

+        return AddMember(name, v, allocator);

+    }

+#endif

+

+    //! Add any primitive value as member (name-value pair) to the object.

+    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t

+        \param name A string value as name of member.

+        \param value Value of primitive type \c T as value of member

+        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().

+        \return The value itself for fluent API.

+        \pre  IsObject()

+

+        \note The source type \c T explicitly disallows all pointer types,

+            especially (\c const) \ref Ch*.  This helps avoiding implicitly

+            referencing character strings with insufficient lifetime, use

+            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref

+            AddMember(StringRefType, StringRefType, Allocator&).

+            All other pointer types would implicitly convert to \c bool,

+            use an explicit cast instead, if needed.

+        \note Amortized Constant time complexity.

+    */

+    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);

@@ -1005,8 +1128,7 @@ public:
     RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))

     AddMember(StringRefType name, T value, Allocator& allocator) {

         GenericValue n(name);

-        GenericValue v(value);

-        return AddMember(n, v, allocator);

+        return AddMember(n, value, allocator);

     }

 

     //! Remove all members in the object.

@@ -1023,7 +1145,9 @@ public:
     //! Remove a member in object by its name.

     /*! \param name Name of member to be removed.

         \return Whether the member existed.

-        \note Removing member is implemented by moving the last member. So the ordering of members is changed.

+        \note This function may reorder the object members. Use \ref

+            EraseMember(ConstMemberIterator) if you need to preserve the

+            relative order of the remaining members.

         \note Linear time complexity.

     */

     bool RemoveMember(const Ch* name) {

@@ -1031,6 +1155,10 @@ public:
         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);

@@ -1045,8 +1173,9 @@ public:
     //! Remove a member in object by iterator.

     /*! \param m member iterator (obtained by FindMember() or MemberBegin()).

         \return the new iterator after removal.

-        \note Removing member is implemented by moving the last member. So the ordering of members is changed.

-        \note Use \ref EraseMember(ConstMemberIterator) instead, if you need to rely on a stable member ordering.

+        \note This function may reorder the object members. Use \ref

+            EraseMember(ConstMemberIterator) if you need to preserve the

+            relative order of the remaining members.

         \note Constant time complexity.

     */

     MemberIterator RemoveMember(MemberIterator m) {

@@ -1073,7 +1202,8 @@ public:
         \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd()

         \return Iterator following the removed element.

             If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned.

-        \note Other than \ref RemoveMember(MemberIterator), this function preserves the ordering of the members.

+        \note This function preserves the relative order of the remaining object

+            members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator).

         \note Linear time complexity.

     */

     MemberIterator EraseMember(ConstMemberIterator pos) {

@@ -1085,7 +1215,8 @@ public:
         \param last  iterator following the last member to remove

         \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd()

         \return Iterator following the last removed element.

-        \note Other than \ref RemoveMember(MemberIterator), this function preserves the ordering of the members.

+        \note This function preserves the relative order of the remaining object

+            members.

         \note Linear time complexity.

     */

     MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) {

@@ -1099,11 +1230,36 @@ public:
         MemberIterator pos = MemberBegin() + (first - MemberBegin());

         for (MemberIterator itr = pos; itr != last; ++itr)

             itr->~Member();

-        std::memmove(&*pos, &*last, (MemberEnd() - last) * sizeof(Member));

-        data_.o.size -= (last - first);

+        std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));

+        data_.o.size -= static_cast<SizeType>(last - first);

         return pos;

     }

 

+    //! Erase a member in object by its name.

+    /*! \param name Name of member to be removed.

+        \return Whether the member existed.

+        \note Linear time complexity.

+    */

+    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;

+    }

+

     //@}

 

     //!@name Array

@@ -1134,14 +1290,9 @@ public:
     }

 

     //! Get an element from array by index.

-    /*! \param index Zero-based index of element.

-\code

-Value a(kArrayType);

-a.PushBack(123);

-int x = a[0].GetInt();              // Error: operator[ is ambiguous, as 0 also mean a null pointer of const char* type.

-int y = a[SizeType(0)].GetInt();    // Cast to SizeType will work.

-int z = a[0u].GetInt();             // This works too.

-\endcode

+    /*! \pre IsArray() == true

+        \param index Zero-based index of element.

+        \see operator[](T*)

     */

     GenericValue& operator[](SizeType index) {

         RAPIDJSON_ASSERT(IsArray());

@@ -1172,7 +1323,7 @@ int z = a[0u].GetInt();             // This works too.
     GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {

         RAPIDJSON_ASSERT(IsArray());

         if (newCapacity > data_.a.capacity) {

-            data_.a.elements = (GenericValue*)allocator.Realloc(data_.a.elements, data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue));

+            data_.a.elements = static_cast<GenericValue*>(allocator.Realloc(data_.a.elements, data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue)));

             data_.a.capacity = newCapacity;

         }

         return *this;

@@ -1279,8 +1430,8 @@ int z = a[0u].GetInt();             // This works too.
         ValueIterator pos = Begin() + (first - Begin());

         for (ValueIterator itr = pos; itr != last; ++itr)

             itr->~GenericValue();       

-        std::memmove(pos, last, (End() - last) * sizeof(GenericValue));

-        data_.a.size -= (last - first);

+        std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));

+        data_.a.size -= static_cast<SizeType>(last - first);

         return pos;

     }

 

@@ -1299,8 +1450,8 @@ int z = a[0u].GetInt();             // This works too.
         if ((flags_ & kDoubleFlag) != 0)                return data_.n.d;   // exact type, no conversion.

         if ((flags_ & kIntFlag) != 0)                   return data_.n.i.i; // int -> double

         if ((flags_ & kUintFlag) != 0)                  return data_.n.u.u; // unsigned -> double

-        if ((flags_ & kInt64Flag) != 0)                 return (double)data_.n.i64; // int64_t -> double (may lose precision)

-        RAPIDJSON_ASSERT((flags_ & kUint64Flag) != 0);  return (double)data_.n.u64; // uint64_t -> double (may lose precision)

+        if ((flags_ & kInt64Flag) != 0)                 return static_cast<double>(data_.n.i64); // int64_t -> double (may lose precision)

+        RAPIDJSON_ASSERT((flags_ & kUint64Flag) != 0);  return static_cast<double>(data_.n.u64); // uint64_t -> double (may lose precision)

     }

 

     GenericValue& SetInt(int i)             { this->~GenericValue(); new (this) GenericValue(i);    return *this; }

@@ -1364,7 +1515,7 @@ int z = a[0u].GetInt();             // This works too.
         \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size()

         \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.

     */

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

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

 #endif

 

     //@}

@@ -1387,6 +1538,7 @@ int z = a[0u].GetInt();             // This works too.
             if (!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 (!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.flags_ & kCopyFlag) != 0))

                     return false;

                 if (!m->value.Accept(handler))

@@ -1405,17 +1557,14 @@ int z = a[0u].GetInt();             // This works too.
         case kStringType:

             return handler.String(GetString(), GetStringLength(), (flags_ & kCopyFlag) != 0);

     

-        case kNumberType:

+        default:

+            RAPIDJSON_ASSERT(GetType() == kNumberType);

             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 if (IsUint64())    return handler.Uint64(data_.n.u64);

             else                    return handler.Double(data_.n.d);

-    

-        default:

-            RAPIDJSON_ASSERT(false);

         }

-        return false;

     }

 

 private:

@@ -1474,9 +1623,9 @@ private:
         enum { MaxChars = sizeof(String) / 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] = (Ch)(MaxSize -  len); }

-        inline SizeType GetLength() const       { return  (SizeType)(MaxSize -  str[LenPos]); }

+        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.

@@ -1528,16 +1677,24 @@ private:
     // Initialize this value as array with initial data, without calling destructor.

     void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {

         flags_ = kArrayFlag;

-        data_.a.elements = (GenericValue*)allocator.Malloc(count * sizeof(GenericValue));

-        std::memcpy(data_.a.elements, values, count * sizeof(GenericValue));

+        if (count) {

+            data_.a.elements = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));

+            std::memcpy(data_.a.elements, values, count * sizeof(GenericValue));

+        }

+        else

+            data_.a.elements = NULL;

         data_.a.size = data_.a.capacity = count;

     }

 

     //! Initialize this value as object with initial data, without calling destructor.

     void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {

         flags_ = kObjectFlag;

-        data_.o.members = (Member*)allocator.Malloc(count * sizeof(Member));

-        std::memcpy(data_.o.members, members, count * sizeof(Member));

+        if (count) {

+            data_.o.members = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));

+            std::memcpy(data_.o.members, members, count * sizeof(Member));

+        }

+        else

+            data_.o.members = NULL;

         data_.o.size = data_.o.capacity = count;

     }

 

@@ -1558,7 +1715,7 @@ private:
         } else {

             flags_ = kCopyStringFlag;

             data_.s.length = s.length;

-            str = (Ch *)allocator.Malloc((s.length + 1) * sizeof(Ch));

+            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));

             data_.s.str = str;

         }

         std::memcpy(str, s, s.length * sizeof(Ch));

@@ -1614,7 +1771,22 @@ public:
     typedef Allocator AllocatorType;                        //!< Allocator type from template parameter.

 

     //! Constructor

-    /*! \param allocator        Optional allocator for allocating memory.

+    /*! Creates an empty document of specified type.

+        \param type             Mandatory type of object to create.

+        \param allocator        Optional allocator for allocating memory.

+        \param stackCapacity    Optional initial capacity of stack in bytes.

+        \param stackAllocator   Optional allocator for allocating memory for stack.

+    */

+    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());

+    }

+

+    //! Constructor

+    /*! Creates an empty document which type is Null. 

+        \param allocator        Optional allocator for allocating memory.

         \param stackCapacity    Optional initial capacity of stack in bytes.

         \param stackAllocator   Optional allocator for allocating memory for stack.

     */

@@ -1622,13 +1794,81 @@ public:
         allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()

     {

         if (!allocator_)

-            ownAllocator_ = allocator_ = new Allocator();

+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());

     }

 

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    //! Move constructor in C++11

+    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() {

-        delete ownAllocator_;

+        Destroy();

     }

 

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    //! Move assignment in C++11

+    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

+

+    //! Exchange the contents of this document with those of another.

+    /*!

+        \param rhs Another document.

+        \note Constant complexity.

+        \see GenericValue::Swap

+    */

+    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;

+    }

+

+    //! free-standing swap function helper

+    /*!

+        Helper function to enable support for common swap implementation pattern based on \c std::swap:

+        \code

+        void swap(MyClass& a, MyClass& b) {

+            using std::swap;

+            swap(a.doc, b.doc);

+            // ...

+        }

+        \endcode

+        \see Swap()

+     */

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

+

     //!@name Parse from stream

     //!@{

 

@@ -1641,13 +1881,13 @@ public:
     */

     template <unsigned parseFlags, typename SourceEncoding, typename InputStream>

     GenericDocument& ParseStream(InputStream& is) {

-        ValueType::SetNull(); // Remove existing root if exist

-        GenericReader<SourceEncoding, Encoding, Allocator> reader(&GetAllocator());

+        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

-            this->RawAssign(*stack_.template Pop<ValueType>(1));    // Add this-> to prevent issue 13.

+            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document

         }

         return *this;

     }

@@ -1660,7 +1900,7 @@ public:
     */

     template <unsigned parseFlags, typename InputStream>

     GenericDocument& ParseStream(InputStream& is) {

-        return ParseStream<parseFlags,Encoding,InputStream>(is);

+        return ParseStream<parseFlags, Encoding, InputStream>(is);

     }

 

     //! Parse JSON text from an input stream (with \ref kParseDefaultFlags)

@@ -1677,18 +1917,6 @@ public:
     //!@name Parse in-place from mutable string

     //!@{

 

-    //! Parse JSON text from a mutable string (with Encoding conversion)

-    /*! \tparam parseFlags Combination of \ref ParseFlag.

-        \tparam SourceEncoding Transcoding from input Encoding

-        \param str Mutable zero-terminated string to be parsed.

-        \return The document itself for fluent API.

-    */

-    template <unsigned parseFlags, typename SourceEncoding>

-    GenericDocument& ParseInsitu(Ch* str) {

-        GenericInsituStringStream<Encoding> s(str);

-        return ParseStream<parseFlags | kParseInsituFlag, SourceEncoding>(s);

-    }

-

     //! Parse JSON text from a mutable string

     /*! \tparam parseFlags Combination of \ref ParseFlag.

         \param str Mutable zero-terminated string to be parsed.

@@ -1696,7 +1924,8 @@ public:
     */

     template <unsigned parseFlags>

     GenericDocument& ParseInsitu(Ch* str) {

-        return ParseInsitu<parseFlags, Encoding>(str);

+        GenericInsituStringStream<Encoding> s(str);

+        return ParseStream<parseFlags | kParseInsituFlag>(s);

     }

 

     //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags)

@@ -1704,7 +1933,7 @@ public:
         \return The document itself for fluent API.

     */

     GenericDocument& ParseInsitu(Ch* str) {

-        return ParseInsitu<kParseDefaultFlags, Encoding>(str);

+        return ParseInsitu<kParseDefaultFlags>(str);

     }

     //!@}

 

@@ -1717,7 +1946,7 @@ public:
         \param str Read-only zero-terminated string to be parsed.

     */

     template <unsigned parseFlags, typename SourceEncoding>

-    GenericDocument& Parse(const Ch* str) {

+    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {

         RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));

         GenericStringStream<SourceEncoding> s(str);

         return ParseStream<parseFlags, SourceEncoding>(s);

@@ -1738,16 +1967,6 @@ public:
     GenericDocument& Parse(const Ch* str) {

         return Parse<kParseDefaultFlags>(str);

     }

-    

-    GenericDocument& Parse(const Ch * str, size_t sz) {

-      const char* buf = (const char*) str;

-      size_t    bufsz = sz * sizeof(Ch);

-      MemoryStream ms(buf, bufsz);

-      EncodedInputStream<Encoding, MemoryStream> is(ms);

-      ParseStream(is);

-      return *this;

-    }

-

     //!@}

 

     //!@name Handling parse errors

@@ -1762,10 +1981,26 @@ public:
     //! Get the position of last parsing error in input, 0 otherwise.

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

 

+    //! Implicit conversion to get the last parse result

+#ifndef __clang // -Wdocumentation

+    /*! \return \ref ParseResult of the last parse operation

+

+        \code

+          Document doc;

+          ParseResult ok = doc.Parse(json);

+          if (!ok)

+            printf( "JSON parse error: %s (%u)\n", GetParseError_En(ok.Code()), ok.Offset());

+        \endcode

+     */

+#endif

+    operator ParseResult() const { return parseResult_; }

     //!@}

 

     //! Get the allocator of this document.

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

+    Allocator& GetAllocator() {

+        RAPIDJSON_ASSERT(allocator_);

+        return *allocator_;

+    }

 

     //! Get the capacity of stack in bytes.

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

@@ -1808,7 +2043,7 @@ private:
 

     bool EndObject(SizeType memberCount) {

         typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);

-        stack_.template Top<ValueType>()->SetObjectRaw(members, (SizeType)memberCount, GetAllocator());

+        stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount, GetAllocator());

         return true;

     }

 

@@ -1821,6 +2056,8 @@ private:
     }

 

 private:

+    //! Prohibit copying

+    GenericDocument(const GenericDocument&);

     //! Prohibit assignment

     GenericDocument& operator=(const GenericDocument&);

 

@@ -1833,6 +2070,10 @@ private:
         stack_.ShrinkToFit();

     }

 

+    void Destroy() {

+        RAPIDJSON_DELETE(ownAllocator_);

+    }

+

     static const size_t kDefaultStackCapacity = 1024;

     Allocator* allocator_;

     Allocator* ownAllocator_;

@@ -1849,14 +2090,40 @@ template <typename SourceAllocator>
 inline

 GenericValue<Encoding,Allocator>::GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator)

 {

-    GenericDocument<Encoding,Allocator> d(&allocator);

-    rhs.Accept(d);

-    RawAssign(*d.stack_.template Pop<GenericValue>(1));

+    switch (rhs.GetType()) {

+    case kObjectType:

+    case kArrayType: { // perform deep copy via SAX Handler

+            GenericDocument<Encoding,Allocator> d(&allocator);

+            rhs.Accept(d);

+            RawAssign(*d.stack_.template Pop<GenericValue>(1));

+        }

+        break;

+    case kStringType:

+        if (rhs.flags_ == kConstStringFlag) {

+            flags_ = rhs.flags_;

+            data_  = *reinterpret_cast<const Data*>(&rhs.data_);

+        } else {

+            SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);

+        }

+        break;

+    default:

+        flags_ = rhs.flags_;

+        data_  = *reinterpret_cast<const Data*>(&rhs.data_);

+        break;

+    }

 }

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

+

+#ifdef _MSC_VER

+RAPIDJSON_DIAG_POP

+#endif

+

+#ifdef __clang__

+RAPIDJSON_DIAG_POP

+#endif

 

-#if defined(_MSC_VER) || defined(__GNUC__)

+#ifdef __GNUC__

 RAPIDJSON_DIAG_POP

 #endif

 

diff --git a/external/rapidjson/encodedstream.h b/external/rapidjson/encodedstream.h
index 9dc00c7af..e7cdf080d 100644
--- a/external/rapidjson/encodedstream.h
+++ b/external/rapidjson/encodedstream.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_ENCODEDSTREAM_H_

 #define RAPIDJSON_ENCODEDSTREAM_H_

@@ -28,7 +22,12 @@ RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(effc++)

 #endif

 

-namespace rapidjson {

+#ifdef __clang__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(padded)

+#endif

+

+RAPIDJSON_NAMESPACE_BEGIN

 

 //! Input byte stream wrapper with a statically bound encoding.

 /*!

@@ -66,7 +65,7 @@ private:
 //! Output byte stream wrapper with statically bound encoding.

 /*!

     \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.

-    \tparam InputByteStream Type of input byte stream. For example, FileWriteStream.

+    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.

 */

 template <typename Encoding, typename OutputByteStream>

 class EncodedOutputStream {

@@ -83,8 +82,8 @@ public:
     void Flush() { os_.Flush(); }

 

     // Not implemented

-    Ch Peek() const { RAPIDJSON_ASSERT(false); }

-    Ch Take() { RAPIDJSON_ASSERT(false);  }

+    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}

+    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}

     size_t Tell() const { RAPIDJSON_ASSERT(false);  return 0; }

     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }

     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }

@@ -115,6 +114,7 @@ public:
         \param type UTF encoding type if it is not detected from the stream.

     */

     AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {

+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        

         DetectType();

         static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };

         takeFunc_ = f[type_];

@@ -147,11 +147,11 @@ private:
         // FF FE        UTF-16LE

         // EF BB BF     UTF-8

 

-        const unsigned char* c = (const unsigned char *)is_->Peek4();

+        const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());

         if (!c)

             return;

 

-        unsigned bom = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);

+        unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));

         hasBOM_ = false;

         if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }

         else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }

@@ -183,21 +183,8 @@ private:
         }

 

         // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.

-        switch (type_) {

-        case kUTF8:

-            // Do nothing

-            break;

-        case kUTF16LE:

-        case kUTF16BE:

-            RAPIDJSON_ASSERT(sizeof(Ch) >= 2);

-            break;

-        case kUTF32LE:

-        case kUTF32BE:

-            RAPIDJSON_ASSERT(sizeof(Ch) >= 4);

-            break;

-        default:

-            RAPIDJSON_ASSERT(false);    // Invalid type

-        }

+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);

+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);

     }

 

     typedef Ch (*TakeFunc)(InputByteStream& is);

@@ -211,7 +198,7 @@ private:
 //! Output stream wrapper with dynamically bound encoding and automatic encoding detection.

 /*!

     \tparam CharType Type of character for writing.

-    \tparam InputByteStream type of output byte stream to be wrapped.

+    \tparam OutputByteStream type of output byte stream to be wrapped.

 */

 template <typename CharType, typename OutputByteStream>

 class AutoUTFOutputStream {

@@ -226,22 +213,11 @@ public:
         \param putBOM Whether to write BOM at the beginning of the stream.

     */

     AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {

-        // RUntime check whether the size of character type is sufficient. It only perform checks with assertion.

-        switch (type_) {

-        case kUTF16LE:

-        case kUTF16BE:

-            RAPIDJSON_ASSERT(sizeof(Ch) >= 2);

-            break;

-        case kUTF32LE:

-        case kUTF32BE:

-            RAPIDJSON_ASSERT(sizeof(Ch) >= 4);

-            break;

-        case kUTF8:

-            // Do nothing

-            break;

-        default:

-            RAPIDJSON_ASSERT(false);    // Invalid UTFType

-        }

+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);

+

+        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.

+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);

+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);

 

         static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };

         putFunc_ = f[type_];

@@ -256,8 +232,8 @@ public:
     void Flush() { os_->Flush(); } 

 

     // Not implemented

-    Ch Peek() const { RAPIDJSON_ASSERT(false); }

-    Ch Take() { RAPIDJSON_ASSERT(false); }

+    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}

+    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}

     size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }

     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }

     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }

@@ -281,7 +257,11 @@ private:
 

 #undef RAPIDJSON_ENCODINGS_FUNC

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

+

+#ifdef __clang__

+RAPIDJSON_DIAG_POP

+#endif

 

 #ifdef __GNUC__

 RAPIDJSON_DIAG_POP

diff --git a/external/rapidjson/encodings.h b/external/rapidjson/encodings.h
index 5c7da3e04..f37f9e1f7 100644
--- a/external/rapidjson/encodings.h
+++ b/external/rapidjson/encodings.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_ENCODINGS_H_

 #define RAPIDJSON_ENCODINGS_H_

@@ -30,9 +24,10 @@ RAPIDJSON_DIAG_OFF(4702)  // unreachable code
 #elif defined(__GNUC__)

 RAPIDJSON_DIAG_PUSH

 RAPIDJSON_DIAG_OFF(effc++)

+RAPIDJSON_DIAG_OFF(overflow)

 #endif

 

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 

 ///////////////////////////////////////////////////////////////////////////////

 // Encoding

@@ -127,17 +122,17 @@ struct UTF8 {
 

     template <typename InputStream>

     static bool Decode(InputStream& is, unsigned* codepoint) {

-#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | ((unsigned char)c & 0x3Fu)

-#define TRANS(mask) result &= ((GetRange((unsigned char)c) & mask) != 0)

+#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)

+#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)

 #define TAIL() COPY(); TRANS(0x70)

-        Ch c = is.Take();

+        typename InputStream::Ch c = is.Take();

         if (!(c & 0x80)) {

-            *codepoint = (unsigned char)c;

+            *codepoint = static_cast<unsigned char>(c);

             return true;

         }

 

-        unsigned char type = GetRange((unsigned char)c);

-        *codepoint = (0xFF >> type) & (unsigned char)c;

+        unsigned char type = GetRange(static_cast<unsigned char>(c));

+        *codepoint = (0xFF >> type) & static_cast<unsigned char>(c);

         bool result = true;

         switch (type) {

         case 2: TAIL(); return result;

@@ -157,7 +152,7 @@ struct UTF8 {
     template <typename InputStream, typename OutputStream>

     static bool Validate(InputStream& is, OutputStream& os) {

 #define COPY() os.Put(c = is.Take())

-#define TRANS(mask) result &= ((GetRange((unsigned char)c) & mask) != 0)

+#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)

 #define TAIL() COPY(); TRANS(0x70)

         Ch c;

         COPY();

@@ -165,7 +160,7 @@ struct UTF8 {
             return true;

 

         bool result = true;

-        switch (GetRange((unsigned char)c)) {

+        switch (GetRange(static_cast<unsigned char>(c))) {

         case 2: TAIL(); return result;

         case 3: TAIL(); TAIL(); return result;

         case 4: COPY(); TRANS(0x50); TAIL(); return result;

@@ -201,12 +196,12 @@ struct UTF8 {
     template <typename InputByteStream>

     static CharType TakeBOM(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        Ch c = Take(is);

-        if ((unsigned char)c != 0xEFu) return c;

+        typename InputByteStream::Ch c = Take(is);

+        if (static_cast<unsigned char>(c) != 0xEFu) return c;

         c = is.Take();

-        if ((unsigned char)c != 0xBBu) return c;

+        if (static_cast<unsigned char>(c) != 0xBBu) return c;

         c = is.Take();

-        if ((unsigned char)c != 0xBFu) return c;

+        if (static_cast<unsigned char>(c) != 0xBFu) return c;

         c = is.Take();

         return c;

     }

@@ -214,13 +209,15 @@ struct UTF8 {
     template <typename InputByteStream>

     static Ch Take(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        return is.Take();

+        return static_cast<Ch>(is.Take());

     }

 

     template <typename OutputByteStream>

     static void PutBOM(OutputByteStream& os) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(0xEFu); os.Put(0xBBu); os.Put(0xBFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));

     }

 

     template <typename OutputByteStream>

@@ -267,15 +264,15 @@ struct UTF16 {
     template <typename InputStream>

     static bool Decode(InputStream& is, unsigned* codepoint) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);

-        Ch c = is.Take();

+        typename InputStream::Ch c = is.Take();

         if (c < 0xD800 || c > 0xDFFF) {

-            *codepoint = c;

+            *codepoint = static_cast<unsigned>(c);

             return true;

         }

         else if (c <= 0xDBFF) {

-            *codepoint = (c & 0x3FF) << 10;

+            *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;

             c = is.Take();

-            *codepoint |= (c & 0x3FF);

+            *codepoint |= (static_cast<unsigned>(c) & 0x3FF);

             *codepoint += 0x10000;

             return c >= 0xDC00 && c <= 0xDFFF;

         }

@@ -286,8 +283,8 @@ struct UTF16 {
     static bool Validate(InputStream& is, OutputStream& os) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);

-        Ch c;

-        os.Put(c = is.Take());

+        typename InputStream::Ch c;

+        os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));

         if (c < 0xD800 || c > 0xDFFF)

             return true;

         else if (c <= 0xDBFF) {

@@ -305,28 +302,29 @@ struct UTF16LE : UTF16<CharType> {
     static CharType TakeBOM(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

         CharType c = Take(is);

-        return (unsigned short)c == 0xFEFFu ? Take(is) : c;

+        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;

     }

 

     template <typename InputByteStream>

     static CharType Take(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        CharType c = (unsigned char)is.Take();

-        c |= (unsigned char)is.Take() << 8;

-        return c;

+        unsigned c = static_cast<uint8_t>(is.Take());

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;

+        return static_cast<CharType>(c);

     }

 

     template <typename OutputByteStream>

     static void PutBOM(OutputByteStream& os) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(0xFFu); os.Put(0xFEu);

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));

     }

 

     template <typename OutputByteStream>

     static void Put(OutputByteStream& os, CharType c) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(c & 0xFFu);

-        os.Put((c >> 8) & 0xFFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));

     }

 };

 

@@ -337,28 +335,29 @@ struct UTF16BE : UTF16<CharType> {
     static CharType TakeBOM(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

         CharType c = Take(is);

-        return (unsigned short)c == 0xFEFFu ? Take(is) : c;

+        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;

     }

 

     template <typename InputByteStream>

     static CharType Take(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        CharType c = (unsigned char)is.Take() << 8;

-        c |= (unsigned char)is.Take();

-        return c;

+        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;

+        c |= static_cast<uint8_t>(is.Take());

+        return static_cast<CharType>(c);

     }

 

     template <typename OutputByteStream>

     static void PutBOM(OutputByteStream& os) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(0xFEu); os.Put(0xFFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));

     }

 

     template <typename OutputByteStream>

     static void Put(OutputByteStream& os, CharType c) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put((c >> 8) & 0xFFu);

-        os.Put(c & 0xFFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));

     }

 };

 

@@ -411,32 +410,35 @@ struct UTF32LE : UTF32<CharType> {
     static CharType TakeBOM(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

         CharType c = Take(is);

-        return (unsigned)c == 0x0000FEFFu ? Take(is) : c;

+        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;

     }

 

     template <typename InputByteStream>

     static CharType Take(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        CharType c = (unsigned char)is.Take();

-        c |= (unsigned char)is.Take() << 8;

-        c |= (unsigned char)is.Take() << 16;

-        c |= (unsigned char)is.Take() << 24;

-        return c;

+        unsigned c = static_cast<uint8_t>(is.Take());

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;

+        return static_cast<CharType>(c);

     }

 

     template <typename OutputByteStream>

     static void PutBOM(OutputByteStream& os) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(0xFFu); os.Put(0xFEu); os.Put(0x00u); os.Put(0x00u);

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));

     }

 

     template <typename OutputByteStream>

     static void Put(OutputByteStream& os, CharType c) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(c & 0xFFu);

-        os.Put((c >> 8) & 0xFFu);

-        os.Put((c >> 16) & 0xFFu);

-        os.Put((c >> 24) & 0xFFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));

     }

 };

 

@@ -447,32 +449,35 @@ struct UTF32BE : UTF32<CharType> {
     static CharType TakeBOM(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

         CharType c = Take(is);

-        return (unsigned)c == 0x0000FEFFu ? Take(is) : c; 

+        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c; 

     }

 

     template <typename InputByteStream>

     static CharType Take(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        CharType c = (unsigned char)is.Take() << 24;

-        c |= (unsigned char)is.Take() << 16;

-        c |= (unsigned char)is.Take() << 8;

-        c |= (unsigned char)is.Take();

-        return c;

+        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;

+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));

+        return static_cast<CharType>(c);

     }

 

     template <typename OutputByteStream>

     static void PutBOM(OutputByteStream& os) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put(0x00u); os.Put(0x00u); os.Put(0xFEu); os.Put(0xFFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));

     }

 

     template <typename OutputByteStream>

     static void Put(OutputByteStream& os, CharType c) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);

-        os.Put((c >> 24) & 0xFFu);

-        os.Put((c >> 16) & 0xFFu);

-        os.Put((c >> 8) & 0xFFu);

-        os.Put(c & 0xFFu);

+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));

+        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));

     }

 };

 

@@ -498,29 +503,29 @@ struct ASCII {
 

     template <typename InputStream>

     static bool Decode(InputStream& is, unsigned* codepoint) {

-        unsigned char c = static_cast<unsigned char>(is.Take());

+        uint8_t c = static_cast<uint8_t>(is.Take());

         *codepoint = c;

         return c <= 0X7F;

     }

 

     template <typename InputStream, typename OutputStream>

     static bool Validate(InputStream& is, OutputStream& os) {

-        unsigned char c = is.Take();

-        os.Put(c);

+        uint8_t c = static_cast<uint8_t>(is.Take());

+        os.Put(static_cast<typename OutputStream::Ch>(c));

         return c <= 0x7F;

     }

 

     template <typename InputByteStream>

     static CharType TakeBOM(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        Ch c = Take(is);

-        return c;

+        uint8_t c = static_cast<uint8_t>(Take(is));

+        return static_cast<Ch>(c);

     }

 

     template <typename InputByteStream>

     static Ch Take(InputByteStream& is) {

         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);

-        return is.Take();

+        return static_cast<Ch>(is.Take());

     }

 

     template <typename OutputByteStream>

@@ -621,9 +626,9 @@ struct Transcoder<Encoding, Encoding> {
     }

 };

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

-#if defined(__GNUC__) || defined(_MSV_VER)

+#if defined(__GNUC__) || defined(_MSC_VER)

 RAPIDJSON_DIAG_POP

 #endif

 

diff --git a/external/rapidjson/error/en.h b/external/rapidjson/error/en.h
index d153e04fc..c2315fda7 100644
--- a/external/rapidjson/error/en.h
+++ b/external/rapidjson/error/en.h
@@ -1,29 +1,29 @@
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// 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
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// 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_ERROR_EN_H__
-#define RAPIDJSON_ERROR_EN_H__
+#ifndef RAPIDJSON_ERROR_EN_H_
+#define RAPIDJSON_ERROR_EN_H_
 
 #include "error.h"
 
-namespace rapidjson {
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(switch-enum)
+RAPIDJSON_DIAG_OFF(covered-switch-default)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
 
 //! Maps error code of parsing into error message.
 /*!
@@ -61,11 +61,14 @@ inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErro
         case kParseErrorTermination:                    return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
         case kParseErrorUnspecificSyntaxError:          return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
 
-        default:
-            return RAPIDJSON_ERROR_STRING("Unknown error.");
+        default:                                        return RAPIDJSON_ERROR_STRING("Unknown error.");
     }
 }
 
-} // namespace rapidjson
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
 
-#endif // RAPIDJSON_ERROR_EN_H__
+#endif // RAPIDJSON_ERROR_EN_H_
diff --git a/external/rapidjson/error/error.h b/external/rapidjson/error/error.h
index 146604439..95cb31a72 100644
--- a/external/rapidjson/error/error.h
+++ b/external/rapidjson/error/error.h
@@ -1,25 +1,26 @@
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// 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
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// 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_ERROR_ERROR_H__
-#define RAPIDJSON_ERROR_ERROR_H__
+#ifndef RAPIDJSON_ERROR_ERROR_H_
+#define RAPIDJSON_ERROR_ERROR_H_
+
+#include "../rapidjson.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
 
 /*! \file error.h */
 
@@ -51,7 +52,7 @@
 #define RAPIDJSON_ERROR_STRING(x) x
 #endif
 
-namespace rapidjson {
+RAPIDJSON_NAMESPACE_BEGIN
 
 ///////////////////////////////////////////////////////////////////////////////
 // ParseErrorCode
@@ -85,7 +86,7 @@ enum ParseErrorCode {
     kParseErrorNumberMissExponent,              //!< Miss exponent in number.
 
     kParseErrorTermination,                     //!< Parsing was terminated.
-    kParseErrorUnspecificSyntaxError,           //!< Unspecific syntax error.
+    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
 };
 
 //! Result of parsing (wraps ParseErrorCode)
@@ -103,7 +104,7 @@ enum ParseErrorCode {
     \see GenericReader::Parse, GenericDocument::Parse
 */
 struct ParseResult {
-
+public:
     //! Default constructor, no error.
     ParseResult() : code_(kParseErrorNone), offset_(0) {}
     //! Constructor to set an error.
@@ -145,6 +146,10 @@ private:
 */
 typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
 
-} // namespace rapidjson
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
 
-#endif // RAPIDJSON_ERROR_ERROR_H__
+#endif // RAPIDJSON_ERROR_ERROR_H_
diff --git a/external/rapidjson/filereadstream.h b/external/rapidjson/filereadstream.h
index 31c193bf9..6c8a86c8e 100644
--- a/external/rapidjson/filereadstream.h
+++ b/external/rapidjson/filereadstream.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_FILEREADSTREAM_H_

 #define RAPIDJSON_FILEREADSTREAM_H_

@@ -24,7 +18,14 @@
 #include "rapidjson.h"

 #include <cstdio>

 

-namespace rapidjson {

+#ifdef __clang__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(padded)

+RAPIDJSON_DIAG_OFF(unreachable-code)

+RAPIDJSON_DIAG_OFF(missing-noreturn)

+#endif

+

+RAPIDJSON_NAMESPACE_BEGIN

 

 //! File byte stream for input using fread().

 /*!

@@ -40,7 +41,7 @@ public:
         \param buffer user-supplied buffer.

         \param bufferSize size of buffer in bytes. Must >=4 bytes.

     */

-    FileReadStream(FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 

+    FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 

         RAPIDJSON_ASSERT(fp_ != 0);

         RAPIDJSON_ASSERT(bufferSize >= 4);

         Read();

@@ -79,7 +80,7 @@ private:
         }

     }

 

-    FILE* fp_;

+    std::FILE* fp_;

     Ch *buffer_;

     size_t bufferSize_;

     Ch *bufferLast_;

@@ -89,6 +90,10 @@ private:
     bool eof_;

 };

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

+

+#ifdef __clang__

+RAPIDJSON_DIAG_POP

+#endif

 

 #endif // RAPIDJSON_FILESTREAM_H_

diff --git a/external/rapidjson/filestream.h b/external/rapidjson/filestream.h
deleted file mode 100644
index 6995b3d3f..000000000
--- a/external/rapidjson/filestream.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (C) 2011 Milo Yip

-//

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

-//

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

-//

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

-

-#ifndef RAPIDJSON_FILESTREAM_H_

-#define RAPIDJSON_FILESTREAM_H_

-

-#include "rapidjson.h"

-#include <cstdio>

-

-namespace rapidjson {

-

-//! (Depreciated) Wrapper of C file stream for input or output.

-/*!

-    This simple wrapper does not check the validity of the stream.

-    \note implements Stream concept

-    \note deprecated: This was only for basic testing in version 0.1, it is found that the performance is very low by using fgetc(). Use FileReadStream instead.

-*/

-class FileStream {

-public:

-    typedef char Ch;    //!< Character type. Only support char.

-

-    FileStream(FILE* fp) : fp_(fp), current_('\0'), count_(0) { Read(); }

-    char Peek() const { return current_; }

-    char Take() { char c = current_; Read(); return c; }

-    size_t Tell() const { return count_; }

-    void Put(char c) { fputc(c, fp_); }

-    void Flush() { fflush(fp_); }

-

-    // Not implemented

-    char* PutBegin() { return 0; }

-    size_t PutEnd(char*) { return 0; }

-

-private:

-    // Prohibit copy constructor & assignment operator.

-    FileStream(const FileStream&);

-    FileStream& operator=(const FileStream&);

-

-    void Read() {

-        RAPIDJSON_ASSERT(fp_ != 0);

-        int c = fgetc(fp_);

-        if (c != EOF) {

-            current_ = (char)c;

-            count_++;

-        }

-        else if (current_ != '\0')

-            current_ = '\0';

-    }

-

-    FILE* fp_;

-    char current_;

-    size_t count_;

-};

-

-} // namespace rapidjson

-

-#endif // RAPIDJSON_FILESTREAM_H_

diff --git a/external/rapidjson/filewritestream.h b/external/rapidjson/filewritestream.h
index 05c5ca090..3c3832920 100644
--- a/external/rapidjson/filewritestream.h
+++ b/external/rapidjson/filewritestream.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_FILEWRITESTREAM_H_

 #define RAPIDJSON_FILEWRITESTREAM_H_

@@ -24,7 +18,12 @@
 #include "rapidjson.h"

 #include <cstdio>

 

-namespace rapidjson {

+#ifdef __clang__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(unreachable-code)

+#endif

+

+RAPIDJSON_NAMESPACE_BEGIN

 

 //! Wrapper of C file stream for input using fread().

 /*!

@@ -34,7 +33,7 @@ class FileWriteStream {
 public:

     typedef char Ch;    //!< Character type. Only support char.

 

-    FileWriteStream(FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 

+    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 

         RAPIDJSON_ASSERT(fp_ != 0);

     }

 

@@ -63,7 +62,11 @@ public:
 

     void Flush() {

         if (current_ != buffer_) {

-            fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);

+            size_t result = fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);

+            if (result < static_cast<size_t>(current_ - buffer_)) {

+                // failure deliberately ignored at this time

+                // added to avoid warn_unused_result build errors

+            }

             current_ = buffer_;

         }

     }

@@ -80,7 +83,7 @@ private:
     FileWriteStream(const FileWriteStream&);

     FileWriteStream& operator=(const FileWriteStream&);

 

-    FILE* fp_;

+    std::FILE* fp_;

     char *buffer_;

     char *bufferEnd_;

     char *current_;

@@ -92,6 +95,10 @@ inline void PutN(FileWriteStream& stream, char c, size_t n) {
     stream.PutN(c, n);

 }

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

+

+#ifdef __clang__

+RAPIDJSON_DIAG_POP

+#endif

 

 #endif // RAPIDJSON_FILESTREAM_H_

diff --git a/external/rapidjson/internal/biginteger.h b/external/rapidjson/internal/biginteger.h
new file mode 100755
index 000000000..9d3e88c99
--- /dev/null
+++ b/external/rapidjson/internal/biginteger.h
@@ -0,0 +1,290 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_BIGINTEGER_H_
+#define RAPIDJSON_BIGINTEGER_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
+#include <intrin.h> // for _umul128
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+class BigInteger {
+public:
+    typedef uint64_t Type;
+
+    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
+        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+    }
+
+    explicit BigInteger(uint64_t u) : count_(1) {
+        digits_[0] = u;
+    }
+
+    BigInteger(const char* decimals, size_t length) : count_(1) {
+        RAPIDJSON_ASSERT(length > 0);
+        digits_[0] = 0;
+        size_t i = 0;
+        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
+        while (length >= kMaxDigitPerIteration) {
+            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
+            length -= kMaxDigitPerIteration;
+            i += kMaxDigitPerIteration;
+        }
+
+        if (length > 0)
+            AppendDecimal64(decimals + i, decimals + i + length);
+    }
+    
+    BigInteger& operator=(const BigInteger &rhs)
+    {
+        if (this != &rhs) {
+            count_ = rhs.count_;
+            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+        }
+        return *this;
+    }
+    
+    BigInteger& operator=(uint64_t u) {
+        digits_[0] = u;            
+        count_ = 1;
+        return *this;
+    }
+
+    BigInteger& operator+=(uint64_t u) {
+        Type backup = digits_[0];
+        digits_[0] += u;
+        for (size_t i = 0; i < count_ - 1; i++) {
+            if (digits_[i] >= backup)
+                return *this; // no carry
+            backup = digits_[i + 1];
+            digits_[i + 1] += 1;
+        }
+
+        // Last carry
+        if (digits_[count_ - 1] < backup)
+            PushBack(1);
+
+        return *this;
+    }
+
+    BigInteger& operator*=(uint64_t u) {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++) {
+            uint64_t hi;
+            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
+            k = hi;
+        }
+        
+        if (k > 0)
+            PushBack(k);
+
+        return *this;
+    }
+
+    BigInteger& operator*=(uint32_t u) {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++) {
+            const uint64_t c = digits_[i] >> 32;
+            const uint64_t d = digits_[i] & 0xFFFFFFFF;
+            const uint64_t uc = u * c;
+            const uint64_t ud = u * d;
+            const uint64_t p0 = ud + k;
+            const uint64_t p1 = uc + (p0 >> 32);
+            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
+            k = p1 >> 32;
+        }
+        
+        if (k > 0)
+            PushBack(k);
+
+        return *this;
+    }
+
+    BigInteger& operator<<=(size_t shift) {
+        if (IsZero() || shift == 0) return *this;
+
+        size_t offset = shift / kTypeBit;
+        size_t interShift = shift % kTypeBit;
+        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
+
+        if (interShift == 0) {
+            std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
+            count_ += offset;
+        }
+        else {
+            digits_[count_] = 0;
+            for (size_t i = count_; i > 0; i--)
+                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
+            digits_[offset] = digits_[0] << interShift;
+            count_ += offset;
+            if (digits_[count_])
+                count_++;
+        }
+
+        std::memset(digits_, 0, offset * sizeof(Type));
+
+        return *this;
+    }
+
+    bool operator==(const BigInteger& rhs) const {
+        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
+    }
+
+    bool operator==(const Type rhs) const {
+        return count_ == 1 && digits_[0] == rhs;
+    }
+
+    BigInteger& MultiplyPow5(unsigned exp) {
+        static const uint32_t kPow5[12] = {
+            5,
+            5 * 5,
+            5 * 5 * 5,
+            5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
+        };
+        if (exp == 0) return *this;
+        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
+        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
+        if (exp > 0)                 *this *= kPow5[exp - 1];
+        return *this;
+    }
+
+    // Compute absolute difference of this and rhs.
+    // Assume this != rhs
+    bool Difference(const BigInteger& rhs, BigInteger* out) const {
+        int cmp = Compare(rhs);
+        RAPIDJSON_ASSERT(cmp != 0);
+        const BigInteger *a, *b;  // Makes a > b
+        bool ret;
+        if (cmp < 0) { a = &rhs; b = this; ret = true; }
+        else         { a = this; b = &rhs; ret = false; }
+
+        Type borrow = 0;
+        for (size_t i = 0; i < a->count_; i++) {
+            Type d = a->digits_[i] - borrow;
+            if (i < b->count_)
+                d -= b->digits_[i];
+            borrow = (d > a->digits_[i]) ? 1 : 0;
+            out->digits_[i] = d;
+            if (d != 0)
+                out->count_ = i + 1;
+        }
+
+        return ret;
+    }
+
+    int Compare(const BigInteger& rhs) const {
+        if (count_ != rhs.count_)
+            return count_ < rhs.count_ ? -1 : 1;
+
+        for (size_t i = count_; i-- > 0;)
+            if (digits_[i] != rhs.digits_[i])
+                return digits_[i] < rhs.digits_[i] ? -1 : 1;
+
+        return 0;
+    }
+
+    size_t GetCount() const { return count_; }
+    Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; }
+    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }
+
+private:
+    void AppendDecimal64(const char* begin, const char* end) {
+        uint64_t u = ParseUint64(begin, end);
+        if (IsZero())
+            *this = u;
+        else {
+            unsigned exp = static_cast<unsigned>(end - begin);
+            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
+        }
+    }
+
+    void PushBack(Type digit) {
+        RAPIDJSON_ASSERT(count_ < kCapacity);
+        digits_[count_++] = digit;
+    }
+
+    static uint64_t ParseUint64(const char* begin, const char* end) {
+        uint64_t r = 0;
+        for (const char* p = begin; p != end; ++p) {
+            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
+            r = r * 10u + static_cast<unsigned>(*p - '0');
+        }
+        return r;
+    }
+
+    // Assume a * b + k < 2^128
+    static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t low = _umul128(a, b, outHigh) + k;
+        if (low < k)
+            (*outHigh)++;
+        return low;
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
+        p += k;
+        *outHigh = static_cast<uint64_t>(p >> 64);
+        return static_cast<uint64_t>(p);
+#else
+        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
+        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
+        x1 += (x0 >> 32); // can't give carry
+        x1 += x2;
+        if (x1 < x2)
+            x3 += (static_cast<uint64_t>(1) << 32);
+        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
+        uint64_t hi = x3 + (x1 >> 32);
+
+        lo += k;
+        if (lo < k)
+            hi++;
+        *outHigh = hi;
+        return lo;
+#endif
+    }
+
+    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
+    static const size_t kCapacity = kBitCount / sizeof(Type);
+    static const size_t kTypeBit = sizeof(Type) * 8;
+
+    Type digits_[kCapacity];
+    size_t count_;
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_BIGINTEGER_H_
diff --git a/external/rapidjson/internal/diyfp.h b/external/rapidjson/internal/diyfp.h
new file mode 100644
index 000000000..9a62c2cc7
--- /dev/null
+++ b/external/rapidjson/internal/diyfp.h
@@ -0,0 +1,258 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DIYFP_H_
+#define RAPIDJSON_DIYFP_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
+#include <intrin.h>
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+struct DiyFp {
+    DiyFp() {}
+
+    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
+
+    explicit DiyFp(double d) {
+        union {
+            double d;
+            uint64_t u64;
+        } u = { d };
+
+        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
+        uint64_t significand = (u.u64 & kDpSignificandMask);
+        if (biased_e != 0) {
+            f = significand + kDpHiddenBit;
+            e = biased_e - kDpExponentBias;
+        } 
+        else {
+            f = significand;
+            e = kDpMinExponent + 1;
+        }
+    }
+
+    DiyFp operator-(const DiyFp& rhs) const {
+        return DiyFp(f - rhs.f, e);
+    }
+
+    DiyFp operator*(const DiyFp& rhs) const {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t h;
+        uint64_t l = _umul128(f, rhs.f, &h);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
+        uint64_t h = static_cast<uint64_t>(p >> 64);
+        uint64_t l = static_cast<uint64_t>(p);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#else
+        const uint64_t M32 = 0xFFFFFFFF;
+        const uint64_t a = f >> 32;
+        const uint64_t b = f & M32;
+        const uint64_t c = rhs.f >> 32;
+        const uint64_t d = rhs.f & M32;
+        const uint64_t ac = a * c;
+        const uint64_t bc = b * c;
+        const uint64_t ad = a * d;
+        const uint64_t bd = b * d;
+        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
+        tmp += 1U << 31;  /// mult_round
+        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
+#endif
+    }
+
+    DiyFp Normalize() const {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        unsigned long index;
+        _BitScanReverse64(&index, f);
+        return DiyFp(f << (63 - index), e - (63 - index));
+#elif defined(__GNUC__) && __GNUC__ >= 4
+        int s = __builtin_clzll(f);
+        return DiyFp(f << s, e - s);
+#else
+        DiyFp res = *this;
+        while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
+            res.f <<= 1;
+            res.e--;
+        }
+        return res;
+#endif
+    }
+
+    DiyFp NormalizeBoundary() const {
+        DiyFp res = *this;
+        while (!(res.f & (kDpHiddenBit << 1))) {
+            res.f <<= 1;
+            res.e--;
+        }
+        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
+        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
+        return res;
+    }
+
+    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
+        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
+        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
+        mi.f <<= mi.e - pl.e;
+        mi.e = pl.e;
+        *plus = pl;
+        *minus = mi;
+    }
+
+    double ToDouble() const {
+        union {
+            double d;
+            uint64_t u64;
+        }u;
+        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : 
+            static_cast<uint64_t>(e + kDpExponentBias);
+        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
+        return u.d;
+    }
+
+    static const int kDiySignificandSize = 64;
+    static const int kDpSignificandSize = 52;
+    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
+    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
+    static const int kDpMinExponent = -kDpExponentBias;
+    static const int kDpDenormalExponent = -kDpExponentBias + 1;
+    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    uint64_t f;
+    int e;
+};
+
+inline DiyFp GetCachedPowerByIndex(size_t index) {
+    // 10^-348, 10^-340, ..., 10^340
+    static const uint64_t kCachedPowers_F[] = {
+        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
+        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
+        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
+        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
+        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
+        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
+        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
+        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
+        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
+        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
+        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
+        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
+        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
+        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
+        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
+        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
+        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
+        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
+        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
+        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
+        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
+        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
+        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
+        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
+        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
+        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
+        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
+        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
+        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
+        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
+        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
+        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
+        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
+        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
+        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
+        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
+        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
+        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
+        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
+        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
+        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
+        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
+        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
+        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
+    };
+    static const int16_t kCachedPowers_E[] = {
+        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
+        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
+        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
+        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
+        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
+        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
+        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
+        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
+        907,   933,   960,   986,  1013,  1039,  1066
+    };
+    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
+}
+    
+inline DiyFp GetCachedPower(int e, int* K) {
+
+    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
+    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
+    int k = static_cast<int>(dk);
+    if (dk - k > 0.0)
+        k++;
+
+    unsigned index = static_cast<unsigned>((k >> 3) + 1);
+    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
+
+    return GetCachedPowerByIndex(index);
+}
+
+inline DiyFp GetCachedPower10(int exp, int *outExp) {
+     unsigned index = (static_cast<unsigned>(exp) + 348u) / 8u;
+     *outExp = -348 + static_cast<int>(index) * 8;
+     return GetCachedPowerByIndex(index);
+ }
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DIYFP_H_
diff --git a/external/rapidjson/internal/dtoa.h b/external/rapidjson/internal/dtoa.h
index 6ae588ac4..d04ae21cc 100644
--- a/external/rapidjson/internal/dtoa.h
+++ b/external/rapidjson/internal/dtoa.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// 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
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// 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.
 
 // This is a C++ header-only implementation of Grisu2 algorithm from the publication:
 // Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
@@ -25,16 +19,11 @@
 #ifndef RAPIDJSON_DTOA_
 #define RAPIDJSON_DTOA_
 
-#if defined(_MSC_VER)
-#include <intrin.h>
-#if defined(_M_AMD64)
-#pragma intrinsic(_BitScanReverse64)
-#endif
-#endif
-
 #include "itoa.h" // GetDigitsLut()
+#include "diyfp.h"
+#include "ieee754.h"
 
-namespace rapidjson {
+RAPIDJSON_NAMESPACE_BEGIN
 namespace internal {
 
 #ifdef __GNUC__
@@ -42,193 +31,6 @@ RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(effc++)
 #endif
 
-struct DiyFp {
-    DiyFp() {}
-
-    DiyFp(uint64_t f, int e) : f(f), e(e) {}
-
-    DiyFp(double d) {
-        union {
-            double d;
-            uint64_t u64;
-        } u = { d };
-
-        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
-        uint64_t significand = (u.u64 & kDpSignificandMask);
-        if (biased_e != 0) {
-            f = significand + kDpHiddenBit;
-            e = biased_e - kDpExponentBias;
-        } 
-        else {
-            f = significand;
-            e = kDpMinExponent + 1;
-        }
-    }
-
-    DiyFp operator-(const DiyFp& rhs) const {
-        return DiyFp(f - rhs.f, e);
-    }
-
-    DiyFp operator*(const DiyFp& rhs) const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t h;
-        uint64_t l = _umul128(f, rhs.f, &h);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        unsigned __int128 p = static_cast<unsigned __int128>(f) * static_cast<unsigned __int128>(rhs.f);
-        uint64_t h = static_cast<uint64_t>(p >> 64);
-        uint64_t l = static_cast<uint64_t>(p);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#else
-        const uint64_t M32 = 0xFFFFFFFF;
-        const uint64_t a = f >> 32;
-        const uint64_t b = f & M32;
-        const uint64_t c = rhs.f >> 32;
-        const uint64_t d = rhs.f & M32;
-        const uint64_t ac = a * c;
-        const uint64_t bc = b * c;
-        const uint64_t ad = a * d;
-        const uint64_t bd = b * d;
-        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
-        tmp += 1U << 31;  /// mult_round
-        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
-#endif
-    }
-
-    DiyFp Normalize() const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        unsigned long index;
-        _BitScanReverse64(&index, f);
-        return DiyFp(f << (63 - index), e - (63 - index));
-#elif defined(__GNUC__)
-        int s = __builtin_clzll(f);
-        return DiyFp(f << s, e - s);
-#else
-        DiyFp res = *this;
-        while (!(res.f & kDpHiddenBit)) {
-            res.f <<= 1;
-            res.e--;
-        }
-        res.f <<= (kDiySignificandSize - kDpSignificandSize - 1);
-        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 1);
-        return res;
-#endif
-    }
-
-    DiyFp NormalizeBoundary() const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        unsigned long index;
-        _BitScanReverse64(&index, f);
-        return DiyFp (f << (63 - index), e - (63 - index));
-#else
-        DiyFp res = *this;
-        while (!(res.f & (kDpHiddenBit << 1))) {
-            res.f <<= 1;
-            res.e--;
-        }
-        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
-        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
-        return res;
-#endif
-    }
-
-    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
-        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
-        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
-        mi.f <<= mi.e - pl.e;
-        mi.e = pl.e;
-        *plus = pl;
-        *minus = mi;
-    }
-
-    static const int kDiySignificandSize = 64;
-    static const int kDpSignificandSize = 52;
-    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
-    static const int kDpMinExponent = -kDpExponentBias;
-    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    uint64_t f;
-    int e;
-};
-
-inline DiyFp GetCachedPower(int e, int* K) {
-    // 10^-348, 10^-340, ..., 10^340
-    static const uint64_t kCachedPowers_F[] = {
-        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
-        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
-        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
-        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
-        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
-        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
-        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
-        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
-        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
-        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
-        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
-        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
-        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
-        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
-        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
-        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
-        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
-        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
-        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
-        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
-        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
-        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
-        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
-        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
-        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
-        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
-        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
-        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
-        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
-        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
-        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
-        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
-        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
-        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
-        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
-        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
-        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
-        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
-        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
-        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
-        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
-        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
-        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
-        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
-    };
-    static const int16_t kCachedPowers_E[] = {
-        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
-         -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
-         -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
-         -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
-         -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
-          109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
-          375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
-          641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
-          907,   933,   960,   986,  1013,  1039,  1066
-    };
-
-    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
-    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
-    int k = static_cast<int>(dk);
-    if (k != dk)
-        k++;
-
-    unsigned index = static_cast<unsigned>((k >> 3) + 1);
-    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
-
-    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
-}
-
 inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
     while (rest < wp_w && delta - rest >= ten_kappa &&
            (rest + ten_kappa < wp_w ||  /// closer
@@ -248,8 +50,10 @@ inline unsigned CountDecimalDigit32(uint32_t n) {
     if (n < 1000000) return 6;
     if (n < 10000000) return 7;
     if (n < 100000000) return 8;
-    if (n < 1000000000) return 9;
-    return 10;
+    // Will not reach 10 digits in DigitGen()
+    //if (n < 1000000000) return 9;
+    //return 10;
+    return 9;
 }
 
 inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
@@ -258,13 +62,12 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
     const DiyFp wp_w = Mp - W;
     uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
     uint64_t p2 = Mp.f & (one.f - 1);
-    int kappa = CountDecimalDigit32(p1);
+    unsigned kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
     *len = 0;
 
     while (kappa > 0) {
-        uint32_t d;
+        uint32_t d = 0;
         switch (kappa) {
-            case 10: d = p1 / 1000000000; p1 %= 1000000000; break;
             case  9: d = p1 /  100000000; p1 %=  100000000; break;
             case  8: d = p1 /   10000000; p1 %=   10000000; break;
             case  7: d = p1 /    1000000; p1 %=    1000000; break;
@@ -274,14 +77,7 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
             case  3: d = p1 /        100; p1 %=        100; break;
             case  2: d = p1 /         10; p1 %=         10; break;
             case  1: d = p1;              p1 =           0; break;
-            default: 
-#if defined(_MSC_VER)
-                __assume(0);
-#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-                __builtin_unreachable();
-#else
-                d = 0;
-#endif
+            default:;
         }
         if (d || *len)
             buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
@@ -305,7 +101,7 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
         kappa--;
         if (p2 < delta) {
             *K += kappa;
-            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-kappa]);
+            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-static_cast<int>(kappa)]);
             return;
         }
     }
@@ -362,14 +158,14 @@ inline char* Prettify(char* buffer, int length, int k) {
     }
     else if (0 < kk && kk <= 21) {
         // 1234e-2 -> 12.34
-        std::memmove(&buffer[kk + 1], &buffer[kk], length - kk);
+        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
         buffer[kk] = '.';
         return &buffer[length + 1];
     }
     else if (-6 < kk && kk <= 0) {
         // 1234e-6 -> 0.001234
         const int offset = 2 - kk;
-        std::memmove(&buffer[offset], &buffer[0], length);
+        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
         buffer[0] = '0';
         buffer[1] = '.';
         for (int i = 2; i < offset; i++)
@@ -383,7 +179,7 @@ inline char* Prettify(char* buffer, int length, int k) {
     }
     else {
         // 1234e30 -> 1.234e33
-        std::memmove(&buffer[2], &buffer[1], length - 1);
+        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
         buffer[1] = '.';
         buffer[length + 1] = 'e';
         return WriteExponent(kk - 1, &buffer[0 + length + 2]);
@@ -391,7 +187,10 @@ inline char* Prettify(char* buffer, int length, int k) {
 }
 
 inline char* dtoa(double value, char* buffer) {
-    if (value == 0) {
+    Double d(value);
+    if (d.IsZero()) {
+        if (d.Sign())
+            *buffer++ = '-';     // -0.0, Issue #289
         buffer[0] = '0';
         buffer[1] = '.';
         buffer[2] = '0';
@@ -413,6 +212,6 @@ RAPIDJSON_DIAG_POP
 #endif
 
 } // namespace internal
-} // namespace rapidjson
+RAPIDJSON_NAMESPACE_END
 
 #endif // RAPIDJSON_DTOA_
diff --git a/external/rapidjson/internal/ieee754.h b/external/rapidjson/internal/ieee754.h
new file mode 100644
index 000000000..6890f89e8
--- /dev/null
+++ b/external/rapidjson/internal/ieee754.h
@@ -0,0 +1,77 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_IEEE754_
+#define RAPIDJSON_IEEE754_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+class Double {
+public:
+    Double() {}
+    Double(double d) : d_(d) {}
+    Double(uint64_t u) : u_(u) {}
+
+    double Value() const { return d_; }
+    uint64_t Uint64Value() const { return u_; }
+
+    double NextPositiveDouble() const {
+        RAPIDJSON_ASSERT(!Sign());
+        return Double(u_ + 1).Value();
+    }
+
+    bool Sign() const { return (u_ & kSignMask) != 0; }
+    uint64_t Significand() const { return u_ & kSignificandMask; }
+    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
+
+    bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
+    bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
+    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
+    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
+
+    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
+    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
+    uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
+
+    static unsigned EffectiveSignificandSize(int order) {
+        if (order >= -1021)
+            return 53;
+        else if (order <= -1074)
+            return 0;
+        else
+            return static_cast<unsigned>(order) + 1074;
+    }
+
+private:
+    static const int kSignificandSize = 52;
+    static const int kExponentBias = 0x3FF;
+    static const int kDenormalExponent = 1 - kExponentBias;
+    static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
+    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    union {
+        double d_;
+        uint64_t u_;
+    };
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_IEEE754_
diff --git a/external/rapidjson/internal/itoa.h b/external/rapidjson/internal/itoa.h
index 425e9830c..01a4e7e72 100644
--- a/external/rapidjson/internal/itoa.h
+++ b/external/rapidjson/internal/itoa.h
@@ -1,27 +1,23 @@
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// 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
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// 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_ITOA_
 #define RAPIDJSON_ITOA_
 
-namespace rapidjson {
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
 namespace internal {
 
 inline const char* GetDigitsLut() {
@@ -115,12 +111,13 @@ inline char* u32toa(uint32_t value, char* buffer) {
 }
 
 inline char* i32toa(int32_t value, char* buffer) {
+    uint32_t u = static_cast<uint32_t>(value);
     if (value < 0) {
         *buffer++ = '-';
-        value = -value;
+        u = ~u + 1;
     }
 
-    return u32toa(static_cast<uint32_t>(value), buffer);
+    return u32toa(u, buffer);
 }
 
 inline char* u64toa(uint64_t value, char* buffer) {
@@ -292,15 +289,16 @@ inline char* u64toa(uint64_t value, char* buffer) {
 }
 
 inline char* i64toa(int64_t value, char* buffer) {
+    uint64_t u = static_cast<uint64_t>(value);
     if (value < 0) {
         *buffer++ = '-';
-        value = -value;
+        u = ~u + 1;
     }
 
-    return u64toa(static_cast<uint64_t>(value), buffer);
+    return u64toa(u, buffer);
 }
 
 } // namespace internal
-} // namespace rapidjson
+RAPIDJSON_NAMESPACE_END
 
 #endif // RAPIDJSON_ITOA_
diff --git a/external/rapidjson/internal/meta.h b/external/rapidjson/internal/meta.h
index dbe5450d6..2daad964e 100644
--- a/external/rapidjson/internal/meta.h
+++ b/external/rapidjson/internal/meta.h
@@ -1,29 +1,21 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_INTERNAL_META_H_

 #define RAPIDJSON_INTERNAL_META_H_

 

-#ifndef RAPIDJSON_RAPIDJSON_H_

-#error <rapidjson.h> not yet included. Do not include this file directly.

-#endif

+#include "../rapidjson.h"

 

 #ifdef __GNUC__

 RAPIDJSON_DIAG_PUSH

@@ -39,7 +31,7 @@ RAPIDJSON_DIAG_OFF(6334)
 #endif

 

 //@cond RAPIDJSON_INTERNAL

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 namespace internal {

 

 // Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching

@@ -157,29 +149,29 @@ template <typename T> struct RemoveSfinaeTag;
 template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };

 

 #define RAPIDJSON_REMOVEFPTR_(type) \

-    typename ::rapidjson::internal::RemoveSfinaeTag \

-        < ::rapidjson::internal::SfinaeTag&(*) type>::Type

+    typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \

+        < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type

 

 #define RAPIDJSON_ENABLEIF(cond) \

-    typename ::rapidjson::internal::EnableIf \

+    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \

         <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL

 

 #define RAPIDJSON_DISABLEIF(cond) \

-    typename ::rapidjson::internal::DisableIf \

+    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \

         <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL

 

 #define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \

-    typename ::rapidjson::internal::EnableIf \

+    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \

         <RAPIDJSON_REMOVEFPTR_(cond), \

          RAPIDJSON_REMOVEFPTR_(returntype)>::Type

 

 #define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \

-    typename ::rapidjson::internal::DisableIf \

+    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \

         <RAPIDJSON_REMOVEFPTR_(cond), \

          RAPIDJSON_REMOVEFPTR_(returntype)>::Type

 

 } // namespace internal

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 //@endcond

 

 #if defined(__GNUC__) || defined(_MSC_VER)

diff --git a/external/rapidjson/internal/pow10.h b/external/rapidjson/internal/pow10.h
index 72e0dac9f..1d2dff06a 100644
--- a/external/rapidjson/internal/pow10.h
+++ b/external/rapidjson/internal/pow10.h
@@ -1,27 +1,23 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_POW10_

 #define RAPIDJSON_POW10_

 

-namespace rapidjson {

+#include "../rapidjson.h"

+

+RAPIDJSON_NAMESPACE_BEGIN

 namespace internal {

 

 //! Computes integer powers of 10 in double (10.0^n).

@@ -54,6 +50,6 @@ inline double Pow10(int n) {
 }

 

 } // namespace internal

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_POW10_

diff --git a/external/rapidjson/internal/stack.h b/external/rapidjson/internal/stack.h
index d4d3c92de..dcc975728 100644
--- a/external/rapidjson/internal/stack.h
+++ b/external/rapidjson/internal/stack.h
@@ -1,27 +1,24 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_INTERNAL_STACK_H_

 #define RAPIDJSON_INTERNAL_STACK_H_

 

-namespace rapidjson {

+#include "../rapidjson.h"

+#include "swap.h"

+

+RAPIDJSON_NAMESPACE_BEGIN

 namespace internal {

 

 ///////////////////////////////////////////////////////////////////////////////

@@ -35,15 +32,63 @@ class Stack {
 public:

     // Optimization note: Do not allocate memory for stack_ in constructor.

     // Do it lazily when first Push() -> Expand() -> Resize().

-    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {

+    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {

         RAPIDJSON_ASSERT(stackCapacity > 0);

-        if (!allocator_)

-            ownAllocator = allocator_ = new Allocator();

     }

 

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    Stack(Stack&& rhs)

+        : allocator_(rhs.allocator_),

+          ownAllocator_(rhs.ownAllocator_),

+          stack_(rhs.stack_),

+          stackTop_(rhs.stackTop_),

+          stackEnd_(rhs.stackEnd_),

+          initialCapacity_(rhs.initialCapacity_)

+    {

+        rhs.allocator_ = 0;

+        rhs.ownAllocator_ = 0;

+        rhs.stack_ = 0;

+        rhs.stackTop_ = 0;

+        rhs.stackEnd_ = 0;

+        rhs.initialCapacity_ = 0;

+    }

+#endif

+

     ~Stack() {

-        Allocator::Free(stack_);

-        delete ownAllocator; // Only delete if it is owned by the stack

+        Destroy();

+    }

+

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    Stack& operator=(Stack&& rhs) {

+        if (&rhs != this)

+        {

+            Destroy();

+

+            allocator_ = rhs.allocator_;

+            ownAllocator_ = rhs.ownAllocator_;

+            stack_ = rhs.stack_;

+            stackTop_ = rhs.stackTop_;

+            stackEnd_ = rhs.stackEnd_;

+            initialCapacity_ = rhs.initialCapacity_;

+

+            rhs.allocator_ = 0;

+            rhs.ownAllocator_ = 0;

+            rhs.stack_ = 0;

+            rhs.stackTop_ = 0;

+            rhs.stackEnd_ = 0;

+            rhs.initialCapacity_ = 0;

+        }

+        return *this;

+    }

+#endif

+

+    void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {

+        internal::Swap(allocator_, rhs.allocator_);

+        internal::Swap(ownAllocator_, rhs.ownAllocator_);

+        internal::Swap(stack_, rhs.stack_);

+        internal::Swap(stackTop_, rhs.stackTop_);

+        internal::Swap(stackEnd_, rhs.stackEnd_);

+        internal::Swap(initialCapacity_, rhs.initialCapacity_);

     }

 

     void Clear() { stackTop_ = stack_; }

@@ -87,9 +132,16 @@ public:
     }

 

     template<typename T>

-    T* Bottom() { return (T*)stack_; }

+    T* Bottom() { return reinterpret_cast<T*>(stack_); }

+

+    bool HasAllocator() const {

+        return allocator_ != 0;

+    }

 

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

+    Allocator& GetAllocator() {

+        RAPIDJSON_ASSERT(allocator_);

+        return *allocator_;

+    }

     bool Empty() const { return stackTop_ == stack_; }

     size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }

     size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }

@@ -99,9 +151,11 @@ private:
     void Expand(size_t count) {

         // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.

         size_t newCapacity;

-        if (stack_ == 0)

+        if (stack_ == 0) {

+            if (!allocator_)

+                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());

             newCapacity = initialCapacity_;

-        else {

+        } else {

             newCapacity = GetCapacity();

             newCapacity += (newCapacity + 1) / 2;

         }

@@ -114,17 +168,22 @@ private:
 

     void Resize(size_t newCapacity) {

         const size_t size = GetSize();  // Backup the current size

-        stack_ = (char*)allocator_->Realloc(stack_, GetCapacity(), newCapacity);

+        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));

         stackTop_ = stack_ + size;

         stackEnd_ = stack_ + newCapacity;

     }

 

+    void Destroy() {

+        Allocator::Free(stack_);

+        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack

+    }

+

     // Prohibit copy constructor & assignment operator.

     Stack(const Stack&);

     Stack& operator=(const Stack&);

 

     Allocator* allocator_;

-    Allocator* ownAllocator;

+    Allocator* ownAllocator_;

     char *stack_;

     char *stackTop_;

     char *stackEnd_;

@@ -132,6 +191,6 @@ private:
 };

 

 } // namespace internal

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_STACK_H_

diff --git a/external/rapidjson/internal/strfunc.h b/external/rapidjson/internal/strfunc.h
index 80adcb6b7..f6c99dbf4 100644
--- a/external/rapidjson/internal/strfunc.h
+++ b/external/rapidjson/internal/strfunc.h
@@ -1,27 +1,23 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_INTERNAL_STRFUNC_H_

 #define RAPIDJSON_INTERNAL_STRFUNC_H_

 

-namespace rapidjson {

+#include "../rapidjson.h"

+

+RAPIDJSON_NAMESPACE_BEGIN

 namespace internal {

 

 //! Custom strlen() which works on different character types.

@@ -38,6 +34,6 @@ inline SizeType StrLen(const Ch* s) {
 }

 

 } // namespace internal

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_INTERNAL_STRFUNC_H_

diff --git a/external/rapidjson/internal/strtod.h b/external/rapidjson/internal/strtod.h
new file mode 100644
index 000000000..89590c404
--- /dev/null
+++ b/external/rapidjson/internal/strtod.h
@@ -0,0 +1,270 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRTOD_
+#define RAPIDJSON_STRTOD_
+
+#include "../rapidjson.h"
+#include "ieee754.h"
+#include "biginteger.h"
+#include "diyfp.h"
+#include "pow10.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+inline double FastPath(double significand, int exp) {
+    if (exp < -308)
+        return 0.0;
+    else if (exp >= 0)
+        return significand * internal::Pow10(exp);
+    else
+        return significand / internal::Pow10(-exp);
+}
+
+inline double StrtodNormalPrecision(double d, int p) {
+    if (p < -308) {
+        // Prevent expSum < -308, making Pow10(p) = 0
+        d = FastPath(d, -308);
+        d = FastPath(d, p + 308);
+    }
+    else
+        d = FastPath(d, p);
+    return d;
+}
+
+template <typename T>
+inline T Min3(T a, T b, T c) {
+    T m = a;
+    if (m > b) m = b;
+    if (m > c) m = c;
+    return m;
+}
+
+inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
+    const Double db(b);
+    const uint64_t bInt = db.IntegerSignificand();
+    const int bExp = db.IntegerExponent();
+    const int hExp = bExp - 1;
+
+    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
+
+    // Adjust for decimal exponent
+    if (dExp >= 0) {
+        dS_Exp2 += dExp;
+        dS_Exp5 += dExp;
+    }
+    else {
+        bS_Exp2 -= dExp;
+        bS_Exp5 -= dExp;
+        hS_Exp2 -= dExp;
+        hS_Exp5 -= dExp;
+    }
+
+    // Adjust for binary exponent
+    if (bExp >= 0)
+        bS_Exp2 += bExp;
+    else {
+        dS_Exp2 -= bExp;
+        hS_Exp2 -= bExp;
+    }
+
+    // Adjust for half ulp exponent
+    if (hExp >= 0)
+        hS_Exp2 += hExp;
+    else {
+        dS_Exp2 -= hExp;
+        bS_Exp2 -= hExp;
+    }
+
+    // Remove common power of two factor from all three scaled values
+    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
+    dS_Exp2 -= common_Exp2;
+    bS_Exp2 -= common_Exp2;
+    hS_Exp2 -= common_Exp2;
+
+    BigInteger dS = d;
+    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
+
+    BigInteger bS(bInt);
+    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
+
+    BigInteger hS(1);
+    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
+
+    BigInteger delta(0);
+    dS.Difference(bS, &delta);
+
+    return delta.Compare(hS);
+}
+
+inline bool StrtodFast(double d, int p, double* result) {
+    // Use fast path for string-to-double conversion if possible
+    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
+    if (p > 22  && p < 22 + 16) {
+        // Fast Path Cases In Disguise
+        d *= internal::Pow10(p - 22);
+        p = 22;
+    }
+
+    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
+        *result = FastPath(d, p);
+        return true;
+    }
+    else
+        return false;
+}
+
+// Compute an approximation and see if it is within 1/2 ULP
+inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
+    uint64_t significand = 0;
+    size_t i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
+    for (; i < length; i++) {
+        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
+            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
+            break;
+        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
+    }
+    
+    if (i < length && decimals[i] >= '5') // Rounding
+        significand++;
+
+    size_t remaining = length - i;
+    const unsigned kUlpShift = 3;
+    const unsigned kUlp = 1 << kUlpShift;
+    int error = (remaining == 0) ? 0 : kUlp / 2;
+
+    DiyFp v(significand, 0);
+    v = v.Normalize();
+    error <<= -v.e;
+
+    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
+
+    int actualExp;
+    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
+    if (actualExp != dExp) {
+        static const DiyFp kPow10[] = {
+            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60),  // 10^1
+            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57),  // 10^2
+            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54),  // 10^3
+            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50),  // 10^4
+            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47),  // 10^5
+            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44),  // 10^6
+            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40)   // 10^7
+        };
+        int  adjustment = dExp - actualExp - 1;
+        RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
+        v = v * kPow10[adjustment];
+        if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
+            error += kUlp / 2;
+    }
+
+    v = v * cachedPower;
+
+    error += kUlp + (error == 0 ? 0 : 1);
+
+    const int oldExp = v.e;
+    v = v.Normalize();
+    error <<= oldExp - v.e;
+
+    const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
+    unsigned precisionSize = 64 - effectiveSignificandSize;
+    if (precisionSize + kUlpShift >= 64) {
+        unsigned scaleExp = (precisionSize + kUlpShift) - 63;
+        v.f >>= scaleExp;
+        v.e += scaleExp; 
+        error = (error >> scaleExp) + 1 + static_cast<int>(kUlp);
+        precisionSize -= scaleExp;
+    }
+
+    DiyFp rounded(v.f >> precisionSize, v.e + static_cast<int>(precisionSize));
+    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
+    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
+    if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
+        rounded.f++;
+        if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
+            rounded.f >>= 1;
+            rounded.e++;
+        }
+    }
+
+    *result = rounded.ToDouble();
+
+    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
+}
+
+inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
+    const BigInteger dInt(decimals, length);
+    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
+    Double a(approx);
+    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
+    if (cmp < 0)
+        return a.Value();  // within half ULP
+    else if (cmp == 0) {
+        // Round towards even
+        if (a.Significand() & 1)
+            return a.NextPositiveDouble();
+        else
+            return a.Value();
+    }
+    else // adjustment
+        return a.NextPositiveDouble();
+}
+
+inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
+    RAPIDJSON_ASSERT(d >= 0.0);
+    RAPIDJSON_ASSERT(length >= 1);
+
+    double result;
+    if (StrtodFast(d, p, &result))
+        return result;
+
+    // Trim leading zeros
+    while (*decimals == '0' && length > 1) {
+        length--;
+        decimals++;
+        decimalPosition--;
+    }
+
+    // Trim trailing zeros
+    while (decimals[length - 1] == '0' && length > 1) {
+        length--;
+        decimalPosition--;
+        exp++;
+    }
+
+    // Trim right-most digits
+    const int kMaxDecimalDigit = 780;
+    if (static_cast<int>(length) > kMaxDecimalDigit) {
+        int delta = (static_cast<int>(length) - kMaxDecimalDigit);
+        exp += delta;
+        decimalPosition -= static_cast<unsigned>(delta);
+        length = kMaxDecimalDigit;
+    }
+
+    // If too small, underflow to zero
+    if (int(length) + exp < -324)
+        return 0.0;
+
+    if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
+        return result;
+
+    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
+    return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STRTOD_
diff --git a/external/rapidjson/internal/swap.h b/external/rapidjson/internal/swap.h
new file mode 100644
index 000000000..39bc2e464
--- /dev/null
+++ b/external/rapidjson/internal/swap.h
@@ -0,0 +1,37 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.

+//

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

+//

+// Licensed under the MIT License (the "License"); you may not use this file except

+// in compliance with the License. You may obtain a copy of the License at

+//

+// http://opensource.org/licenses/MIT

+//

+// Unless required by applicable law or agreed to in writing, software distributed

+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

+// CONDITIONS OF ANY KIND, either express or implied. See the License for the

+// specific language governing permissions and limitations under the License.

+

+#ifndef RAPIDJSON_INTERNAL_SWAP_H_

+#define RAPIDJSON_INTERNAL_SWAP_H_

+

+#include "../rapidjson.h"

+

+RAPIDJSON_NAMESPACE_BEGIN

+namespace internal {

+

+//! Custom swap() to avoid dependency on C++ <algorithm> header

+/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.

+    \note This has the same semantics as std::swap().

+*/

+template <typename T>

+inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT {

+    T tmp = a;

+        a = b;

+        b = tmp;

+}

+

+} // namespace internal

+RAPIDJSON_NAMESPACE_END

+

+#endif // RAPIDJSON_INTERNAL_SWAP_H_

diff --git a/external/rapidjson/memorybuffer.h b/external/rapidjson/memorybuffer.h
index ef15c4678..2484b2185 100644
--- a/external/rapidjson/memorybuffer.h
+++ b/external/rapidjson/memorybuffer.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// 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
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// 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_MEMORYBUFFER_H_
 #define RAPIDJSON_MEMORYBUFFER_H_
@@ -24,7 +18,7 @@
 #include "rapidjson.h"
 #include "internal/stack.h"
 
-namespace rapidjson {
+RAPIDJSON_NAMESPACE_BEGIN
 
 //! Represents an in-memory output byte stream.
 /*!
@@ -71,6 +65,6 @@ inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
     std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
 }
 
-} // namespace rapidjson
+RAPIDJSON_NAMESPACE_END
 
 #endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/external/rapidjson/memorystream.h b/external/rapidjson/memorystream.h
index 8701c33c5..beed1efb5 100644
--- a/external/rapidjson/memorystream.h
+++ b/external/rapidjson/memorystream.h
@@ -1,29 +1,29 @@
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// 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
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// 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_MEMORYSTREAM_H_
 #define RAPIDJSON_MEMORYSTREAM_H_
 
 #include "rapidjson.h"
 
-namespace rapidjson {
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
 
 //! Represents an in-memory input byte stream.
 /*!
@@ -42,7 +42,7 @@ struct MemoryStream {
 
     MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
 
-    Ch Peek() const { return *src_; }
+    Ch Peek() const { return (src_ == end_) ? '\0' : *src_; }
     Ch Take() { return (src_ == end_) ? '\0' : *src_++; }
     size_t Tell() const { return static_cast<size_t>(src_ - begin_); }
 
@@ -62,6 +62,10 @@ struct MemoryStream {
     size_t size_;       //!< Size of the stream.
 };
 
-} // namespace rapidjson
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
 
 #endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/external/rapidjson/msinttypes/inttypes.h b/external/rapidjson/msinttypes/inttypes.h
index ac7e32b6e..18111286b 100644
--- a/external/rapidjson/msinttypes/inttypes.h
+++ b/external/rapidjson/msinttypes/inttypes.h
@@ -30,6 +30,10 @@
 // 
 ///////////////////////////////////////////////////////////////////////////////
 
+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
 #ifndef _MSC_VER // [
 #error "Use this header only with Microsoft Visual C++ compilers!"
 #endif // _MSC_VER ]
@@ -43,6 +47,11 @@
 
 #include "stdint.h"
 
+// miloyip: VC supports inttypes.h since VC2013
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+
 // 7.8 Format conversion of integer types
 
 typedef struct {
@@ -302,5 +311,6 @@ imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
 #define wcstoimax _wcstoi64
 #define wcstoumax _wcstoui64
 
+#endif // _MSC_VER >= 1800
 
 #endif // _MSC_INTTYPES_H_ ]
diff --git a/external/rapidjson/msinttypes/stdint.h b/external/rapidjson/msinttypes/stdint.h
index bbad95af1..3d4477b9a 100644
--- a/external/rapidjson/msinttypes/stdint.h
+++ b/external/rapidjson/msinttypes/stdint.h
@@ -30,6 +30,10 @@
 // 
 ///////////////////////////////////////////////////////////////////////////////
 
+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
 #ifndef _MSC_VER // [
 #error "Use this header only with Microsoft Visual C++ compilers!"
 #endif // _MSC_VER ]
@@ -85,14 +89,14 @@
 #include <limits.h>
 
 // For Visual Studio 6 in C++ mode and for many Visual Studio versions when
-// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
-// or compiler give many errors like this:
+// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler would give many errors like this:
 //   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
-#ifdef __cplusplus
+#if defined(__cplusplus) && !defined(_M_ARM)
 extern "C" {
 #endif
 #  include <wchar.h>
-#ifdef __cplusplus
+#if defined(__cplusplus) && !defined(_M_ARM)
 }
 #endif
 
diff --git a/external/rapidjson/pointer.h b/external/rapidjson/pointer.h
new file mode 100644
index 000000000..7519490dc
--- /dev/null
+++ b/external/rapidjson/pointer.h
@@ -0,0 +1,1326 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_POINTER_H_
+#define RAPIDJSON_POINTER_H_
+
+#include "document.h"
+#include "internal/itoa.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(switch-enum)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+static const SizeType kPointerInvalidIndex = ~SizeType(0);  //!< Represents an invalid index in GenericPointer::Token
+
+//! Error code of parsing.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode
+*/
+enum PointerParseErrorCode {
+    kPointerParseErrorNone = 0,                     //!< The parse is successful
+
+    kPointerParseErrorTokenMustBeginWithSolidus,    //!< A token must begin with a '/'
+    kPointerParseErrorInvalidEscape,                //!< Invalid escape
+    kPointerParseErrorInvalidPercentEncoding,       //!< Invalid percent encoding in URI fragment
+    kPointerParseErrorCharacterMustPercentEncode    //!< A character must percent encoded in URI fragment
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericPointer
+
+//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
+/*!
+    This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" 
+    (https://tools.ietf.org/html/rfc6901).
+
+    A JSON pointer is for identifying a specific value in a JSON document
+    (GenericDocument). It can simplify coding of DOM tree manipulation, because it
+    can access multiple-level depth of DOM tree with single API call.
+
+    After it parses a string representation (e.g. "/foo/0" or URI fragment 
+    representation (e.g. "#/foo/0") into its internal representation (tokens),
+    it can be used to resolve a specific value in multiple documents, or sub-tree 
+    of documents.
+
+    Contrary to GenericValue, Pointer can be copy constructed and copy assigned.
+    Apart from assignment, a Pointer cannot be modified after construction.
+
+    Although Pointer is very convenient, please aware that constructing Pointer
+    involves parsing and dynamic memory allocation. A special constructor with user-
+    supplied tokens eliminates these.
+
+    GenericPointer depends on GenericDocument and GenericValue.
+    
+    \tparam ValueType The value type of the DOM tree. E.g. GenericValue<UTF8<> >
+    \tparam Allocator The allocator type for allocating memory for internal representation.
+    
+    \note GenericPointer uses same encoding of ValueType.
+    However, Allocator of GenericPointer is independent of Allocator of Value.
+*/
+template <typename ValueType, typename Allocator = CrtAllocator>
+class GenericPointer {
+public:
+    typedef typename ValueType::EncodingType EncodingType;  //!< Encoding type from Value
+    typedef typename ValueType::Ch Ch;                      //!< Character type from Value
+
+    //! A token is the basic units of internal representation.
+    /*!
+        A JSON pointer string representation "/foo/123" is parsed to two tokens: 
+        "foo" and 123. 123 will be represented in both numeric form and string form.
+        They are resolved according to the actual value type (object or array).
+
+        For token that are not numbers, or the numeric value is out of bound
+        (greater than limits of SizeType), they are only treated as string form
+        (i.e. the token's index will be equal to kPointerInvalidIndex).
+
+        This struct is public so that user can create a Pointer without parsing and 
+        allocation, using a special constructor.
+    */
+    struct Token {
+        const Ch* name;             //!< Name of the token. It has null character at the end but it can contain null character.
+        SizeType length;            //!< Length of the name.
+        SizeType index;             //!< A valid array index, if it is not equal to kPointerInvalidIndex.
+    };
+
+    //!@name Constructors and destructor.
+    //@{
+
+    //! Default constructor.
+    GenericPointer() : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
+
+    //! Constructor that parses a string or URI fragment representation.
+    /*!
+        \param source A null-terminated, string or URI fragment representation of JSON pointer.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+    */
+    explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        Parse(source, internal::StrLen(source));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Constructor that parses a string or URI fragment representation.
+    /*!
+        \param source A string or URI fragment representation of JSON pointer.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+    */
+    explicit GenericPointer(const std::basic_string<Ch>& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        Parse(source.c_str(), source.size());
+    }
+#endif
+
+    //! Constructor that parses a string or URI fragment representation, with length of the source string.
+    /*!
+        \param source A string or URI fragment representation of JSON pointer.
+        \param length Length of source.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+        \note Slightly faster than the overload without length.
+    */
+    GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        Parse(source, length);
+    }
+
+    //! Constructor with user-supplied tokens.
+    /*!
+        This constructor let user supplies const array of tokens.
+        This prevents the parsing process and eliminates allocation.
+        This is preferred for memory constrained environments.
+
+        \param tokens An constant array of tokens representing the JSON pointer.
+        \param tokenCount Number of tokens.
+
+        \b Example
+        \code
+        #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
+        #define INDEX(i) { #i, sizeof(#i) - 1, i }
+
+        static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
+        static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
+        // Equivalent to static const Pointer p("/foo/123");
+
+        #undef NAME
+        #undef INDEX
+        \endcode
+    */
+    GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
+
+    //! Copy constructor.
+    GenericPointer(const GenericPointer& rhs) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        *this = rhs;
+    }
+
+    //! Destructor.
+    ~GenericPointer() {
+        if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
+            Allocator::Free(tokens_);
+        RAPIDJSON_DELETE(ownAllocator_);
+    }
+
+    //! Assignment operator.
+    GenericPointer& operator=(const GenericPointer& rhs) {
+        if (this != &rhs) {
+            // Do not delete ownAllcator
+            if (nameBuffer_)
+                Allocator::Free(tokens_);
+
+            tokenCount_ = rhs.tokenCount_;
+            parseErrorOffset_ = rhs.parseErrorOffset_;
+            parseErrorCode_ = rhs.parseErrorCode_;
+
+            if (rhs.nameBuffer_)
+                CopyFromRaw(rhs); // Normally parsed tokens.
+            else {
+                tokens_ = rhs.tokens_; // User supplied const tokens.
+                nameBuffer_ = 0;
+            }
+        }
+        return *this;
+    }
+
+    //@}
+
+    //!@name Append token
+    //@{
+
+    //! Append a token and return a new Pointer
+    /*!
+        \param token Token to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const Token& token, Allocator* allocator = 0) const {
+        GenericPointer r;
+        r.allocator_ = allocator;
+        Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
+        std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
+        r.tokens_[tokenCount_].name = p;
+        r.tokens_[tokenCount_].length = token.length;
+        r.tokens_[tokenCount_].index = token.index;
+        return r;
+    }
+
+    //! Append a name token with length, and return a new Pointer
+    /*!
+        \param name Name to be appended.
+        \param length Length of name.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const {
+        Token token = { name, length, kPointerInvalidIndex };
+        return Append(token, allocator);
+    }
+
+    //! Append a name token without length, and return a new Pointer
+    /*!
+        \param name Name (const Ch*) to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
+    Append(T* name, Allocator* allocator = 0) const {
+        return Append(name, StrLen(name), allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Append a name token, and return a new Pointer
+    /*!
+        \param name Name to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const std::basic_string<Ch>& name, Allocator* allocator = 0) const {
+        return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
+    }
+#endif
+
+    //! Append a index token, and return a new Pointer
+    /*!
+        \param index Index to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(SizeType index, Allocator* allocator = 0) const {
+        char buffer[21];
+        char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
+        SizeType length = static_cast<SizeType>(end - buffer);
+        buffer[length] = '\0';
+
+        if (sizeof(Ch) == 1) {
+            Token token = { reinterpret_cast<Ch*>(buffer), length, index };
+            return Append(token, allocator);
+        }
+        else {
+            Ch name[21];
+            for (size_t i = 0; i <= length; i++)
+                name[i] = buffer[i];
+            Token token = { name, length, index };
+            return Append(token, allocator);
+        }
+    }
+
+    //! Append a token by value, and return a new Pointer
+    /*!
+        \param token token to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const {
+        if (token.IsString())
+            return Append(token.GetString(), token.GetStringLength(), allocator);
+        else {
+            RAPIDJSON_ASSERT(token.IsUint64());
+            RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
+            return Append(static_cast<SizeType>(token.GetUint64()), allocator);
+        }
+    }
+
+    //!@name Handling Parse Error
+    //@{
+
+    //! Check whether this is a valid pointer.
+    bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; }
+
+    //! Get the parsing error offset in code unit.
+    size_t GetParseErrorOffset() const { return parseErrorOffset_; }
+
+    //! Get the parsing error code.
+    PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; }
+
+    //@}
+
+    //!@name Tokens
+    //@{
+
+    //! Get the token array (const version only).
+    const Token* GetTokens() const { return tokens_; }
+
+    //! Get the number of tokens.
+    size_t GetTokenCount() const { return tokenCount_; }
+
+    //@}
+
+    //!@name Equality/inequality operators
+    //@{
+
+    //! Equality operator.
+    /*!
+        \note When any pointers are invalid, always returns false.
+    */
+    bool operator==(const GenericPointer& rhs) const {
+        if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
+            return false;
+
+        for (size_t i = 0; i < tokenCount_; i++) {
+            if (tokens_[i].index != rhs.tokens_[i].index ||
+                tokens_[i].length != rhs.tokens_[i].length || 
+                (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    //! Inequality operator.
+    /*!
+        \note When any pointers are invalid, always returns true.
+    */
+    bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
+
+    //@}
+
+    //!@name Stringify
+    //@{
+
+    //! Stringify the pointer into string representation.
+    /*!
+        \tparam OutputStream Type of output stream.
+        \param os The output stream.
+    */
+    template<typename OutputStream>
+    bool Stringify(OutputStream& os) const {
+        return Stringify<false, OutputStream>(os);
+    }
+
+    //! Stringify the pointer into URI fragment representation.
+    /*!
+        \tparam OutputStream Type of output stream.
+        \param os The output stream.
+    */
+    template<typename OutputStream>
+    bool StringifyUriFragment(OutputStream& os) const {
+        return Stringify<true, OutputStream>(os);
+    }
+
+    //@}
+
+    //!@name Create value
+    //@{
+
+    //! Create a value in a subtree.
+    /*!
+        If the value is not exist, it creates all parent values and a JSON Null value.
+        So it always succeed and return the newly created or existing value.
+
+        Remind that it may change types of parents according to tokens, so it 
+        potentially removes previously stored values. For example, if a document 
+        was an array, and "/foo" is used to create a value, then the document 
+        will be changed to an object, and all existing array elements are lost.
+
+        \param root Root value of a DOM subtree to be resolved. It can be any value other than document root.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
+        \return The resolved newly created (a JSON Null value), or already exists value.
+    */
+    ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const {
+        RAPIDJSON_ASSERT(IsValid());
+        ValueType* v = &root;
+        bool exist = true;
+        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+            if (v->IsArray() && t->name[0] == '-' && t->length == 1) {
+                v->PushBack(ValueType().Move(), allocator);
+                v = &((*v)[v->Size() - 1]);
+                exist = false;
+            }
+            else {
+                if (t->index == kPointerInvalidIndex) { // must be object name
+                    if (!v->IsObject())
+                        v->SetObject(); // Change to Object
+                }
+                else { // object name or array index
+                    if (!v->IsArray() && !v->IsObject())
+                        v->SetArray(); // Change to Array
+                }
+
+                if (v->IsArray()) {
+                    if (t->index >= v->Size()) {
+                        v->Reserve(t->index + 1, allocator);
+                        while (t->index >= v->Size())
+                            v->PushBack(ValueType().Move(), allocator);
+                        exist = false;
+                    }
+                    v = &((*v)[t->index]);
+                }
+                else {
+                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    if (m == v->MemberEnd()) {
+                        v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
+                        v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
+                        exist = false;
+                    }
+                    else
+                        v = &m->value;
+                }
+            }
+        }
+
+        if (alreadyExist)
+            *alreadyExist = exist;
+
+        return *v;
+    }
+
+    //! Creates a value in a document.
+    /*!
+        \param document A document to be resolved.
+        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
+        \return The resolved newly created, or already exists value.
+    */
+    template <typename stackAllocator>
+    ValueType& Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, bool* alreadyExist = 0) const {
+        return Create(document, document.GetAllocator(), alreadyExist);
+    }
+
+    //@}
+
+    //!@name Query value
+    //@{
+
+    //! Query a value in a subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Pointer to the value if it can be resolved. Otherwise null.
+    */
+    ValueType* Get(ValueType& root) const {
+        RAPIDJSON_ASSERT(IsValid());
+        ValueType* v = &root;
+        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+            switch (v->GetType()) {
+            case kObjectType:
+                {
+                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    if (m == v->MemberEnd())
+                        return 0;
+                    v = &m->value;
+                }
+                break;
+            case kArrayType:
+                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
+                    return 0;
+                v = &((*v)[t->index]);
+                break;
+            default:
+                return 0;
+            }
+        }
+        return v;
+    }
+
+    //! Query a const value in a const subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Pointer to the value if it can be resolved. Otherwise null.
+    */
+    const ValueType* Get(const ValueType& root) const { return Get(const_cast<ValueType&>(root)); }
+
+    //@}
+
+    //!@name Query a value with default
+    //@{
+
+    //! Query a value in a subtree with default value.
+    /*!
+        Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value.
+        So that this function always succeed.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param defaultValue Default value to be cloned if the value was not exists.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
+        bool alreadyExist;
+        Value& v = Create(root, allocator, &alreadyExist);
+        return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
+    }
+
+    //! Query a value in a subtree with default null-terminated string.
+    ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
+        bool alreadyExist;
+        Value& v = Create(root, allocator, &alreadyExist);
+        return alreadyExist ? v : v.SetString(defaultValue, allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Query a value in a subtree with default std::basic_string.
+    ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
+        bool alreadyExist;
+        Value& v = Create(root, allocator, &alreadyExist);
+        return alreadyExist ? v : v.SetString(defaultValue, allocator);
+    }
+#endif
+
+    //! Query a value in a subtree with default primitive value.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+    GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const {
+        return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
+    }
+
+    //! Query a value in a document with default value.
+    template <typename stackAllocator>
+    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+    //! Query a value in a document with default null-terminated string.
+    template <typename stackAllocator>
+    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+    
+#if RAPIDJSON_HAS_STDSTRING
+    //! Query a value in a document with default std::basic_string.
+    template <typename stackAllocator>
+    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+#endif
+
+    //! Query a value in a document with default primitive value.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T, typename stackAllocator>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+    //@}
+
+    //!@name Set a value
+    //@{
+
+    //! Set a value in a subtree, with move semantics.
+    /*!
+        It creates all parents if they are not exist or types are different to the tokens.
+        So this function always succeeds but potentially remove existing values.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param value Value to be set.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = value;
+    }
+
+    //! Set a value in a subtree, with copy semantics.
+    ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator).CopyFrom(value, allocator);
+    }
+
+    //! Set a null-terminated string in a subtree.
+    ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = ValueType(value, allocator).Move();
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Set a std::basic_string in a subtree.
+    ValueType& Set(ValueType& root, const std::basic_string<Ch>& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = ValueType(value, allocator).Move();
+    }
+#endif
+
+    //! Set a primitive value in a subtree.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+    Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = ValueType(value).Move();
+    }
+
+    //! Set a value in a document, with move semantics.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
+        return Create(document) = value;
+    }
+
+    //! Set a value in a document, with copy semantics.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& value) const {
+        return Create(document).CopyFrom(value, document.GetAllocator());
+    }
+
+    //! Set a null-terminated string in a document.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* value) const {
+        return Create(document) = ValueType(value, document.GetAllocator()).Move();
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Sets a std::basic_string in a document.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& value) const {
+        return Create(document) = ValueType(value, document.GetAllocator()).Move();
+    }
+#endif
+
+    //! Set a primitive value in a document.
+    /*!
+    \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T, typename stackAllocator>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+        Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T value) const {
+            return Create(document) = value;
+    }
+
+    //@}
+
+    //!@name Swap a value
+    //@{
+
+    //! Swap a value with a value in a subtree.
+    /*!
+        It creates all parents if they are not exist or types are different to the tokens.
+        So this function always succeeds but potentially remove existing values.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param value Value to be swapped.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator).Swap(value);
+    }
+
+    //! Swap a value with a value in a document.
+    template <typename stackAllocator>
+    ValueType& Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
+        return Create(document).Swap(value);
+    }
+
+    //@}
+
+    //! Erase a value in a subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Whether the resolved value is found and erased.
+
+        \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false.
+    */
+    bool Erase(ValueType& root) const {
+        RAPIDJSON_ASSERT(IsValid());
+        if (tokenCount_ == 0) // Cannot erase the root
+            return false;
+
+        ValueType* v = &root;
+        const Token* last = tokens_ + (tokenCount_ - 1);
+        for (const Token *t = tokens_; t != last; ++t) {
+            switch (v->GetType()) {
+            case kObjectType:
+                {
+                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    if (m == v->MemberEnd())
+                        return false;
+                    v = &m->value;
+                }
+                break;
+            case kArrayType:
+                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
+                    return false;
+                v = &((*v)[t->index]);
+                break;
+            default:
+                return false;
+            }
+        }
+
+        switch (v->GetType()) {
+        case kObjectType:
+            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
+        case kArrayType:
+            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
+                return false;
+            v->Erase(v->Begin() + last->index);
+            return true;
+        default:
+            return false;
+        }
+    }
+
+private:
+    //! Clone the content from rhs to this.
+    /*!
+        \param rhs Source pointer.
+        \param extraToken Extra tokens to be allocated.
+        \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated.
+        \return Start of non-occupied name buffer, for storing extra names.
+    */
+    Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) {
+        if (!allocator_) // allocator is independently owned.
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+
+        size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
+        for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
+            nameBufferSize += t->length;
+
+        tokenCount_ = rhs.tokenCount_ + extraToken;
+        tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
+        nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
+        std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
+        std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
+
+        // Adjust pointers to name buffer
+        std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
+        for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
+            t->name += diff;
+
+        return nameBuffer_ + nameBufferSize;
+    }
+
+    //! Check whether a character should be percent-encoded.
+    /*!
+        According to RFC 3986 2.3 Unreserved Characters.
+        \param c The character (code unit) to be tested.
+    */
+    bool NeedPercentEncode(Ch c) const {
+        return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
+    }
+
+    //! Parse a JSON String or its URI fragment representation into tokens.
+#ifndef __clang__ // -Wdocumentation
+    /*!
+        \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
+        \param length Length of the source string.
+        \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped.
+    */
+#endif
+    void Parse(const Ch* source, size_t length) {
+        RAPIDJSON_ASSERT(source != NULL);
+        RAPIDJSON_ASSERT(nameBuffer_ == 0);
+        RAPIDJSON_ASSERT(tokens_ == 0);
+
+        // Create own allocator if user did not supply.
+        if (!allocator_)
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+
+        // Count number of '/' as tokenCount
+        tokenCount_ = 0;
+        for (const Ch* s = source; s != source + length; s++) 
+            if (*s == '/')
+                tokenCount_++;
+
+        Token* token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
+        Ch* name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
+        size_t i = 0;
+
+        // Detect if it is a URI fragment
+        bool uriFragment = false;
+        if (source[i] == '#') {
+            uriFragment = true;
+            i++;
+        }
+
+        if (i != length && source[i] != '/') {
+            parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
+            goto error;
+        }
+
+        while (i < length) {
+            RAPIDJSON_ASSERT(source[i] == '/');
+            i++; // consumes '/'
+
+            token->name = name;
+            bool isNumber = true;
+
+            while (i < length && source[i] != '/') {
+                Ch c = source[i];
+                if (uriFragment) {
+                    // Decoding percent-encoding for URI fragment
+                    if (c == '%') {
+                        PercentDecodeStream is(&source[i], source + length);
+                        GenericInsituStringStream<EncodingType> os(name);
+                        Ch* begin = os.PutBegin();
+                        if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid()) {
+                            parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
+                            goto error;
+                        }
+                        size_t len = os.PutEnd(begin);
+                        i += is.Tell() - 1;
+                        if (len == 1)
+                            c = *name;
+                        else {
+                            name += len;
+                            isNumber = false;
+                            i++;
+                            continue;
+                        }
+                    }
+                    else if (NeedPercentEncode(c)) {
+                        parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
+                        goto error;
+                    }
+                }
+
+                i++;
+                
+                // Escaping "~0" -> '~', "~1" -> '/'
+                if (c == '~') {
+                    if (i < length) {
+                        c = source[i];
+                        if (c == '0')       c = '~';
+                        else if (c == '1')  c = '/';
+                        else {
+                            parseErrorCode_ = kPointerParseErrorInvalidEscape;
+                            goto error;
+                        }
+                        i++;
+                    }
+                    else {
+                        parseErrorCode_ = kPointerParseErrorInvalidEscape;
+                        goto error;
+                    }
+                }
+
+                // First check for index: all of characters are digit
+                if (c < '0' || c > '9')
+                    isNumber = false;
+
+                *name++ = c;
+            }
+            token->length = static_cast<SizeType>(name - token->name);
+            if (token->length == 0)
+                isNumber = false;
+            *name++ = '\0'; // Null terminator
+
+            // Second check for index: more than one digit cannot have leading zero
+            if (isNumber && token->length > 1 && token->name[0] == '0')
+                isNumber = false;
+
+            // String to SizeType conversion
+            SizeType n = 0;
+            if (isNumber) {
+                for (size_t j = 0; j < token->length; j++) {
+                    SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
+                    if (m < n) {   // overflow detection
+                        isNumber = false;
+                        break;
+                    }
+                    n = m;
+                }
+            }
+
+            token->index = isNumber ? n : kPointerInvalidIndex;
+            token++;
+        }
+
+        RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
+        parseErrorCode_ = kPointerParseErrorNone;
+        return;
+
+    error:
+        Allocator::Free(tokens_);
+        nameBuffer_ = 0;
+        tokens_ = 0;
+        tokenCount_ = 0;
+        parseErrorOffset_ = i;
+        return;
+    }
+
+    //! Stringify to string or URI fragment representation.
+    /*!
+        \tparam uriFragment True for stringifying to URI fragment representation. False for string representation.
+        \tparam OutputStream type of output stream.
+        \param os The output stream.
+    */
+    template<bool uriFragment, typename OutputStream>
+    bool Stringify(OutputStream& os) const {
+        RAPIDJSON_ASSERT(IsValid());
+
+        if (uriFragment)
+            os.Put('#');
+
+        for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+            os.Put('/');
+            for (size_t j = 0; j < t->length; j++) {
+                Ch c = t->name[j];
+                if (c == '~') {
+                    os.Put('~');
+                    os.Put('0');
+                }
+                else if (c == '/') {
+                    os.Put('~');
+                    os.Put('1');
+                }
+                else if (uriFragment && NeedPercentEncode(c)) { 
+                    // Transcode to UTF8 sequence
+                    GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
+                    PercentEncodeStream<OutputStream> target(os);
+                    if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
+                        return false;
+                    j += source.Tell() - 1;
+                }
+                else
+                    os.Put(c);
+            }
+        }
+        return true;
+    }
+
+    //! A helper stream for decoding a percent-encoded sequence into code unit.
+    /*!
+        This stream decodes %XY triplet into code unit (0-255).
+        If it encounters invalid characters, it sets output code unit as 0 and 
+        mark invalid, and to be checked by IsValid().
+    */
+    class PercentDecodeStream {
+    public:
+        typedef typename ValueType::Ch Ch;
+
+        //! Constructor
+        /*!
+            \param source Start of the stream
+            \param end Past-the-end of the stream.
+        */
+        PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {}
+
+        Ch Take() {
+            if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet
+                valid_ = false;
+                return 0;
+            }
+            src_++;
+            Ch c = 0;
+            for (int j = 0; j < 2; j++) {
+                c <<= 4;
+                Ch h = *src_;
+                if      (h >= '0' && h <= '9') c += h - '0';
+                else if (h >= 'A' && h <= 'F') c += h - 'A' + 10;
+                else if (h >= 'a' && h <= 'f') c += h - 'a' + 10;
+                else {
+                    valid_ = false;
+                    return 0;
+                }
+                src_++;
+            }
+            return c;
+        }
+
+        size_t Tell() const { return static_cast<size_t>(src_ - head_); }
+        bool IsValid() const { return valid_; }
+
+    private:
+        const Ch* src_;     //!< Current read position.
+        const Ch* head_;    //!< Original head of the string.
+        const Ch* end_;     //!< Past-the-end position.
+        bool valid_;        //!< Whether the parsing is valid.
+    };
+
+    //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.
+    template <typename OutputStream>
+    class PercentEncodeStream {
+    public:
+        PercentEncodeStream(OutputStream& os) : os_(os) {}
+        void Put(char c) { // UTF-8 must be byte
+            unsigned char u = static_cast<unsigned char>(c);
+            static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+            os_.Put('%');
+            os_.Put(hexDigits[u >> 4]);
+            os_.Put(hexDigits[u & 15]);
+        }
+    private:
+        OutputStream& os_;
+    };
+
+    Allocator* allocator_;                  //!< The current allocator. It is either user-supplied or equal to ownAllocator_.
+    Allocator* ownAllocator_;               //!< Allocator owned by this Pointer.
+    Ch* nameBuffer_;                        //!< A buffer containing all names in tokens.
+    Token* tokens_;                         //!< A list of tokens.
+    size_t tokenCount_;                     //!< Number of tokens in tokens_.
+    size_t parseErrorOffset_;               //!< Offset in code unit when parsing fail.
+    PointerParseErrorCode parseErrorCode_;  //!< Parsing error code.
+};
+
+//! GenericPointer for Value (UTF-8, default allocator).
+typedef GenericPointer<Value> Pointer;
+
+//!@name Helper functions for GenericPointer
+//@{
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::AllocatorType& a) {
+    return pointer.Create(root, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer) {
+    return pointer.Create(document);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType* GetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer) {
+    return pointer.Get(root);
+}
+
+template <typename T>
+const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer<typename T::ValueType>& pointer) {
+    return pointer.Get(root);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N]) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root);
+}
+
+template <typename T, typename CharType, size_t N>
+const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N]) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+#endif
+
+template <typename T, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+#endif
+
+template <typename T, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+#endif
+
+template <typename DocumentType, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+#endif
+
+template <typename DocumentType, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+#endif
+
+template <typename T, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+#endif
+
+template <typename T, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
+    return pointer.Set(document, value);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& value) {
+    return pointer.Set(document, value);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* value) {
+    return pointer.Set(document, value);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& value) {
+    return pointer.Set(document, value);
+}
+#endif
+
+template <typename DocumentType, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 value) {
+    return pointer.Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+#endif
+
+template <typename DocumentType, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
+    return pointer.Swap(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
+    return pointer.Swap(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+bool EraseValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer) {
+    return pointer.Erase(root);
+}
+
+template <typename T, typename CharType, size_t N>
+bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
+}
+
+//@}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_POINTER_H_
diff --git a/external/rapidjson/prettywriter.h b/external/rapidjson/prettywriter.h
index 4eac8d76f..adfff4fd5 100644
--- a/external/rapidjson/prettywriter.h
+++ b/external/rapidjson/prettywriter.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_PRETTYWRITER_H_

 #define RAPIDJSON_PRETTYWRITER_H_

@@ -28,7 +22,7 @@ RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(effc++)

 #endif

 

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 

 //! Writer with indentation and spacing.

 /*!

@@ -82,6 +76,12 @@ public:
         return Base::WriteString(str, length);

     }

 

+#if RAPIDJSON_HAS_STDSTRING

+    bool String(const std::basic_string<Ch>& str) {

+        return String(str.data(), SizeType(str.size()));

+    }

+#endif

+

     bool StartObject() {

         PrettyPrefix(kObjectType);

         new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);

@@ -100,8 +100,9 @@ public:
             Base::os_->Put('\n');

             WriteIndent();

         }

-        if (!Base::WriteEndObject())

-            return false;

+        bool ret = Base::WriteEndObject();

+        (void)ret;

+        RAPIDJSON_ASSERT(ret == true);

         if (Base::level_stack_.Empty()) // end of json text

             Base::os_->Flush();

         return true;

@@ -123,8 +124,9 @@ public:
             Base::os_->Put('\n');

             WriteIndent();

         }

-        if (!Base::WriteEndArray())

-            return false;

+        bool ret = Base::WriteEndArray();

+        (void)ret;

+        RAPIDJSON_ASSERT(ret == true);

         if (Base::level_stack_.Empty()) // end of json text

             Base::os_->Flush();

         return true;

@@ -184,7 +186,7 @@ protected:
 

     void WriteIndent()  {

         size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;

-        PutN(*Base::os_, indentChar_, count);

+        PutN(*Base::os_, static_cast<typename TargetEncoding::Ch>(indentChar_), count);

     }

 

     Ch indentChar_;

@@ -196,7 +198,7 @@ private:
     PrettyWriter& operator=(const PrettyWriter&);

 };

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #ifdef __GNUC__

 RAPIDJSON_DIAG_POP

diff --git a/external/rapidjson/rapidjson.h b/external/rapidjson/rapidjson.h
index 3f743234d..d896a1445 100644
--- a/external/rapidjson/rapidjson.h
+++ b/external/rapidjson/rapidjson.h
@@ -1,32 +1,23 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_RAPIDJSON_H_

 #define RAPIDJSON_RAPIDJSON_H_

 

-// Copyright (c) 2011 Milo Yip (miloyip@gmail.com)

-// Version 0.1

-

 /*!\file rapidjson.h

     \brief common definitions and configuration

-

+    

     \see RAPIDJSON_CONFIG

  */

 

@@ -49,6 +40,111 @@
 #include <cstring>  // memset(), memcpy(), memmove(), memcmp()

 

 ///////////////////////////////////////////////////////////////////////////////

+// RAPIDJSON_VERSION_STRING

+//

+// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.

+//

+

+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN

+// token stringification

+#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)

+#define RAPIDJSON_DO_STRINGIFY(x) #x

+//!@endcond

+

+/*! \def RAPIDJSON_MAJOR_VERSION

+    \ingroup RAPIDJSON_CONFIG

+    \brief Major version of RapidJSON in integer.

+*/

+/*! \def RAPIDJSON_MINOR_VERSION

+    \ingroup RAPIDJSON_CONFIG

+    \brief Minor version of RapidJSON in integer.

+*/

+/*! \def RAPIDJSON_PATCH_VERSION

+    \ingroup RAPIDJSON_CONFIG

+    \brief Patch version of RapidJSON in integer.

+*/

+/*! \def RAPIDJSON_VERSION_STRING

+    \ingroup RAPIDJSON_CONFIG

+    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.

+*/

+#define RAPIDJSON_MAJOR_VERSION 1

+#define RAPIDJSON_MINOR_VERSION 0

+#define RAPIDJSON_PATCH_VERSION 2

+#define RAPIDJSON_VERSION_STRING \

+    RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)

+

+///////////////////////////////////////////////////////////////////////////////

+// RAPIDJSON_NAMESPACE_(BEGIN|END)

+/*! \def RAPIDJSON_NAMESPACE

+    \ingroup RAPIDJSON_CONFIG

+    \brief   provide custom rapidjson namespace

+

+    In order to avoid symbol clashes and/or "One Definition Rule" errors

+    between multiple inclusions of (different versions of) RapidJSON in

+    a single binary, users can customize the name of the main RapidJSON

+    namespace.

+

+    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE

+    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple

+    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref

+    RAPIDJSON_NAMESPACE_END need to be defined as well:

+

+    \code

+    // in some .cpp file

+    #define RAPIDJSON_NAMESPACE my::rapidjson

+    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {

+    #define RAPIDJSON_NAMESPACE_END   } }

+    #include "rapidjson/..."

+    \endcode

+

+    \see rapidjson

+ */

+/*! \def RAPIDJSON_NAMESPACE_BEGIN

+    \ingroup RAPIDJSON_CONFIG

+    \brief   provide custom rapidjson namespace (opening expression)

+    \see RAPIDJSON_NAMESPACE

+*/

+/*! \def RAPIDJSON_NAMESPACE_END

+    \ingroup RAPIDJSON_CONFIG

+    \brief   provide custom rapidjson namespace (closing expression)

+    \see RAPIDJSON_NAMESPACE

+*/

+#ifndef RAPIDJSON_NAMESPACE

+#define RAPIDJSON_NAMESPACE rapidjson

+#endif

+#ifndef RAPIDJSON_NAMESPACE_BEGIN

+#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {

+#endif

+#ifndef RAPIDJSON_NAMESPACE_END

+#define RAPIDJSON_NAMESPACE_END }

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+// RAPIDJSON_HAS_STDSTRING

+

+#ifndef RAPIDJSON_HAS_STDSTRING

+#ifdef RAPIDJSON_DOXYGEN_RUNNING

+#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation

+#else

+#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default

+#endif

+/*! \def RAPIDJSON_HAS_STDSTRING

+    \ingroup RAPIDJSON_CONFIG

+    \brief Enable RapidJSON support for \c std::string

+

+    By defining this preprocessor symbol to \c 1, several convenience functions for using

+    \ref rapidjson::GenericValue with \c std::string are enabled, especially

+    for construction and comparison.

+

+    \hideinitializer

+*/

+#endif // !defined(RAPIDJSON_HAS_STDSTRING)

+

+#if RAPIDJSON_HAS_STDSTRING

+#include <string>

+#endif // RAPIDJSON_HAS_STDSTRING

+

+///////////////////////////////////////////////////////////////////////////////

 // RAPIDJSON_NO_INT64DEFINE

 

 /*! \def RAPIDJSON_NO_INT64DEFINE

@@ -82,9 +178,9 @@
 

 #ifndef RAPIDJSON_FORCEINLINE

 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN

-#ifdef _MSC_VER

+#if defined(_MSC_VER) && !defined(NDEBUG)

 #define RAPIDJSON_FORCEINLINE __forceinline

-#elif defined(__GNUC__) && __GNUC__ >= 4

+#elif defined(__GNUC__) && __GNUC__ >= 4 && !defined(NDEBUG)

 #define RAPIDJSON_FORCEINLINE __attribute__((always_inline))

 #else

 #define RAPIDJSON_FORCEINLINE

@@ -140,6 +236,8 @@
 #    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN

 #  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)

 #    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN

+#  elif defined(_MSC_VER) && defined(_M_ARM)

+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN

 #  elif defined(RAPIDJSON_DOXYGEN_RUNNING)

 #    define RAPIDJSON_ENDIAN

 #  else

@@ -152,7 +250,7 @@
 

 //! Whether using 64-bit architecture

 #ifndef RAPIDJSON_64BIT

-#if defined(__LP64__) || defined(_WIN64)

+#if defined(__LP64__) || defined(_WIN64) || defined(__EMSCRIPTEN__)

 #define RAPIDJSON_64BIT 1

 #else

 #define RAPIDJSON_64BIT 0

@@ -167,10 +265,14 @@
     \param x pointer to align

 

     Some machines require strict data alignment. Currently the default uses 4 bytes

-    alignment. User can customize by defining the RAPIDJSON_ALIGN function macro.,

+    alignment. User can customize by defining the RAPIDJSON_ALIGN function macro.

 */

 #ifndef RAPIDJSON_ALIGN

-#define RAPIDJSON_ALIGN(x) ((x + 3u) & ~3u)

+#if RAPIDJSON_64BIT == 1

+#define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))

+#else

+#define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)

+#endif

 #endif

 

 ///////////////////////////////////////////////////////////////////////////////

@@ -238,20 +340,20 @@
 #ifdef RAPIDJSON_DOXYGEN_RUNNING

 #define RAPIDJSON_NO_SIZETYPEDEFINE

 #endif

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 //! Size type (for string lengths, array sizes, etc.)

 /*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,

     instead of using \c size_t. Users may override the SizeType by defining

     \ref RAPIDJSON_NO_SIZETYPEDEFINE.

 */

 typedef unsigned SizeType;

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 #endif

 

 // always import std::size_t to rapidjson namespace

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 using std::size_t;

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 ///////////////////////////////////////////////////////////////////////////////

 // RAPIDJSON_ASSERT

@@ -274,13 +376,14 @@ using std::size_t;
 

 // Adopt from boost

 #ifndef RAPIDJSON_STATIC_ASSERT

+#ifndef __clang__

 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN

-namespace rapidjson {

-

+#endif

+RAPIDJSON_NAMESPACE_BEGIN

 template <bool x> struct STATIC_ASSERTION_FAILURE;

 template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };

 template<int x> struct StaticAssertTest {};

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)

 #define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)

@@ -291,15 +394,18 @@ template<int x> struct StaticAssertTest {};
 #else

 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 

 #endif

+#ifndef __clang__

 //!@endcond

+#endif

 

 /*! \def RAPIDJSON_STATIC_ASSERT

     \brief (Internal) macro to check for conditions at compile-time

     \param x compile-time condition

     \hideinitializer

  */

-#define RAPIDJSON_STATIC_ASSERT(x) typedef ::rapidjson::StaticAssertTest<\

-    sizeof(::rapidjson::STATIC_ASSERTION_FAILURE<bool(x) >)>\

+#define RAPIDJSON_STATIC_ASSERT(x) \

+    typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \

+      sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \

     RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE

 #endif

 

@@ -316,10 +422,6 @@ template<int x> struct StaticAssertTest {};
 #define RAPIDJSON_VERSION_CODE(x,y,z) \

   (((x)*100000) + ((y)*100) + (z))

 

-// token stringification

-#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)

-#define RAPIDJSON_DO_STRINGIFY(x) #x

-

 ///////////////////////////////////////////////////////////////////////////////

 // RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF

 

@@ -367,7 +469,8 @@ template<int x> struct StaticAssertTest {};
 

 #ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS

 #if defined(__clang__)

-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS __has_feature(cxx_rvalue_references)

+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS __has_feature(cxx_rvalue_references) && \

+    (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)

 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \

       (defined(_MSC_VER) && _MSC_VER >= 1600)

 

@@ -401,13 +504,28 @@ template<int x> struct StaticAssertTest {};
 //!@endcond

 

 ///////////////////////////////////////////////////////////////////////////////

+// new/delete

+

+#ifndef RAPIDJSON_NEW

+///! customization point for global \c new

+#define RAPIDJSON_NEW(x) new x

+#endif

+#ifndef RAPIDJSON_DELETE

+///! customization point for global \c delete

+#define RAPIDJSON_DELETE(x) delete x

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

 // Allocators and Encodings

 

 #include "allocators.h"

 #include "encodings.h"

 

-//! main RapidJSON namespace

-namespace rapidjson {

+/*! \namespace rapidjson

+    \brief main RapidJSON namespace

+    \see RAPIDJSON_NAMESPACE

+*/

+RAPIDJSON_NAMESPACE_BEGIN

 

 ///////////////////////////////////////////////////////////////////////////////

 //  Stream

@@ -562,6 +680,6 @@ enum Type {
     kNumberType = 6     //!< number

 };

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_RAPIDJSON_H_

diff --git a/external/rapidjson/reader.h b/external/rapidjson/reader.h
index f41ba2fd7..8628b53fa 100644
--- a/external/rapidjson/reader.h
+++ b/external/rapidjson/reader.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_READER_H_

 #define RAPIDJSON_READER_H_

@@ -26,8 +20,8 @@
 #include "rapidjson.h"

 #include "encodings.h"

 #include "internal/meta.h"

-#include "internal/pow10.h"

 #include "internal/stack.h"

+#include "internal/strtod.h"

 

 #if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)

 #include <intrin.h>

@@ -45,6 +39,17 @@ RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
 RAPIDJSON_DIAG_OFF(4702)  // unreachable code

 #endif

 

+#ifdef __clang__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(padded)

+RAPIDJSON_DIAG_OFF(switch-enum)

+#endif

+

+#ifdef __GNUC__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(effc++)

+#endif

+

 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN

 #define RAPIDJSON_NOTHING /* deliberately empty */

 #ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN

@@ -116,20 +121,33 @@ RAPIDJSON_DIAG_OFF(4702)  // unreachable code
 

 #include "error/error.h" // ParseErrorCode, ParseResult

 

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 

 ///////////////////////////////////////////////////////////////////////////////

 // ParseFlag

 

+/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS 

+    \ingroup RAPIDJSON_CONFIG

+    \brief User-defined kParseDefaultFlags definition.

+

+    User can define this as any \c ParseFlag combinations.

+*/

+#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS

+#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags

+#endif

+

 //! Combination of parseFlags

 /*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream

  */

 enum ParseFlag {

-    kParseDefaultFlags = 0,         //!< Default parse flags. Non-destructive parsing. Text strings are decoded into allocated buffer.

+    kParseNoFlags = 0,              //!< No flags are set.

     kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.

     kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.

     kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.

-    kParseStopWhenDoneFlag = 8      //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.

+    kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.

+    kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).

+    kParseCommentsFlag = 32,        //!< Allow one-line (//) and multi-line (/**/) comments.

+    kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS

 };

 

 ///////////////////////////////////////////////////////////////////////////////

@@ -244,27 +262,27 @@ void SkipWhitespace(InputStream& is) {
 #ifdef RAPIDJSON_SSE42

 //! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.

 inline const char *SkipWhitespace_SIMD(const char* p) {

-	// Fast return for single non-whitespace

-	if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

-		++p;

-	else

-		return p;

-

-	// 16-byte align to the next boundary

-	const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & ~15);

-	while (p != nextAligned)

-		if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

-			++p;

-		else

-			return p;

+    // Fast return for single non-whitespace

+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

+        ++p;

+    else

+        return p;

+

+    // 16-byte align to the next boundary

+    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));

+    while (p != nextAligned)

+        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

+            ++p;

+        else

+            return p;

 

     // The rest of string using SIMD

-	static const char whitespace[16] = " \n\r\t";

-	const __m128i w = _mm_loadu_si128((const __m128i *)&whitespace[0]);

+    static const char whitespace[16] = " \n\r\t";

+    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));

 

     for (;; p += 16) {

-        const __m128i s = _mm_load_si128((const __m128i *)p);

-        const unsigned r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));

+        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));

+        const int r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));

         if (r != 0) {   // some of characters is non-whitespace

 #ifdef _MSC_VER         // Find the index of first non-whitespace

             unsigned long offset;

@@ -281,39 +299,39 @@ inline const char *SkipWhitespace_SIMD(const char* p) {
 

 //! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.

 inline const char *SkipWhitespace_SIMD(const char* p) {

-	// Fast return for single non-whitespace

-	if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

-		++p;

-	else

-		return p;

+    // Fast return for single non-whitespace

+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

+        ++p;

+    else

+        return p;

 

     // 16-byte align to the next boundary

-	const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & ~15);

-	while (p != nextAligned)

-		if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

-			++p;

-		else

-			return p;

+    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));

+    while (p != nextAligned)

+        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')

+            ++p;

+        else

+            return p;

 

     // The rest of string

-	static const char whitespaces[4][17] = {

-		"                ",

-		"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",

-		"\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r",

-		"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"};

+    static const char whitespaces[4][17] = {

+        "                ",

+        "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",

+        "\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r",

+        "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"};

 

-		const __m128i w0 = _mm_loadu_si128((const __m128i *)&whitespaces[0][0]);

-		const __m128i w1 = _mm_loadu_si128((const __m128i *)&whitespaces[1][0]);

-		const __m128i w2 = _mm_loadu_si128((const __m128i *)&whitespaces[2][0]);

-		const __m128i w3 = _mm_loadu_si128((const __m128i *)&whitespaces[3][0]);

+        const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));

+        const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));

+        const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));

+        const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));

 

     for (;; p += 16) {

-        const __m128i s = _mm_load_si128((const __m128i *)p);

+        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));

         __m128i x = _mm_cmpeq_epi8(s, w0);

         x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));

         x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));

         x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));

-        unsigned short r = (unsigned short)~_mm_movemask_epi8(x);

+        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));

         if (r != 0) {   // some of characters may be non-whitespace

 #ifdef _MSC_VER         // Find the index of first non-whitespace

             unsigned long offset;

@@ -365,7 +383,7 @@ public:
     typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type

 

     //! Constructor.

-    /*! \param allocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)

+    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)

         \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)

     */

     GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}

@@ -387,7 +405,8 @@ public:
 

         ClearStackOnExit scope(*this);

 

-        SkipWhitespace(is);

+        SkipWhitespaceAndComments<parseFlags>(is);

+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

 

         if (is.Peek() == '\0') {

             RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());

@@ -398,7 +417,8 @@ public:
             RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

 

             if (!(parseFlags & kParseStopWhenDoneFlag)) {

-                SkipWhitespace(is);

+                SkipWhitespaceAndComments<parseFlags>(is);

+                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

 

                 if (is.Peek() != '\0') {

                     RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());

@@ -451,6 +471,40 @@ private:
         ClearStackOnExit& operator=(const ClearStackOnExit&);

     };

 

+    template<unsigned parseFlags, typename InputStream>

+    void SkipWhitespaceAndComments(InputStream& is) {

+        SkipWhitespace(is);

+

+        if (parseFlags & kParseCommentsFlag) {

+            while (is.Peek() == '/') {

+                is.Take();

+

+                if (is.Peek() == '*') {

+                    is.Take();

+                    while (true) {

+                        if (is.Peek() == '\0')

+                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());

+

+                        if (is.Take() == '*') {

+                            if (is.Peek() == '\0')

+                                RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());

+

+                            if (is.Take() == '/')

+                                break;

+                        }

+                    }

+                } else if (is.Peek() == '/') {

+                    is.Take();

+                    while (is.Peek() != '\0' && is.Take() != '\n') { }

+                } else {

+                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());

+                }

+

+                SkipWhitespace(is);

+            }

+        }

+    }

+

     // Parse object: { string : value, ... }

     template<unsigned parseFlags, typename InputStream, typename Handler>

     void ParseObject(InputStream& is, Handler& handler) {

@@ -460,7 +514,8 @@ private:
         if (!handler.StartObject())

             RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());

 

-        SkipWhitespace(is);

+        SkipWhitespaceAndComments<parseFlags>(is);

+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

         if (is.Peek() == '}') {

             is.Take();

@@ -476,28 +531,35 @@ private:
             ParseString<parseFlags>(is, handler, true);

             RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

-            SkipWhitespace(is);

+            SkipWhitespaceAndComments<parseFlags>(is);

+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

             if (is.Take() != ':')

                 RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());

 

-            SkipWhitespace(is);

+            SkipWhitespaceAndComments<parseFlags>(is);

+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

             ParseValue<parseFlags>(is, handler);

             RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

-            SkipWhitespace(is);

+            SkipWhitespaceAndComments<parseFlags>(is);

+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

             ++memberCount;

 

             switch (is.Take()) {

-                case ',': SkipWhitespace(is); break;

+                case ',':

+                    SkipWhitespaceAndComments<parseFlags>(is);

+                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

+                    break;

                 case '}': 

                     if (!handler.EndObject(memberCount))

                         RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());

-                    else

-                        return;

-                default:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());

+                    return;

+                default:  

+                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());

+                    break;

             }

         }

     }

@@ -511,7 +573,8 @@ private:
         if (!handler.StartArray())

             RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());

         

-        SkipWhitespace(is);

+        SkipWhitespaceAndComments<parseFlags>(is);

+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

         if (is.Peek() == ']') {

             is.Take();

@@ -525,16 +588,21 @@ private:
             RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

             ++elementCount;

-            SkipWhitespace(is);

+            SkipWhitespaceAndComments<parseFlags>(is);

+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

 

             switch (is.Take()) {

-                case ',': SkipWhitespace(is); break;

+                case ',':

+                    SkipWhitespaceAndComments<parseFlags>(is);

+                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

+                    break;

                 case ']': 

                     if (!handler.EndArray(elementCount))

                         RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());

-                    else

-                        return;

-                default:  RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());

+                    return;

+                default:  

+                    RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());

+                    break;

             }

         }

     }

@@ -600,21 +668,27 @@ private:
         return codepoint;

     }

 

+    template <typename CharType>

     class StackStream {

     public:

-        typedef typename TargetEncoding::Ch Ch;

+        typedef CharType Ch;

 

         StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}

         RAPIDJSON_FORCEINLINE void Put(Ch c) {

             *stack_.template Push<Ch>() = c;

             ++length_;

         }

-        internal::Stack<StackAllocator>& stack_;

-        SizeType length_;

+        size_t Length() const { return length_; }

+        Ch* Pop() {

+            return stack_.template Pop<Ch>(length_);

+        }

 

     private:

         StackStream(const StackStream&);

         StackStream& operator=(const StackStream&);

+

+        internal::Stack<StackAllocator>& stack_;

+        SizeType length_;

     };

 

     // Parse string and generate String event. Different code paths for kParseInsituFlag.

@@ -630,15 +704,16 @@ private:
             RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

             size_t length = s.PutEnd(head) - 1;

             RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);

-            const typename TargetEncoding::Ch* const str = (typename TargetEncoding::Ch*)head;

+            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);

             success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));

         }

         else {

-            StackStream stackStream(stack_);

+            StackStream<typename TargetEncoding::Ch> stackStream(stack_);

             ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);

             RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

-            const typename TargetEncoding::Ch* const str = stack_.template Pop<typename TargetEncoding::Ch>(stackStream.length_);

-            success = (isKey ? handler.Key(str, stackStream.length_ - 1, true) : handler.String(str, stackStream.length_ - 1, true));

+            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;

+            const typename TargetEncoding::Ch* const str = stackStream.Pop();

+            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));

         }

         if (!success)

             RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());

@@ -668,16 +743,17 @@ private:
             if (c == '\\') {    // Escape

                 is.Take();

                 Ch e = is.Take();

-                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && escape[(unsigned char)e]) {

-                    os.Put(escape[(unsigned char)e]);

-                }

+                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && escape[static_cast<unsigned char>(e)])

+                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));

                 else if (e == 'u') {    // Unicode

                     unsigned codepoint = ParseHex4(is);

+                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

                     if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {

                         // Handle UTF-16 surrogate pair

                         if (is.Take() != '\\' || is.Take() != 'u')

                             RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, is.Tell() - 2);

                         unsigned codepoint2 = ParseHex4(is);

+                        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

                         if (codepoint2 < 0xDC00 || codepoint2 > 0xDFFF)

                             RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, is.Tell() - 2);

                         codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;

@@ -694,7 +770,7 @@ private:
             }

             else if (c == '\0')

                 RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell() - 1);

-            else if ((unsigned)c < 0x20) // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF

+            else if (static_cast<unsigned>(c) < 0x20) // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF

                 RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell() - 1);

             else {

                 if (parseFlags & kParseValidateEncodingFlag ? 

@@ -705,22 +781,55 @@ private:
         }

     }

 

-    inline double StrtodFastPath(double significand, int exp) {

-        // Fast path only works on limited range of values.

-        // But for simplicity and performance, currently only implement this.

-        // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/

-        if (exp < -308)

-            return 0.0;

-        else if (exp >= 0)

-            return significand * internal::Pow10(exp);

-        else

-            return significand / internal::Pow10(-exp);

-    }

+    template<typename InputStream, bool backup>

+    class NumberStream;

+

+    template<typename InputStream>

+    class NumberStream<InputStream, false> {

+    public:

+        NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader;  }

+        ~NumberStream() {}

+

+        RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }

+        RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }

+        RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }

+        size_t Tell() { return is.Tell(); }

+        size_t Length() { return 0; }

+        const char* Pop() { return 0; }

+

+    protected:

+        NumberStream& operator=(const NumberStream&);

+

+        InputStream& is;

+    };

+

+    template<typename InputStream>

+    class NumberStream<InputStream, true> : public NumberStream<InputStream, false> {

+        typedef NumberStream<InputStream, false> Base;

+    public:

+        NumberStream(GenericReader& reader, InputStream& is) : NumberStream<InputStream, false>(reader, is), stackStream(reader.stack_) {}

+        ~NumberStream() {}

+

+        RAPIDJSON_FORCEINLINE Ch TakePush() {

+            stackStream.Put(static_cast<char>(Base::is.Peek()));

+            return Base::is.Take();

+        }

+

+        size_t Length() { return stackStream.Length(); }

+

+        const char* Pop() {

+            stackStream.Put('\0');

+            return stackStream.Pop();

+        }

+

+    private:

+        StackStream<char> stackStream;

+    };

 

     template<unsigned parseFlags, typename InputStream, typename Handler>

     void ParseNumber(InputStream& is, Handler& handler) {

         internal::StreamLocalCopy<InputStream> copy(is);

-        InputStream& s(copy.s);

+        NumberStream<InputStream, (parseFlags & kParseFullPrecisionFlag) != 0> s(*this, copy.s);

 

         // Parse minus

         bool minus = false;

@@ -733,12 +842,13 @@ private:
         unsigned i = 0;

         uint64_t i64 = 0;

         bool use64bit = false;

+        int significandDigit = 0;

         if (s.Peek() == '0') {

             i = 0;

-            s.Take();

+            s.TakePush();

         }

         else if (s.Peek() >= '1' && s.Peek() <= '9') {

-            i = static_cast<unsigned>(s.Take() - '0');

+            i = static_cast<unsigned>(s.TakePush() - '0');

 

             if (minus)

                 while (s.Peek() >= '0' && s.Peek() <= '9') {

@@ -749,7 +859,8 @@ private:
                             break;

                         }

                     }

-                    i = i * 10 + static_cast<unsigned>(s.Take() - '0');

+                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');

+                    significandDigit++;

                 }

             else

                 while (s.Peek() >= '0' && s.Peek() <= '9') {

@@ -760,35 +871,38 @@ private:
                             break;

                         }

                     }

-                    i = i * 10 + static_cast<unsigned>(s.Take() - '0');

+                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');

+                    significandDigit++;

                 }

         }

         else

             RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());

 

         // Parse 64bit int

-        double d = 0.0;

         bool useDouble = false;

+        double d = 0.0;

         if (use64bit) {

             if (minus) 

                 while (s.Peek() >= '0' && s.Peek() <= '9') {                    

                      if (i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC)) // 2^63 = 9223372036854775808

                         if (i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8') {

-                            d = (double)i64;

+                            d = i64;

                             useDouble = true;

                             break;

                         }

-                    i64 = i64 * 10 + static_cast<unsigned>(s.Take() - '0');

+                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');

+                    significandDigit++;

                 }

             else

                 while (s.Peek() >= '0' && s.Peek() <= '9') {                    

                     if (i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999)) // 2^64 - 1 = 18446744073709551615

                         if (i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5') {

-                            d = (double)i64;

+                            d = i64;

                             useDouble = true;

                             break;

                         }

-                    i64 = i64 * 10 + static_cast<unsigned>(s.Take() - '0');

+                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');

+                    significandDigit++;

                 }

         }

 

@@ -797,53 +911,64 @@ private:
             while (s.Peek() >= '0' && s.Peek() <= '9') {

                 if (d >= 1.7976931348623157e307) // DBL_MAX / 10.0

                     RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());

-                d = d * 10 + (s.Take() - '0');

+                d = d * 10 + (s.TakePush() - '0');

             }

         }

 

         // Parse frac = decimal-point 1*DIGIT

         int expFrac = 0;

+        size_t decimalPosition;

         if (s.Peek() == '.') {

             s.Take();

+            decimalPosition = s.Length();

+

+            if (!(s.Peek() >= '0' && s.Peek() <= '9'))

+                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());

 

-#if RAPIDJSON_64BIT

-            // Use i64 to store significand in 64-bit architecture

             if (!useDouble) {

+#if RAPIDJSON_64BIT

+                // Use i64 to store significand in 64-bit architecture

                 if (!use64bit)

                     i64 = i;

         

                 while (s.Peek() >= '0' && s.Peek() <= '9') {

-                    if (i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))

+                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path

                         break;

                     else {

-                        i64 = i64 * 10 + static_cast<unsigned>(s.Take() - '0');

+                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');

                         --expFrac;

+                        if (i64 != 0)

+                            significandDigit++;

                     }

                 }

 

-                d = (double)i64;

-            }

+                d = static_cast<double>(i64);

 #else

-            // Use double to store significand in 32-bit architecture

-            if (!useDouble)

-                d = use64bit ? (double)i64 : (double)i;

+                // Use double to store significand in 32-bit architecture

+                d = static_cast<double>(use64bit ? i64 : i);

 #endif

-            useDouble = true;

+                useDouble = true;

+            }

 

             while (s.Peek() >= '0' && s.Peek() <= '9') {

-                d = d * 10 + (s.Take() - '0');

-                --expFrac;

+                if (significandDigit < 17) {

+                    d = d * 10.0 + (s.TakePush() - '0');

+                    --expFrac;

+                    if (d > 0.0)

+                        significandDigit++;

+                }

+                else

+                    s.TakePush();

             }

-

-            if (expFrac == 0)

-                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());

         }

+        else

+            decimalPosition = s.Length(); // decimal position at the end of integer.

 

         // Parse exp = e [ minus / plus ] 1*DIGIT

         int exp = 0;

         if (s.Peek() == 'e' || s.Peek() == 'E') {

             if (!useDouble) {

-                d = use64bit ? (double)i64 : (double)i;

+                d = use64bit ? i64 : i;

                 useDouble = true;

             }

             s.Take();

@@ -857,11 +982,23 @@ private:
             }

 

             if (s.Peek() >= '0' && s.Peek() <= '9') {

-                exp = s.Take() - '0';

-                while (s.Peek() >= '0' && s.Peek() <= '9') {

-                    exp = exp * 10 + (s.Take() - '0');

-                    if (exp > 308 && !expMinus) // exp > 308 should be rare, so it should be checked first.

-                        RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());

+                exp = static_cast<int>(s.Take() - '0');

+                if (expMinus) {

+                    while (s.Peek() >= '0' && s.Peek() <= '9') {

+                        exp = exp * 10 + static_cast<int>(s.Take() - '0');

+                        if (exp >= 214748364) {                         // Issue #313: prevent overflow exponent

+                            while (s.Peek() >= '0' && s.Peek() <= '9')  // Consume the rest of exponent

+                                s.Take();

+                        }

+                    }

+                }

+                else {  // positive exp

+                    int maxExp = 308 - expFrac;

+                    while (s.Peek() >= '0' && s.Peek() <= '9') {

+                        exp = exp * 10 + static_cast<int>(s.Take() - '0');

+                        if (exp > maxExp)

+                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());

+                    }

                 }

             }

             else

@@ -873,28 +1010,28 @@ private:
 

         // Finish parsing, call event according to the type of number.

         bool cont = true;

+        size_t length = s.Length();

+        const char* decimal = s.Pop();  // Pop stack no matter if it will be used or not.

+

         if (useDouble) {

-            int expSum = exp + expFrac;

-            if (expSum < -308) {

-                // Prevent expSum < -308, making Pow10(expSum) = 0

-                d = StrtodFastPath(d, exp);

-                d = StrtodFastPath(d, expFrac);

-            }

+            int p = exp + expFrac;

+            if (parseFlags & kParseFullPrecisionFlag)

+                d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);

             else

-                d = StrtodFastPath(d, expSum);

+                d = internal::StrtodNormalPrecision(d, p);

 

             cont = handler.Double(minus ? -d : d);

         }

         else {

             if (use64bit) {

                 if (minus)

-                    cont = handler.Int64(-(int64_t)i64);

+                    cont = handler.Int64(static_cast<int64_t>(~i64 + 1));

                 else

                     cont = handler.Uint64(i64);

             }

             else {

                 if (minus)

-                    cont = handler.Int(-(int)i);

+                    cont = handler.Int(static_cast<int32_t>(~i + 1));

                 else

                     cont = handler.Uint(i);

             }

@@ -913,7 +1050,10 @@ private:
             case '"': ParseString<parseFlags>(is, handler); break;

             case '{': ParseObject<parseFlags>(is, handler); break;

             case '[': ParseArray <parseFlags>(is, handler); break;

-            default : ParseNumber<parseFlags>(is, handler);

+            default : 

+                      ParseNumber<parseFlags>(is, handler);

+                      break;

+                      

         }

     }

 

@@ -940,11 +1080,11 @@ private:
         IterativeParsingArrayFinishState,

 

         // Single value state

-        IterativeParsingValueState,

-

-        cIterativeParsingStateCount

+        IterativeParsingValueState

     };

 

+    enum { cIterativeParsingStateCount = IterativeParsingValueState + 1 };

+

     // Tokens

     enum Token {

         LeftBracketToken = 0,

@@ -986,8 +1126,8 @@ private:
 #undef N16

 //!@endcond

         

-        if (sizeof(Ch) == 1 || unsigned(c) < 256)

-            return (Token)tokenMap[(unsigned char)c];

+        if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)

+            return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);

         else

             return NumberToken;

     }

@@ -1153,21 +1293,16 @@ private:
             }

         }; // End of G

 

-        return (IterativeParsingState)G[state][token];

+        return static_cast<IterativeParsingState>(G[state][token]);

     }

 

     // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().

     // May return a new state on state pop.

     template <unsigned parseFlags, typename InputStream, typename Handler>

     RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {

-        switch (dst) {

-        case IterativeParsingStartState:

-            RAPIDJSON_ASSERT(false);

-            return IterativeParsingErrorState;

-

-        case IterativeParsingFinishState:

-            return dst;

+        (void)token;

 

+        switch (dst) {

         case IterativeParsingErrorState:

             return dst;

 

@@ -1206,12 +1341,9 @@ private:
                 return dst;

 

         case IterativeParsingKeyValueDelimiterState:

-            if (token == ColonToken) {

-                is.Take();

-                return dst;

-            }

-            else

-                return IterativeParsingErrorState;

+            RAPIDJSON_ASSERT(token == ColonToken);

+            is.Take();

+            return dst;

 

         case IterativeParsingMemberValueState:

             // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.

@@ -1286,17 +1418,25 @@ private:
             }

         }

 

-        case IterativeParsingValueState:

+        default:

+            // This branch is for IterativeParsingValueState actually.

+            // Use `default:` rather than

+            // `case IterativeParsingValueState:` is for code coverage.

+

+            // The IterativeParsingStartState is not enumerated in this switch-case.

+            // It is impossible for that case. And it can be caught by following assertion.

+

+            // The IterativeParsingFinishState is not enumerated in this switch-case either.

+            // It is a "derivative" state which cannot triggered from Predict() directly.

+            // Therefore it cannot happen here. And it can be caught by following assertion.

+            RAPIDJSON_ASSERT(dst == IterativeParsingValueState);

+

             // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.

             ParseValue<parseFlags>(is, handler);

             if (HasParseError()) {

                 return IterativeParsingErrorState;

             }

             return IterativeParsingFinishState;

-

-        default:

-            RAPIDJSON_ASSERT(false);

-            return IterativeParsingErrorState;

         }

     }

 

@@ -1308,14 +1448,14 @@ private:
         }

         

         switch (src) {

-        case IterativeParsingStartState:            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell());

-        case IterativeParsingFinishState:           RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell());

+        case IterativeParsingStartState:            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return;

+        case IterativeParsingFinishState:           RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return;

         case IterativeParsingObjectInitialState:

-        case IterativeParsingMemberDelimiterState:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());

-        case IterativeParsingMemberKeyState:        RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());

-        case IterativeParsingMemberValueState:      RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());

-        case IterativeParsingElementState:          RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());

-        default:                                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());

+        case IterativeParsingMemberDelimiterState:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return;

+        case IterativeParsingMemberKeyState:        RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return;

+        case IterativeParsingMemberValueState:      RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return;

+        case IterativeParsingElementState:          RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return;

+        default:                                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell()); return;

         }       

     }

 

@@ -1325,7 +1465,8 @@ private:
         ClearStackOnExit scope(*this);

         IterativeParsingState state = IterativeParsingStartState;

 

-        SkipWhitespace(is);

+        SkipWhitespaceAndComments<parseFlags>(is);

+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

         while (is.Peek() != '\0') {

             Token t = Tokenize(is.Peek());

             IterativeParsingState n = Predict(state, t);

@@ -1342,7 +1483,8 @@ private:
             if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)

                 break;

 

-            SkipWhitespace(is);

+            SkipWhitespaceAndComments<parseFlags>(is);

+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

         }

 

         // Handle the end of file.

@@ -1360,7 +1502,16 @@ private:
 //! Reader with UTF8 encoding and default allocator.

 typedef GenericReader<UTF8<>, UTF8<> > Reader;

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

+

+#ifdef __clang__

+RAPIDJSON_DIAG_POP

+#endif

+

+

+#ifdef __GNUC__

+RAPIDJSON_DIAG_POP

+#endif

 

 #ifdef _MSC_VER

 RAPIDJSON_DIAG_POP

diff --git a/external/rapidjson/stringbuffer.h b/external/rapidjson/stringbuffer.h
index 55124f117..e9be84909 100644
--- a/external/rapidjson/stringbuffer.h
+++ b/external/rapidjson/stringbuffer.h
@@ -1,30 +1,29 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_STRINGBUFFER_H_

 #define RAPIDJSON_STRINGBUFFER_H_

 

 #include "rapidjson.h"

+

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+#include <utility> // std::move

+#endif

+

 #include "internal/stack.h"

 

-namespace rapidjson {

+RAPIDJSON_NAMESPACE_BEGIN

 

 //! Represents an in-memory output stream.

 /*!

@@ -33,11 +32,21 @@ namespace rapidjson {
     \note implements Stream concept

 */

 template <typename Encoding, typename Allocator = CrtAllocator>

-struct GenericStringBuffer {

+class GenericStringBuffer {

+public:

     typedef typename Encoding::Ch Ch;

 

     GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}

 

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}

+    GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {

+        if (&rhs != this)

+            stack_ = std::move(rhs.stack_);

+        return *this;

+    }

+#endif

+

     void Put(Ch c) { *stack_.template Push<Ch>() = c; }

     void Flush() {}

 

@@ -63,6 +72,11 @@ struct GenericStringBuffer {
 

     static const size_t kDefaultCapacity = 256;

     mutable internal::Stack<Allocator> stack_;

+

+private:

+    // Prohibit copy constructor & assignment operator.

+    GenericStringBuffer(const GenericStringBuffer&);

+    GenericStringBuffer& operator=(const GenericStringBuffer&);

 };

 

 //! String buffer with UTF8 encoding

@@ -74,6 +88,6 @@ inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
     std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));

 }

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_STRINGBUFFER_H_

diff --git a/external/rapidjson/writer.h b/external/rapidjson/writer.h
index fb6601ef9..a45045613 100644
--- a/external/rapidjson/writer.h
+++ b/external/rapidjson/writer.h
@@ -1,22 +1,16 @@
-// Copyright (C) 2011 Milo Yip

+// Tencent is pleased to support the open source community by making RapidJSON available.

+// 

+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_WRITER_H_

 #define RAPIDJSON_WRITER_H_

@@ -34,7 +28,12 @@ RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant

 #endif

 

-namespace rapidjson {

+#ifdef __clang__

+RAPIDJSON_DIAG_PUSH

+RAPIDJSON_DIAG_OFF(padded)

+#endif

+

+RAPIDJSON_NAMESPACE_BEGIN

 

 //! JSON writer

 /*! Writer implements the concept Handler.

@@ -59,12 +58,14 @@ public:
 

     //! Constructor

     /*! \param os Output stream.

-        \param allocator User supplied allocator. If it is null, it will create a private one.

+        \param stackAllocator User supplied allocator. If it is null, it will create a private one.

         \param levelDepth Initial capacity of stack.

     */

+    explicit

     Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : 

         os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), hasRoot_(false) {}

 

+    explicit

     Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :

         os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), hasRoot_(false) {}

 

@@ -125,6 +126,12 @@ public:
         return WriteString(str, length);

     }

 

+#if RAPIDJSON_HAS_STDSTRING

+    bool String(const std::basic_string<Ch>& str) {

+        return String(str.data(), SizeType(str.size()));

+    }

+#endif

+

     bool StartObject() {

         Prefix(kObjectType);

         new (level_stack_.template Push<Level>()) Level(false);

@@ -199,7 +206,7 @@ protected:
         char buffer[11];

         const char* end = internal::i32toa(i, buffer);

         for (const char* p = buffer; p != end; ++p)

-            os_->Put(*p);

+            os_->Put(static_cast<typename TargetEncoding::Ch>(*p));

         return true;

     }

 

@@ -207,7 +214,7 @@ protected:
         char buffer[10];

         const char* end = internal::u32toa(u, buffer);

         for (const char* p = buffer; p != end; ++p)

-            os_->Put(*p);

+            os_->Put(static_cast<typename TargetEncoding::Ch>(*p));

         return true;

     }

 

@@ -215,7 +222,7 @@ protected:
         char buffer[21];

         const char* end = internal::i64toa(i64, buffer);

         for (const char* p = buffer; p != end; ++p)

-            os_->Put(*p);

+            os_->Put(static_cast<typename TargetEncoding::Ch>(*p));

         return true;

     }

 

@@ -223,7 +230,7 @@ protected:
         char buffer[20];

         char* end = internal::u64toa(u64, buffer);

         for (char* p = buffer; p != end; ++p)

-            os_->Put(*p);

+            os_->Put(static_cast<typename TargetEncoding::Ch>(*p));

         return true;

     }

 

@@ -231,12 +238,12 @@ protected:
         char buffer[25];

         char* end = internal::dtoa(d, buffer);

         for (char* p = buffer; p != end; ++p)

-            os_->Put(*p);

+            os_->Put(static_cast<typename TargetEncoding::Ch>(*p));

         return true;

     }

 

     bool WriteString(const Ch* str, SizeType length)  {

-        static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

+        static const typename TargetEncoding::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

         static const char escape[256] = {

 #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

             //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F

@@ -253,7 +260,7 @@ protected:
         GenericStringStream<SourceEncoding> is(str);

         while (is.Tell() < length) {

             const Ch c = is.Peek();

-            if (!TargetEncoding::supportUnicode && (unsigned)c >= 0x80) {

+            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {

                 // Unicode escaping

                 unsigned codepoint;

                 if (!SourceEncoding::Decode(is, &codepoint))

@@ -266,7 +273,8 @@ protected:
                     os_->Put(hexDigits[(codepoint >>  4) & 15]);

                     os_->Put(hexDigits[(codepoint      ) & 15]);

                 }

-                else if (codepoint >= 0x010000 && codepoint <= 0x10FFFF)    {

+                else {

+                    RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);

                     // Surrogate pair

                     unsigned s = codepoint - 0x010000;

                     unsigned lead = (s >> 10) + 0xD800;

@@ -282,22 +290,21 @@ protected:
                     os_->Put(hexDigits[(trail >>  4) & 15]);

                     os_->Put(hexDigits[(trail      ) & 15]);                    

                 }

-                else

-                    return false;   // invalid code point

             }

-            else if ((sizeof(Ch) == 1 || (unsigned)c < 256) && escape[(unsigned char)c])  {

+            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && escape[static_cast<unsigned char>(c)])  {

                 is.Take();

                 os_->Put('\\');

-                os_->Put(escape[(unsigned char)c]);

-                if (escape[(unsigned char)c] == 'u') {

+                os_->Put(static_cast<typename TargetEncoding::Ch>(escape[static_cast<unsigned char>(c)]));

+                if (escape[static_cast<unsigned char>(c)] == 'u') {

                     os_->Put('0');

                     os_->Put('0');

-                    os_->Put(hexDigits[(unsigned char)c >> 4]);

-                    os_->Put(hexDigits[(unsigned char)c & 0xF]);

+                    os_->Put(hexDigits[static_cast<unsigned char>(c) >> 4]);

+                    os_->Put(hexDigits[static_cast<unsigned char>(c) & 0xF]);

                 }

             }

             else

-                Transcoder<SourceEncoding, TargetEncoding>::Transcode(is, *os_);

+                if (!Transcoder<SourceEncoding, TargetEncoding>::Transcode(is, *os_))

+                    return false;

         }

         os_->Put('\"');

         return true;

@@ -344,7 +351,7 @@ template<>
 inline bool Writer<StringBuffer>::WriteInt(int i) {

     char *buffer = os_->Push(11);

     const char* end = internal::i32toa(i, buffer);

-    os_->Pop(11 - (end - buffer));

+    os_->Pop(static_cast<size_t>(11 - (end - buffer)));

     return true;

 }

 

@@ -352,7 +359,7 @@ template<>
 inline bool Writer<StringBuffer>::WriteUint(unsigned u) {

     char *buffer = os_->Push(10);

     const char* end = internal::u32toa(u, buffer);

-    os_->Pop(10 - (end - buffer));

+    os_->Pop(static_cast<size_t>(10 - (end - buffer)));

     return true;

 }

 

@@ -360,7 +367,7 @@ template<>
 inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {

     char *buffer = os_->Push(21);

     const char* end = internal::i64toa(i64, buffer);

-    os_->Pop(21 - (end - buffer));

+    os_->Pop(static_cast<size_t>(21 - (end - buffer)));

     return true;

 }

 

@@ -368,7 +375,7 @@ template<>
 inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {

     char *buffer = os_->Push(20);

     const char* end = internal::u64toa(u, buffer);

-    os_->Pop(20 - (end - buffer));

+    os_->Pop(static_cast<size_t>(20 - (end - buffer)));

     return true;

 }

 

@@ -376,14 +383,18 @@ template<>
 inline bool Writer<StringBuffer>::WriteDouble(double d) {

     char *buffer = os_->Push(25);

     char* end = internal::dtoa(d, buffer);

-    os_->Pop(25 - (end - buffer));

+    os_->Pop(static_cast<size_t>(25 - (end - buffer)));

     return true;

 }

 

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #ifdef _MSC_VER

 RAPIDJSON_DIAG_POP

 #endif

 

+#ifdef __clang__

+RAPIDJSON_DIAG_POP

+#endif

+

 #endif // RAPIDJSON_RAPIDJSON_H_

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 123637a6f..cfa33b283 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -894,7 +894,7 @@ void wallet2::load_keys(const std::string& keys_file_name, const std::string& pa
 
   // The contents should be JSON if the wallet follows the new format.
   rapidjson::Document json;
-  if (json.Parse(account_data.c_str(), keys_file_data.account_data.size()).HasParseError())
+  if (json.Parse(account_data.c_str()).HasParseError())
   {
     is_old_file_format = true;
     m_watch_only = false;
@@ -972,7 +972,7 @@ bool wallet2::verify_password(const std::string& password) const
 
   // The contents should be JSON if the wallet follows the new format.
   rapidjson::Document json;
-  if (json.Parse(account_data.c_str(), keys_file_data.account_data.size()).HasParseError())
+  if (json.Parse(account_data.c_str()).HasParseError())
   {
     // old format before JSON wallet key file format
   }