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_