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_(kNullFlag) {}

private:
        GenericValue(const GenericValue& rhs);

public:


        GenericValue(Type type) {
                static const unsigned defaultFlags[7] = {
                        kNullFlag, 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_ = kNullFlag;
                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_ == kNullFlag; }
        bool IsFalse()  const { return flags_ == kFalseFlag; }
        bool IsTrue()   const { return flags_ == kTrueFlag; }
        bool IsBool()   const { return (flags_ & kBoolFlag) != 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 NullValue;
                        return NullValue;
                }
        }
        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 kNullType:         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 {
                kBoolFlag = 0x100,
                kNumberFlag = 0x200,
                kIntFlag = 0x400,
                kUintFlag = 0x800,
                kInt64Flag = 0x1000,
                kUint64Flag = 0x2000,
                kDoubleFlag = 0x4000,
                kStringFlag = 0x100000,
                kCopyFlag = 0x200000,

                // Initial flags of different types.
                kNullFlag = kNullType,
                kTrueFlag = kTrueType | kBoolFlag,
                kFalseFlag = kFalseType | kBoolFlag,
                kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
                kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
                kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
                kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
                kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
                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_ = kNullFlag;
        }

        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_