document.h

Go to the documentation of this file.

#ifndef RAPIDJSON_DOCUMENT_H_
#define RAPIDJSON_DOCUMENT_H_
 
#include "reader.h"
#include "internal/strfunc.h"
#include <new>      // placement new
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
 
namespace rapidjson {
 
// GenericValue
 
 
#pragma pack (push, 4)
template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
class GenericValue {
public:
    struct Member {
        GenericValue<Encoding, Allocator> name;     
        GenericValue<Encoding, Allocator> value;    
    };
 
    typedef Encoding EncodingType;                  
    typedef Allocator AllocatorType;                
    typedef typename Encoding::Ch Ch;               
    typedef Member* MemberIterator;                 
    typedef const Member* ConstMemberIterator;      
    typedef GenericValue* ValueIterator;            
    typedef const GenericValue* ConstValueIterator; 
 
 
 
    GenericValue() : flags_(kNull_Flag) {}
 
private:
    GenericValue(const GenericValue& rhs);
 
public:
 
 
    GenericValue(Type type) {
        static const unsigned defaultFlags[7] = {
            kNull_Flag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kConstStringFlag,
            kNumberFlag | kIntFlag | kUintFlag | kInt64Flag | kUint64Flag | kDoubleFlag
        };
        RAPIDJSON_ASSERT(type <= kNumberType);
        flags_ = defaultFlags[type];
        memset(&data_, 0, sizeof(data_));
    }
 
    GenericValue(bool b) : flags_(b ? kTrueFlag : kFalseFlag) {}
 
    GenericValue(int i) : flags_(kNumberIntFlag) {
        data_.n.i64 = i;
        if (i >= 0)
            flags_ |= kUintFlag | kUint64Flag;
    }
 
    GenericValue(unsigned u) : flags_(kNumberUintFlag) {
        data_.n.u64 = u;
        if (!(u & 0x80000000))
            flags_ |= kIntFlag | kInt64Flag;
    }
 
    GenericValue(int64_t i64) : flags_(kNumberInt64Flag) {
        data_.n.i64 = i64;
        if (i64 >= 0) {
            flags_ |= kNumberUint64Flag;
            if (!(i64 & 0xFFFFFFFF00000000LL))
                flags_ |= kUintFlag;
            if (!(i64 & 0xFFFFFFFF80000000LL))
                flags_ |= kIntFlag;
        }
        else if (i64 >= -2147483648LL)
            flags_ |= kIntFlag;
    }
 
    GenericValue(uint64_t u64) : flags_(kNumberUint64Flag) {
        data_.n.u64 = u64;
        if (!(u64 & 0x8000000000000000ULL))
            flags_ |= kInt64Flag;
        if (!(u64 & 0xFFFFFFFF00000000ULL))
            flags_ |= kUintFlag;
        if (!(u64 & 0xFFFFFFFF80000000ULL))
            flags_ |= kIntFlag;
    }
 
    GenericValue(double d) : flags_(kNumberDoubleFlag) { data_.n.d = d; }
 
    GenericValue(const Ch* s, SizeType length) {
        RAPIDJSON_ASSERT(s != NULL);
        flags_ = kConstStringFlag;
        data_.s.str = s;
        data_.s.length = length;
    }
 
    GenericValue(const Ch* s) { SetStringRaw(s, internal::StrLen(s)); }
 
    GenericValue(const Ch* s, SizeType length, Allocator& allocator) { SetStringRaw(s, length, allocator); }
 
    GenericValue(const Ch*s, Allocator& allocator) { SetStringRaw(s, internal::StrLen(s), allocator); }
 
 
    ~GenericValue() {
        if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
            switch(flags_) {
            case kArrayFlag:
                for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
                    v->~GenericValue();
                Allocator::Free(data_.a.elements);
                break;
 
            case kObjectFlag:
                for (Member* m = data_.o.members; m != data_.o.members + data_.o.size; ++m) {
                    m->name.~GenericValue();
                    m->value.~GenericValue();
                }
                Allocator::Free(data_.o.members);
                break;
 
            case kCopyStringFlag:
                Allocator::Free(const_cast<Ch*>(data_.s.str));
                break;
            }
        }
    }
 
 
 
 
 
    GenericValue& operator=(GenericValue& rhs) {
        RAPIDJSON_ASSERT(this != &rhs);
        this->~GenericValue();
        memcpy(this, &rhs, sizeof(GenericValue));
        rhs.flags_ = kNull_Flag;
        return *this;
    }
 
 
    template <typename T>
    GenericValue& operator=(T value) {
        this->~GenericValue();
        new (this) GenericValue(value);
        return *this;
    }
 
 
 
    Type GetType()  const { return static_cast<Type>(flags_ & kTypeMask); }
    bool IsNull_()  const { return flags_ == kNull_Flag; }
    bool IsFalse()  const { return flags_ == kFalseFlag; }
    bool IsTrue()   const { return flags_ == kTrueFlag; }
    bool IsBool_()  const { return (flags_ & kBool_Flag) != 0; }
    bool IsObject() const { return flags_ == kObjectFlag; }
    bool IsArray()  const { return flags_ == kArrayFlag; }
    bool IsNumber() const { return (flags_ & kNumberFlag) != 0; }
    bool IsInt()    const { return (flags_ & kIntFlag) != 0; }
    bool IsUint()   const { return (flags_ & kUintFlag) != 0; }
    bool IsInt64()  const { return (flags_ & kInt64Flag) != 0; }
    bool IsUint64() const { return (flags_ & kUint64Flag) != 0; }
    bool IsDouble() const { return (flags_ & kDoubleFlag) != 0; }
    bool IsString() const { return (flags_ & kStringFlag) != 0; }
 
 
 
 
    GenericValue& SetNull_() { this->~GenericValue(); new (this) GenericValue(); return *this; }
 
 
 
 
    bool GetBool_() const { RAPIDJSON_ASSERT(IsBool_()); return flags_ == kTrueFlag; }
    GenericValue& SetBool_(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }
 
 
 
 
    GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }
 
    GenericValue& operator[](const Ch* name) {
        if (Member* member = FindMember(name))
            return member->value;
        else {
            static GenericValue Null_Value;
            return Null_Value;
        }
    }
    const GenericValue& operator[](const Ch* name) const { return const_cast<GenericValue&>(*this)[name]; }
 
    ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.members; }
    ConstMemberIterator MemberEnd() const   { RAPIDJSON_ASSERT(IsObject()); return data_.o.members + data_.o.size; }
    MemberIterator MemberBegin()            { RAPIDJSON_ASSERT(IsObject()); return data_.o.members; }
    MemberIterator MemberEnd()              { RAPIDJSON_ASSERT(IsObject()); return data_.o.members + data_.o.size; }
 
    bool HasMember(const Ch* name) const { return FindMember(name) != 0; }
 
 
    GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
        RAPIDJSON_ASSERT(IsObject());
        RAPIDJSON_ASSERT(name.IsString());
        Object& o = data_.o;
        if (o.size >= o.capacity) {
            if (o.capacity == 0) {
                o.capacity = kDefaultObjectCapacity;
                o.members = (Member*)allocator.Malloc(o.capacity * sizeof(Member));
            }
            else {
                SizeType oldCapacity = o.capacity;
                o.capacity *= 2;
                o.members = (Member*)allocator.Realloc(o.members, oldCapacity * sizeof(Member), o.capacity * sizeof(Member));
            }
        }
        o.members[o.size].name.RawAssign(name);
        o.members[o.size].value.RawAssign(value);
        o.size++;
        return *this;
    }
 
    GenericValue& AddMember(const Ch* name, Allocator& nameAllocator, GenericValue& value, Allocator& allocator) {
        GenericValue n(name, internal::StrLen(name), nameAllocator);
        return AddMember(n, value, allocator);
    }
 
    GenericValue& AddMember(const Ch* name, GenericValue& value, Allocator& allocator) {
        GenericValue n(name, internal::StrLen(name));
        return AddMember(n, value, allocator);
    }
 
    template <typename T>
    GenericValue& AddMember(const Ch* name, T value, Allocator& allocator) {
        GenericValue n(name, internal::StrLen(name));
        GenericValue v(value);
        return AddMember(n, v, allocator);
    }
 
 
    bool RemoveMember(const Ch* name) {
        RAPIDJSON_ASSERT(IsObject());
        if (Member* m = FindMember(name)) {
            RAPIDJSON_ASSERT(data_.o.size > 0);
            RAPIDJSON_ASSERT(data_.o.members != 0);
 
            Member* last = data_.o.members + (data_.o.size - 1);
            if (data_.o.size > 1 && m != last) {
                // Move the last one to this place
                m->name = last->name;
                m->value = last->value;
            }
            else {
                // Only one left, just destroy
                m->name.~GenericValue();
                m->value.~GenericValue();
            }
            --data_.o.size;
            return true;
        }
        return false;
    }
 
 
 
 
    GenericValue& SetArray() {  this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }
 
    SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }
 
    SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }
 
    bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }
 
 
    void Clear() {
        RAPIDJSON_ASSERT(IsArray());
        for (SizeType i = 0; i < data_.a.size; ++i)
            data_.a.elements[i].~GenericValue();
        data_.a.size = 0;
    }
 
 
    GenericValue& operator[](SizeType index) {
        RAPIDJSON_ASSERT(IsArray());
        RAPIDJSON_ASSERT(index < data_.a.size);
        return data_.a.elements[index];
    }
    const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }
 
    ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements; }
    ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements + data_.a.size; }
    ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }
    ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }
 
 
    GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {
        RAPIDJSON_ASSERT(IsArray());
        if (newCapacity > data_.a.capacity) {
            data_.a.elements = (GenericValue*)allocator.Realloc(data_.a.elements, data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue));
            data_.a.capacity = newCapacity;
        }
        return *this;
    }
 
 
    GenericValue& PushBack(GenericValue& value, Allocator& allocator) {
        RAPIDJSON_ASSERT(IsArray());
        if (data_.a.size >= data_.a.capacity)
            Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : data_.a.capacity * 2, allocator);
        data_.a.elements[data_.a.size++].RawAssign(value);
        return *this;
    }
 
    template <typename T>
    GenericValue& PushBack(T value, Allocator& allocator) {
        GenericValue v(value);
        return PushBack(v, allocator);
    }
 
    GenericValue& PopBack() {
        RAPIDJSON_ASSERT(IsArray());
        RAPIDJSON_ASSERT(!Empty());
        data_.a.elements[--data_.a.size].~GenericValue();
        return *this;
    }
 
 
 
    int GetInt() const          { RAPIDJSON_ASSERT(flags_ & kIntFlag);   return data_.n.i.i;   }
    unsigned GetUint() const    { RAPIDJSON_ASSERT(flags_ & kUintFlag);  return data_.n.u.u;   }
    int64_t GetInt64() const    { RAPIDJSON_ASSERT(flags_ & kInt64Flag); return data_.n.i64; }
    uint64_t GetUint64() const  { RAPIDJSON_ASSERT(flags_ & kUint64Flag); return data_.n.u64; }
 
    double GetDouble() const {
        RAPIDJSON_ASSERT(IsNumber());
        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)
    }
 
    GenericValue& SetInt(int i)             { this->~GenericValue(); new (this) GenericValue(i);    return *this; }
    GenericValue& SetUint(unsigned u)       { this->~GenericValue(); new (this) GenericValue(u);    return *this; }
    GenericValue& SetInt64(int64_t i64)     { this->~GenericValue(); new (this) GenericValue(i64);  return *this; }
    GenericValue& SetUint64(uint64_t u64)   { this->~GenericValue(); new (this) GenericValue(u64);  return *this; }
    GenericValue& SetDouble(double d)       { this->~GenericValue(); new (this) GenericValue(d);    return *this; }
 
 
 
 
    const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return data_.s.str; }
 
 
    SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return data_.s.length; }
 
 
    GenericValue& SetString(const Ch* s, SizeType length) { this->~GenericValue(); SetStringRaw(s, length); return *this; }
 
 
    GenericValue& SetString(const Ch* s) { return SetString(s, internal::StrLen(s)); }
 
 
    GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, length, allocator); return *this; }
 
 
    GenericValue& SetString(const Ch* s, Allocator& allocator) {    SetString(s, internal::StrLen(s), allocator); return *this; }
 
 
 
    template <typename Handler>
    const GenericValue& Accept(Handler& handler) const {
        switch(GetType()) {
        case kNull_Type:        handler.Null_(); break;
        case kFalseType:    handler.Bool_(false); break;
        case kTrueType:     handler.Bool_(true); break;
 
        case kObjectType:
            handler.StartObject();
            for (Member* m = data_.o.members; m != data_.o.members + data_.o.size; ++m) {
                handler.String(m->name.data_.s.str, m->name.data_.s.length, false);
                m->value.Accept(handler);
            }
            handler.EndObject(data_.o.size);
            break;
 
        case kArrayType:
            handler.StartArray();
            for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
                v->Accept(handler);
            handler.EndArray(data_.a.size);
            break;
 
        case kStringType:
            handler.String(data_.s.str, data_.s.length, false);
            break;
 
        case kNumberType:
            if (IsInt())            handler.Int(data_.n.i.i);
            else if (IsUint())      handler.Uint(data_.n.u.u);
            else if (IsInt64())     handler.Int64(data_.n.i64);
            else if (IsUint64())    handler.Uint64(data_.n.u64);
            else                    handler.Double(data_.n.d);
            break;
        }
        return *this;
    }
 
private:
    template <typename, typename>
    friend class GenericDocument;
 
    enum {
        kBool_Flag = 0x100,
        kNumberFlag = 0x200,
        kIntFlag = 0x400,
        kUintFlag = 0x800,
        kInt64Flag = 0x1000,
        kUint64Flag = 0x2000,
        kDoubleFlag = 0x4000,
        kStringFlag = 0x100000,
        kCopyFlag = 0x200000,
 
        // Initial flags of different types.
        kNull_Flag = kNull_Type,
        kTrueFlag = kTrueType | kBool_Flag,
        kFalseFlag = kFalseType | kBool_Flag,
        kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
        kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
        kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
        kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
        kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
        kConstStringFlag = kStringType | kStringFlag,
        kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
        kObjectFlag = kObjectType,
        kArrayFlag = kArrayType,
 
        kTypeMask = 0xFF    // bitwise-and with mask of 0xFF can be optimized by compiler
    };
 
    static const SizeType kDefaultArrayCapacity = 16;
    static const SizeType kDefaultObjectCapacity = 16;
 
    struct String {
        const Ch* str;
        SizeType length;
        unsigned hashcode;  
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
 
    // By using proper binary layout, retrieval of different integer types do not need conversions.
    union Number {
#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
        struct I {
            int i;
            char padding[4];
        }i;
        struct U {
            unsigned u;
            char padding2[4];
        }u;
#else
        struct I {
            char padding[4];
            int i;
        }i;
        struct U {
            char padding2[4];
            unsigned u;
        }u;
#endif
        int64_t i64;
        uint64_t u64;
        double d;
    };  // 8 bytes
 
    struct Object {
        Member* members;
        SizeType size;
        SizeType capacity;
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
 
    struct Array {
        GenericValue<Encoding, Allocator>* elements;
        SizeType size;
        SizeType capacity;
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
 
    union Data {
        String s;
        Number n;
        Object o;
        Array a;
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
 
    Member* FindMember(const Ch* name) {
        RAPIDJSON_ASSERT(name);
        RAPIDJSON_ASSERT(IsObject());
 
        SizeType length = internal::StrLen(name);
 
        Object& o = data_.o;
        for (Member* member = o.members; member != data_.o.members + data_.o.size; ++member)
            if (length == member->name.data_.s.length && memcmp(member->name.data_.s.str, name, length * sizeof(Ch)) == 0)
                return member;
 
        return 0;
    }
    const Member* FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
 
    // Initialize this value as array with initial data, without calling destructor.
    void SetArrayRaw(GenericValue* values, SizeType count, Allocator& alloctaor) {
        flags_ = kArrayFlag;
        data_.a.elements = (GenericValue*)alloctaor.Malloc(count * sizeof(GenericValue));
        memcpy(data_.a.elements, values, count * sizeof(GenericValue));
        data_.a.size = data_.a.capacity = count;
    }
 
    void SetObjectRaw(Member* members, SizeType count, Allocator& alloctaor) {
        flags_ = kObjectFlag;
        data_.o.members = (Member*)alloctaor.Malloc(count * sizeof(Member));
        memcpy(data_.o.members, members, count * sizeof(Member));
        data_.o.size = data_.o.capacity = count;
    }
 
    void SetStringRaw(const Ch* s, SizeType length) {
        RAPIDJSON_ASSERT(s != NULL);
        flags_ = kConstStringFlag;
        data_.s.str = s;
        data_.s.length = length;
    }
 
    void SetStringRaw(const Ch* s, SizeType length, Allocator& allocator) {
        RAPIDJSON_ASSERT(s != NULL);
        flags_ = kCopyStringFlag;
        data_.s.str = (Ch *)allocator.Malloc((length + 1) * sizeof(Ch));
        data_.s.length = length;
        memcpy(const_cast<Ch*>(data_.s.str), s, length * sizeof(Ch));
        const_cast<Ch*>(data_.s.str)[length] = '\0';
    }
 
    void RawAssign(GenericValue& rhs) {
        memcpy(this, &rhs, sizeof(GenericValue));
        rhs.flags_ = kNull_Flag;
    }
 
    Data data_;
    unsigned flags_;
};
#pragma pack (pop)
 
typedef GenericValue<UTF8<> > Value;
 
// GenericDocument
 
 
template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
class GenericDocument : public GenericValue<Encoding, Allocator> {
public:
    typedef typename Encoding::Ch Ch;                       
    typedef GenericValue<Encoding, Allocator> ValueType;    
    typedef Allocator AllocatorType;                        
 
 
    GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(allocator, stackCapacity), parseError_(0), errorOffset_(0) {}
 
 
    template <unsigned parseFlags, typename Stream>
    GenericDocument& ParseStream(Stream& stream) {
        ValueType::SetNull_(); // Remove existing root if exist
        GenericReader<Encoding, Allocator> reader;
        if (reader.template Parse<parseFlags>(stream, *this)) {
            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.
            parseError_ = 0;
            errorOffset_ = 0;
        }
        else {
            parseError_ = reader.GetParseError();
            errorOffset_ = reader.GetErrorOffset();
            ClearStack();
        }
        return *this;
    }
 
 
    template <unsigned parseFlags>
    GenericDocument& ParseInsitu(Ch* str) {
        GenericInsituStringStream<Encoding> s(str);
        return ParseStream<parseFlags | kParseInsituFlag>(s);
    }
 
 
    template <unsigned parseFlags>
    GenericDocument& Parse(const Ch* str) {
        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
        GenericStringStream<Encoding> s(str);
        return ParseStream<parseFlags>(s);
    }
 
    bool HasParseError() const { return parseError_ != 0; }
 
    const char* GetParseError() const { return parseError_; }
 
    size_t GetErrorOffset() const { return errorOffset_; }
 
    Allocator& GetAllocator() { return stack_.GetAllocator(); }
 
    size_t GetStackCapacity() const { return stack_.GetCapacity(); }
 
private:
    // Prohibit assignment
    GenericDocument& operator=(const GenericDocument&);
 
    friend class GenericReader<Encoding, Allocator>;    // for Reader to call the following private handler functions
 
    // Implementation of Handler
    void Null_()    { new (stack_.template Push<ValueType>()) ValueType(); }
    void Bool_(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); }
    void Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); }
    void Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); }
    void Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); }
    void Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); }
    void Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); }
 
    void String(const Ch* str, SizeType length, bool copy) {
        if (copy)
            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
        else
            new (stack_.template Push<ValueType>()) ValueType(str, length);
    }
 
    void StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); }
 
    void EndObject(SizeType memberCount) {
        typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
        stack_.template Top<ValueType>()->SetObjectRaw(members, (SizeType)memberCount, GetAllocator());
    }
 
    void StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); }
 
    void EndArray(SizeType elementCount) {
        ValueType* elements = stack_.template Pop<ValueType>(elementCount);
        stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
    }
 
    void ClearStack() {
        if (Allocator::kNeedFree)
            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
                (stack_.template Pop<ValueType>(1))->~ValueType();
        else
            stack_.Clear();
    }
 
    static const size_t kDefaultStackCapacity = 1024;
    internal::Stack<Allocator> stack_;
    const char* parseError_;
    size_t errorOffset_;
};
 
typedef GenericDocument<UTF8<> > Document;
 
} // namespace rapidjson
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif // RAPIDJSON_DOCUMENT_H_