blame: source/code/Libs/include/cereal/external/rapidjson/document.h

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

#define CEREAL_RAPIDJSON_DOCUMENT_H_

/*! \file document.h */

#include "reader.h"

#include "internal/meta.h"

#include "internal/strfunc.h"

#include "memorystream.h"

#include "encodedstream.h"

#include <new>      // placement new

#include <limits>

CEREAL_RAPIDJSON_DIAG_PUSH

#ifdef __clang__

CEREAL_RAPIDJSON_DIAG_OFF(padded)

CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)

CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)

#elif defined(_MSC_VER)

CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant

CEREAL_RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data

#endif

#ifdef __GNUC__

CEREAL_RAPIDJSON_DIAG_OFF(effc++)

#endif // __GNUC__

#ifndef CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

#include <iterator> // std::random_access_iterator_tag

#endif

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS

#include <utility> // std::move

#endif

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

    But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.

    https://code.google.com/p/rapidjson/issues/detail?id=64

*/

template <typename Encoding, typename Allocator>

struct GenericMember {

    GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)

    GenericValue<Encoding, Allocator> value;    //!< value of member.

    // swap() for std::sort() and other potential use in STL.

    friend inline void swap(GenericMember& a, GenericMember& b) CEREAL_RAPIDJSON_NOEXCEPT {

        a.name.Swap(b.name);

        a.value.Swap(b.value);

    }

};

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

// GenericMemberIterator

#ifndef CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

//! (Constant) member iterator for a JSON object value

/*!

    \tparam Const Is this a constant iterator?

    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)

    \tparam Allocator   Allocator type for allocating memory of object, array and string.

    This class implements a Random Access Iterator for GenericMember elements

    of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements].

    \note This iterator implementation is mainly intended to avoid implicit

        conversions from iterator values to \c NULL,

        e.g. from GenericValue::FindMember.

    \note Define \c CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a

        pointer-based implementation, if your platform doesn't provide

        the C++ <iterator> header.

    \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator

 */

template <bool Const, typename Encoding, typename Allocator>

class GenericMemberIterator {

    friend class GenericValue<Encoding,Allocator>;

    template <bool, typename, typename> friend class GenericMemberIterator;

    typedef GenericMember<Encoding,Allocator> PlainType;

    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;

public:

    //! Iterator type itself

    typedef GenericMemberIterator Iterator;

    //! Constant iterator type

    typedef GenericMemberIterator<true,Encoding,Allocator>  ConstIterator;

    //! Non-constant iterator type

    typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;

    /** \name std::iterator_traits support */

    //@{

    typedef ValueType      value_type;

    typedef ValueType *    pointer;

    typedef ValueType &    reference;

    typedef std::ptrdiff_t difference_type;

    typedef std::random_access_iterator_tag iterator_category;

    //@}

    //! Pointer to (const) GenericMember

    typedef pointer         Pointer;

    //! Reference to (const) GenericMember

    typedef reference       Reference;

    //! Signed integer type (e.g. \c ptrdiff_t)

    typedef difference_type DifferenceType;

    //! Default constructor (singular value)

    /*! Creates an iterator pointing to no element.

        \note All operations, except for comparisons, are undefined on such values.

     */

    GenericMemberIterator() : ptr_() {}

    //! Iterator conversions to more const

    /*!

        \param it (Non-const) iterator to copy from

        Allows the creation of an iterator from another GenericMemberIterator

        that is "less const".  Especially, creating a non-constant iterator

        from a constant iterator are disabled:

        \li const -> non-const (not ok)

        \li const -> const (ok)

        \li non-const -> const (ok)

        \li non-const -> non-const (ok)

        \note If the \c Const template parameter is already \c false, this

            constructor effectively defines a regular copy-constructor.

            Otherwise, the copy constructor is implicitly defined.

    */

    GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}

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

    //! @name stepping

    //@{

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

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

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

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

    //@}

    //! @name increment/decrement

    //@{

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

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

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

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

    //@}

    //! @name relations

    //@{

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

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

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

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

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

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

    //@}

    //! @name dereference

    //@{

    Reference operator*() const { return *ptr_; }

    Pointer   operator->() const { return ptr_; }

    Reference operator[](DifferenceType n) const { return ptr_[n]; }

    //@}

    //! Distance

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

private:

    //! Internal constructor from plain pointer

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

    Pointer ptr_; //!< raw pointer

};

#else // CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

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

template <bool Const, typename Encoding, typename Allocator>

class GenericMemberIterator;

//! non-const GenericMemberIterator

template <typename Encoding, typename Allocator>

class GenericMemberIterator<false,Encoding,Allocator> {

    //! use plain pointer as iterator type

    typedef GenericMember<Encoding,Allocator>* Iterator;

};

//! const GenericMemberIterator

template <typename Encoding, typename Allocator>

class GenericMemberIterator<true,Encoding,Allocator> {

    //! use plain const pointer as iterator type

    typedef const GenericMember<Encoding,Allocator>* Iterator;

};

#endif // CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

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

// GenericStringRef

//! Reference to a constant string (not taking a copy)

/*!

    \tparam CharType character type of the string

    This helper class is used to automatically infer constant string

    references for string literals, especially from \c const \b (!)

    character arrays.

    The main use is for creating JSON string values without copying the

    source string via an \ref Allocator.  This requires that the referenced

    string pointers have a sufficient lifetime, which exceeds the lifetime

    of the associated GenericValue.

    \b Example

    \code

    Value v("foo");   // ok, no need to copy & calculate length

    const char foo[] = "foo";

    v.SetString(foo); // ok

    const char* bar = foo;

    // Value x(bar); // not ok, can't rely on bar's lifetime

    Value x(StringRef(bar)); // lifetime explicitly guaranteed by user

    Value y(StringRef(bar, 3));  // ok, explicitly pass length

    \endcode

    \see StringRef, GenericValue::SetString

*/

template<typename CharType>

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

        \ref StringRef(const CharType*) by inferring the string \ref length

        from the array length, and also supports strings containing null

        characters.

        \tparam N length of the string, automatically inferred

        \param str Constant character array, lifetime assumed to be longer

            than the use of the string in e.g. a GenericValue

        \post \ref s == str

        \note Constant complexity.

        \note There is a hidden, private overload to disallow references to

            non-const character arrays to be created via this constructor.

            By this, e.g. function-scope arrays used to be filled via

            \c snprintf are excluded from consideration.

            In such cases, the referenced string should be \b copied to the

            GenericValue instead.

     */

#endif

    template<SizeType N>

    GenericStringRef(const CharType (&str)[N]) CEREAL_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.

        \see StringRef(const CharType*)

        \param str Constant character pointer, lifetime assumed to be longer

            than the use of the string in e.g. a GenericValue

        \post \ref s == str

        \note There is a hidden, private overload to disallow references to

            non-const character arrays to be created via this constructor.

            By this, e.g. function-scope arrays used to be filled via

            \c snprintf are excluded from consideration.

            In such cases, the referenced string should be \b copied to the

            GenericValue instead.

     */

#endif

    explicit GenericStringRef(const CharType* str)

        : s(str), length(NotNullStrLen(str)) {}

    //! 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(CEREAL_RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { CEREAL_RAPIDJSON_ASSERT(str != 0 || len == 0u); }

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

    //! implicit conversion to plain CharType pointer

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

    const Ch* const s; //!< plain CharType pointer

    const SizeType length; //!< length of the string (excluding the trailing NULL terminator)

private:

    SizeType NotNullStrLen(const CharType* str) {

        CEREAL_RAPIDJSON_ASSERT(str != 0);

        return internal::StrLen(str);

    }

    /// Empty string - used when passing in a NULL pointer

    static const Ch emptyString[];

    //! Disallow construction from non-const array

    template<SizeType N>

    GenericStringRef(CharType (&str)[N]) /* = delete */;

    //! Copy assignment operator not permitted - immutable type

    GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */;

};

template<typename CharType>

const CharType GenericStringRef<CharType>::emptyString[] = { CharType() };

//! Mark a character pointer as constant string

/*! Mark a plain character pointer as a "string literal".  This function

    can be used to avoid copying a character string to be referenced as a

    value in a JSON GenericValue object, if the string's lifetime is known

    to be valid long enough.

    \tparam CharType Character type of the string

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

    \return GenericStringRef string reference object

    \relatesalso GenericStringRef

    \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember

*/

template<typename CharType>

inline GenericStringRef<CharType> StringRef(const CharType* str) {

    return GenericStringRef<CharType>(str);

}

//! Mark a character pointer as constant string

/*! Mark a plain character pointer as a "string literal".  This function

    can be used to avoid copying a character string to be referenced as a

    value in a JSON GenericValue object, if the string's lifetime is known

    to be valid long enough.

    This version has better performance with supplied length, and also

    supports string containing null characters.

    \tparam CharType character type of the string

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

    \param length The length of source string.

    \return GenericStringRef string reference object

    \relatesalso GenericStringRef

*/

template<typename CharType>

inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {

    return GenericStringRef<CharType>(str, SizeType(length));

}

#if CEREAL_RAPIDJSON_HAS_STDSTRING

//! Mark a string object as constant string

/*! Mark a string object (e.g. \c std::string) as a "string literal".

    This function can be used to avoid copying a string to be referenced as a

    value in a JSON GenericValue object, if the string's lifetime is known

    to be valid long enough.

    \tparam CharType character type of the string

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

    \return GenericStringRef string reference object

    \relatesalso GenericStringRef

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

*/

template<typename CharType>

inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) {

    return GenericStringRef<CharType>(str.data(), SizeType(str.size()));

}

#endif

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

// GenericValue type traits

namespace internal {

template <typename T, typename Encoding = void, typename Allocator = void>

struct IsGenericValueImpl : FalseType {};

// select candidates according to nested encoding and allocator types

template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type>

    : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {};

// helper to match arbitrary GenericValue instantiations, including derived classes

template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};

} // namespace internal

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

// TypeHelper

namespace internal {

template <typename ValueType, typename T>

struct TypeHelper {};

template<typename ValueType>

struct TypeHelper<ValueType, bool> {

    static bool Is(const ValueType& v) { return v.IsBool(); }

    static bool Get(const ValueType& v) { return v.GetBool(); }

    static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); }

    static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }

};

template<typename ValueType>

struct TypeHelper<ValueType, int> {

    static bool Is(const ValueType& v) { return v.IsInt(); }

    static int Get(const ValueType& v) { return v.GetInt(); }

    static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); }

    static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }

};

template<typename ValueType>

struct TypeHelper<ValueType, unsigned> {

    static bool Is(const ValueType& v) { return v.IsUint(); }

    static unsigned Get(const ValueType& v) { return v.GetUint(); }

    static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); }

    static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }

};

#ifdef _MSC_VER

CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));

template<typename ValueType>

struct TypeHelper<ValueType, long> {

    static bool Is(const ValueType& v) { return v.IsInt(); }

    static long Get(const ValueType& v) { return v.GetInt(); }

    static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }

    static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); }

};

CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));

template<typename ValueType>

struct TypeHelper<ValueType, unsigned long> {

    static bool Is(const ValueType& v) { return v.IsUint(); }

    static unsigned long Get(const ValueType& v) { return v.GetUint(); }

    static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }

    static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); }

};

#endif

template<typename ValueType>

struct TypeHelper<ValueType, int64_t> {

    static bool Is(const ValueType& v) { return v.IsInt64(); }

    static int64_t Get(const ValueType& v) { return v.GetInt64(); }

    static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); }

    static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }

};

template<typename ValueType>

struct TypeHelper<ValueType, uint64_t> {

    static bool Is(const ValueType& v) { return v.IsUint64(); }

    static uint64_t Get(const ValueType& v) { return v.GetUint64(); }

    static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); }

    static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }

};

template<typename ValueType>

struct TypeHelper<ValueType, double> {

    static bool Is(const ValueType& v) { return v.IsDouble(); }

    static double Get(const ValueType& v) { return v.GetDouble(); }

    static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); }

    static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }

};

template<typename ValueType>

struct TypeHelper<ValueType, float> {

    static bool Is(const ValueType& v) { return v.IsFloat(); }

    static float Get(const ValueType& v) { return v.GetFloat(); }

    static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); }

    static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }

};

template<typename ValueType>

struct TypeHelper<ValueType, const typename ValueType::Ch*> {

    typedef const typename ValueType::Ch* StringType;

    static bool Is(const ValueType& v) { return v.IsString(); }

    static StringType Get(const ValueType& v) { return v.GetString(); }

    static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); }

    static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }

};

#if CEREAL_RAPIDJSON_HAS_STDSTRING

template<typename ValueType>

struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {

    typedef std::basic_string<typename ValueType::Ch> StringType;

    static bool Is(const ValueType& v) { return v.IsString(); }

    static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); }

    static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }

};

#endif

template<typename ValueType>

struct TypeHelper<ValueType, typename ValueType::Array> {

    typedef typename ValueType::Array ArrayType;

    static bool Is(const ValueType& v) { return v.IsArray(); }

    static ArrayType Get(ValueType& v) { return v.GetArray(); }

    static ValueType& Set(ValueType& v, ArrayType data) { return v = data; }

    static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }

};

template<typename ValueType>

struct TypeHelper<ValueType, typename ValueType::ConstArray> {

    typedef typename ValueType::ConstArray ArrayType;

    static bool Is(const ValueType& v) { return v.IsArray(); }

    static ArrayType Get(const ValueType& v) { return v.GetArray(); }

};

template<typename ValueType>

struct TypeHelper<ValueType, typename ValueType::Object> {

    typedef typename ValueType::Object ObjectType;

    static bool Is(const ValueType& v) { return v.IsObject(); }

    static ObjectType Get(ValueType& v) { return v.GetObject(); }

    static ValueType& Set(ValueType& v, ObjectType data) { return v = data; }

    static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { return v = data; }

};

template<typename ValueType>

struct TypeHelper<ValueType, typename ValueType::ConstObject> {

    typedef typename ValueType::ConstObject ObjectType;

    static bool Is(const ValueType& v) { return v.IsObject(); }

    static ObjectType Get(const ValueType& v) { return v.GetObject(); }

};

} // namespace internal

// Forward declarations

template <bool, typename> class GenericArray;

template <bool, typename> class GenericObject;

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

// GenericValue

//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.

/*!

    A JSON value can be one of 7 types. This class is a variant type supporting

    these types.

    Use the Value if UTF8 and default allocator

    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)

    \tparam Allocator   Allocator type for allocating memory of object, array and string.

*/

template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >

class GenericValue {

public:

    //! Name-value pair in an object.

    typedef GenericMember<Encoding, Allocator> Member;

    typedef Encoding EncodingType;                  //!< Encoding type from template parameter.

    typedef Allocator AllocatorType;                //!< Allocator type from template parameter.

    typedef typename Encoding::Ch Ch;               //!< Character type derived from Encoding.

    typedef GenericStringRef<Ch> StringRefType;     //!< Reference to a constant string

    typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator;  //!< Member iterator for iterating in object.

    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.

    typedef GenericArray<false, ValueType> Array;

    typedef GenericArray<true, ValueType> ConstArray;

    typedef GenericObject<false, ValueType> Object;

    typedef GenericObject<true, ValueType> ConstObject;

    //!@name Constructors and destructor.

    //@{

    //! Default constructor creates a null value.

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

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS

    //! Move constructor in C++11

    GenericValue(GenericValue&& rhs) CEREAL_RAPIDJSON_NOEXCEPT : data_(rhs.data_) {

        rhs.data_.f.flags = kNullFlag; // give up contents

    }

#endif

private:

    //! Copy constructor is not permitted.

    GenericValue(const GenericValue& rhs);

#if CEREAL_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.

    /*! This creates a Value of specified type with default content.

        \param type Type of the value.

        \note Default content for number is zero.

    */

    explicit GenericValue(Type type) CEREAL_RAPIDJSON_NOEXCEPT : data_() {

        static const uint16_t defaultFlags[] = {

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

            kNumberAnyFlag

        };

        CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);

        data_.f.flags = defaultFlags[type];

        // Use ShortString to store empty string.

        if (type == kStringType)

            data_.ss.SetLength(0);

    }

    //! Explicit copy constructor (with allocator)

    /*! Creates a copy of a Value by using the given Allocator

        \tparam SourceAllocator allocator of \c rhs

        \param rhs Value to copy from (read-only)

        \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator().

        \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)

        \see CopyFrom()

    */

    template <typename SourceAllocator>

    GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {

        switch (rhs.GetType()) {

        case kObjectType: {

                SizeType count = rhs.data_.o.size;

                Member* lm = reinterpret_cast<Member*>(allocator.Malloc(count * sizeof(Member)));

                const typename GenericValue<Encoding,SourceAllocator>::Member* rm = rhs.GetMembersPointer();

                for (SizeType i = 0; i < count; i++) {

                    new (&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings);

                    new (&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings);

                }

                data_.f.flags = kObjectFlag;

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

                SetMembersPointer(lm);

            }

            break;

        case kArrayType: {

                SizeType count = rhs.data_.a.size;

                GenericValue* le = reinterpret_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));

                const GenericValue<Encoding,SourceAllocator>* re = rhs.GetElementsPointer();

                for (SizeType i = 0; i < count; i++)

                    new (&le[i]) GenericValue(re[i], allocator, copyConstStrings);

                data_.f.flags = kArrayFlag;

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

                SetElementsPointer(le);

            }

            break;

        case kStringType:

            if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {

                data_.f.flags = rhs.data_.f.flags;

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

            }

            else

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

            break;

        default:

            data_.f.flags = rhs.data_.f.flags;

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

            break;

        }

    }

    //! Constructor for boolean value.

    /*! \param b Boolean value

        \note This constructor is limited to \em real boolean values and rejects

            implicitly converted types like arbitrary pointers.  Use an explicit cast

            to \c bool, if you want to construct a boolean JSON value in such cases.

     */

#ifndef CEREAL_RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen

    template <typename T>

    explicit GenericValue(T b, CEREAL_RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) CEREAL_RAPIDJSON_NOEXCEPT  // See #472

#else

    explicit GenericValue(bool b) CEREAL_RAPIDJSON_NOEXCEPT

#endif

        : data_() {

            // safe-guard against failing SFINAE

            CEREAL_RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));

            data_.f.flags = b ? kTrueFlag : kFalseFlag;

    }

    //! Constructor for int value.

    explicit GenericValue(int i) CEREAL_RAPIDJSON_NOEXCEPT : data_() {

        data_.n.i64 = i;

        data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;

    }

    //! Constructor for unsigned value.

    explicit GenericValue(unsigned u) CEREAL_RAPIDJSON_NOEXCEPT : data_() {

        data_.n.u64 = u;

        data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);

    }

    //! Constructor for int64_t value.

    explicit GenericValue(int64_t i64) CEREAL_RAPIDJSON_NOEXCEPT : data_() {

        data_.n.i64 = i64;

        data_.f.flags = kNumberInt64Flag;

        if (i64 >= 0) {

            data_.f.flags |= kNumberUint64Flag;

            if (!(static_cast<uint64_t>(i64) & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))

                data_.f.flags |= kUintFlag;

            if (!(static_cast<uint64_t>(i64) & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))

                data_.f.flags |= kIntFlag;

        }

        else if (i64 >= static_cast<int64_t>(CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))

            data_.f.flags |= kIntFlag;

    }

    //! Constructor for uint64_t value.

    explicit GenericValue(uint64_t u64) CEREAL_RAPIDJSON_NOEXCEPT : data_() {

        data_.n.u64 = u64;

        data_.f.flags = kNumberUint64Flag;

        if (!(u64 & CEREAL_RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))

            data_.f.flags |= kInt64Flag;

        if (!(u64 & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))

            data_.f.flags |= kUintFlag;

        if (!(u64 & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))

            data_.f.flags |= kIntFlag;

    }

    //! Constructor for double value.

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

    //! Constructor for float value.

    explicit GenericValue(float f) CEREAL_RAPIDJSON_NOEXCEPT : data_() { data_.n.d = static_cast<double>(f); data_.f.flags = kNumberDoubleFlag; }

    //! Constructor for constant string (i.e. do not make a copy of string)

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

    //! Constructor for constant string (i.e. do not make a copy of string)

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

    //! Constructor for copy-string (i.e. do make a copy of string)

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

    //! Constructor for copy-string (i.e. do make a copy of string)

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

#if CEREAL_RAPIDJSON_HAS_STDSTRING

    //! Constructor for copy-string from a string object (i.e. do make a copy of string)

    /*! \note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.

     */

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

#endif

    //! Constructor for Array.

    /*!

        \param a An array obtained by \c GetArray().

        \note \c Array is always pass-by-value.

        \note the source array is moved into this value and the sourec array becomes empty.

    */

    GenericValue(Array a) CEREAL_RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {

        a.value_.data_ = Data();

        a.value_.data_.f.flags = kArrayFlag;

    }

    //! Constructor for Object.

    /*!

        \param o An object obtained by \c GetObject().

        \note \c Object is always pass-by-value.

        \note the source object is moved into this value and the sourec object becomes empty.

    */

    GenericValue(Object o) CEREAL_RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {

        o.value_.data_ = Data();

        o.value_.data_.f.flags = kObjectFlag;

    }

    //! Destructor.

    /*! Need to destruct elements of array, members of object, or copy-string.

    */

    ~GenericValue() {

        if (Allocator::kNeedFree) { // Shortcut by Allocator's trait

            switch(data_.f.flags) {

            case kArrayFlag:

                {

                    GenericValue* e = GetElementsPointer();

                    for (GenericValue* v = e; v != e + data_.a.size; ++v)

                        v->~GenericValue();

                    Allocator::Free(e);

                }

                break;

            case kObjectFlag:

                for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)

                    m->~Member();

                Allocator::Free(GetMembersPointer());

                break;

            case kCopyStringFlag:

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

                break;

            default:

                break;  // Do nothing for other types.

            }

        }

    }

    //@}

    //!@name Assignment operators

    //@{

    //! Assignment with move semantics.

    /*! \param rhs Source of the assignment. It will become a null value after assignment.

    */

    GenericValue& operator=(GenericValue& rhs) CEREAL_RAPIDJSON_NOEXCEPT {

        if (CEREAL_RAPIDJSON_LIKELY(this != &rhs)) {

            this->~GenericValue();

            RawAssign(rhs);

        }

        return *this;

    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS

    //! Move assignment in C++11

    GenericValue& operator=(GenericValue&& rhs) CEREAL_RAPIDJSON_NOEXCEPT {

        return *this = rhs.Move();

    }

#endif

    //! Assignment of constant string reference (no copy)

    /*! \param str Constant string reference to be assigned

        \note This overload is needed to avoid clashes with the generic primitive type assignment overload below.

        \see GenericStringRef, operator=(T)

    */

    GenericValue& operator=(StringRefType str) CEREAL_RAPIDJSON_NOEXCEPT {

        GenericValue s(str);

        return *this = s;

    }

    //! Assignment with primitive types.

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

        \param value The value to be assigned.

        \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 SetString(const Ch*, Allocator&) (for copying) or

            \ref StringRef() (to explicitly mark the pointer as constant) instead.

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

            use \ref SetBool() instead.

    */

    template <typename T>

    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&))

    operator=(T value) {

        GenericValue v(value);

        return *this = v;

    }

    //! Deep-copy assignment from Value

    /*! Assigns a \b copy of the Value to the current Value object

        \tparam SourceAllocator Allocator type of \c rhs

        \param rhs Value to copy from (read-only)

        \param allocator Allocator to use for copying

        \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)

     */

    template <typename SourceAllocator>

    GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {