1 #ifndef RAPIDJSON_DOCUMENT_H_
2 #define RAPIDJSON_DOCUMENT_H_
5 #include "internal/strfunc.h"
10 RAPIDJSON_DIAG_OFF(4127)
11 #elif defined(__GNUC__)
13 RAPIDJSON_DIAG_OFF(effc++)
16 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
17 #include "internal/meta.h"
24 template <
typename Encoding,
typename Allocator>
33 template <
typename Encoding,
typename Allocator>
39 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
60 template <
bool Const,
typename Encoding,
typename Allocator>
62 :
public std::iterator<std::random_access_iterator_tag
63 , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
70 typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
81 typedef typename BaseType::pointer
Pointer;
113 Iterator& operator++(){ ++ptr_;
return *
this; }
114 Iterator& operator--(){ --ptr_;
return *
this; }
130 bool operator==(
Iterator that)
const {
return ptr_ == that.ptr_; }
131 bool operator!=(
Iterator that)
const {
return ptr_ != that.ptr_; }
132 bool operator<=(
Iterator that)
const {
return ptr_ <= that.ptr_; }
133 bool operator>=(
Iterator that)
const {
return ptr_ >= that.ptr_; }
134 bool operator< (
Iterator that)
const {
return ptr_ < that.ptr_; }
135 bool operator> (
Iterator that)
const {
return ptr_ > that.ptr_; }
140 Reference operator*()
const {
return *ptr_; }
141 Pointer operator->()
const {
return ptr_; }
155 #else // RAPIDJSON_NOMEMBERITERATORCLASS
159 template <
bool Const,
typename Encoding,
typename Allocator>
160 struct GenericMemberIterator;
163 template <
typename Encoding,
typename Allocator>
164 struct GenericMemberIterator<false,Encoding,Allocator> {
166 typedef GenericMember<Encoding,Allocator>*
Iterator;
169 template <
typename Encoding,
typename Allocator>
170 struct GenericMemberIterator<true,Encoding,Allocator> {
172 typedef const GenericMember<Encoding,Allocator>*
Iterator;
175 #endif // RAPIDJSON_NOMEMBERITERATORCLASS
207 template<
typename CharType>
258 :
s(str),
length(internal::StrLen(str)){}
271 operator const Ch *()
const {
return s; }
296 template<
typename CharType>
316 template<
typename CharType>
334 #pragma pack (push, 4)
335 template <
typename Encoding,
typename Allocator = MemoryPoolAllocator<> >
342 typedef typename Encoding::Ch
Ch;
367 static const unsigned defaultFlags[7] = {
368 kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kConstStringFlag,
372 flags_ = defaultFlags[type];
382 template<
typename SourceAllocator >
391 #ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
392 template <
typename T>
393 explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<T,bool>)))
397 : data_(), flags_(b ? kTrueFlag : kFalseFlag) {}
403 flags_ |= kUintFlag | kUint64Flag;
409 if (!(u & 0x80000000))
410 flags_ |= kIntFlag | kInt64Flag;
414 explicit GenericValue(int64_t i64) : data_(), flags_(kNumberInt64Flag) {
417 flags_ |= kNumberUint64Flag;
418 if (!(static_cast<uint64_t>(i64) & UINT64_C(0xFFFFFFFF00000000)))
420 if (!(static_cast<uint64_t>(i64) & UINT64_C(0xFFFFFFFF80000000)))
423 else if (i64 >= INT64_C(-2147483648))
428 explicit GenericValue(uint64_t u64) : data_(), flags_(kNumberUint64Flag) {
430 if (!(u64 & UINT64_C(0x8000000000000000)))
431 flags_ |= kInt64Flag;
432 if (!(u64 & UINT64_C(0xFFFFFFFF00000000)))
434 if (!(u64 & UINT64_C(0xFFFFFFFF80000000)))
439 explicit GenericValue(
double d) : data_(), flags_(kNumberDoubleFlag) { data_.n.d = d; }
457 if (Allocator::kNeedFree) {
460 for (
GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
462 Allocator::Free(data_.a.elements);
467 m->name.~GenericValue();
468 m->value.~GenericValue();
470 Allocator::Free(data_.o.members);
473 case kCopyStringFlag:
474 Allocator::Free(const_cast<Ch*>(data_.s.str));
520 template <
typename T>
521 RAPIDJSON_DISABLEIF_RETURN(internal::IsPointer<T>,
GenericValue&)
533 template <
typename SourceAllocator>
548 temp.RawAssign(*
this);
550 other.RawAssign(temp);
562 Type GetType()
const {
return static_cast<Type>(flags_ & kTypeMask); }
563 bool IsNull()
const {
return flags_ == kNullFlag; }
564 bool IsFalse()
const {
return flags_ == kFalseFlag; }
565 bool IsTrue()
const {
return flags_ == kTrueFlag; }
566 bool IsBool()
const {
return (flags_ & kBoolFlag) != 0; }
567 bool IsObject()
const {
return flags_ == kObjectFlag; }
568 bool IsArray()
const {
return flags_ == kArrayFlag; }
569 bool IsNumber()
const {
return (flags_ & kNumberFlag) != 0; }
570 bool IsInt()
const {
return (flags_ & kIntFlag) != 0; }
571 bool IsUint()
const {
return (flags_ & kUintFlag) != 0; }
572 bool IsInt64()
const {
return (flags_ & kInt64Flag) != 0; }
573 bool IsUint64()
const {
return (flags_ & kUint64Flag) != 0; }
574 bool IsDouble()
const {
return (flags_ & kDoubleFlag) != 0; }
575 bool IsString()
const {
return (flags_ & kStringFlag) != 0; }
621 return member->value;
678 if (member->name.data_.s.length == len && memcmp(member->name.data_.s.str, name.data_.s.str, len *
sizeof(
Ch)) == 0)
698 if (o.size >= o.capacity) {
699 if (o.capacity == 0) {
700 o.capacity = kDefaultObjectCapacity;
701 o.members =
reinterpret_cast<Member*
>(allocator.Malloc(o.capacity *
sizeof(
Member)));
706 o.members =
reinterpret_cast<Member*
>(allocator.Realloc(o.members, oldCapacity *
sizeof(
Member), o.capacity *
sizeof(
Member)));
709 o.members[o.size].
name.RawAssign(name);
710 o.members[o.size].value.RawAssign(value);
758 template <
typename T>
759 RAPIDJSON_DISABLEIF_RETURN(internal::IsPointer<T>,
GenericValue&)
798 if (data_.o.size > 1 && m != last) {
800 m->name = last->name;
801 m->value = last->value;
805 m->name.~GenericValue();
806 m->value.~GenericValue();
835 for (
SizeType i = 0; i < data_.a.size; ++i)
836 data_.a.elements[i].~GenericValue();
853 return data_.a.elements[index];
870 if (newCapacity > data_.a.capacity) {
872 data_.a.capacity = newCapacity;
888 if (data_.a.size >= data_.a.capacity)
889 Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : data_.a.capacity * 2, allocator);
890 data_.a.elements[data_.a.size++].RawAssign(value);
903 return (*this).template PushBack<StringRefType>(value, allocator);
922 template <
typename T>
923 RAPIDJSON_DISABLEIF_RETURN(internal::IsPointer<T>,
GenericValue&)
933 data_.a.elements[--data_.a.size].~GenericValue();
941 int GetInt()
const {
RAPIDJSON_ASSERT(flags_ & kIntFlag);
return data_.n.i.i; }
942 unsigned GetUint()
const {
RAPIDJSON_ASSERT(flags_ & kUintFlag);
return data_.n.u.u; }
943 int64_t GetInt64()
const {
RAPIDJSON_ASSERT(flags_ & kInt64Flag);
return data_.n.i64; }
944 uint64_t GetUint64()
const {
RAPIDJSON_ASSERT(flags_ & kUint64Flag);
return data_.n.u64; }
946 double GetDouble()
const {
948 if ((flags_ & kDoubleFlag) != 0)
return data_.n.d;
949 if ((flags_ & kIntFlag) != 0)
return data_.n.i.i;
950 if ((flags_ & kUintFlag) != 0)
return data_.n.u.u;
951 if ((flags_ & kInt64Flag) != 0)
return (
double)data_.n.i64;
1017 template <
typename Handler>
1022 case kTrueType:
return handler.Bool(
true);
1025 if (!handler.StartObject())
1028 if (!handler.String(m->name.data_.s.str, m->name.data_.s.length, (m->name.flags_ & kCopyFlag) != 0))
1030 if (!m->value.Accept(handler))
1033 return handler.EndObject(data_.o.size);
1036 if (!handler.StartArray())
1038 for (
GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
1039 if (!v->Accept(handler))
1041 return handler.EndArray(data_.a.size);
1044 return handler.String(data_.s.str, data_.s.length, (flags_ & kCopyFlag) != 0);
1047 if (IsInt())
return handler.Int(data_.n.i.i);
1048 else if (IsUint())
return handler.Uint(data_.n.u.u);
1049 else if (IsInt64())
return handler.Int64(data_.n.i64);
1050 else if (IsUint64())
return handler.Uint64(data_.n.u64);
1051 else return handler.Double(data_.n.d);
1060 template <
typename,
typename>
1065 kNumberFlag = 0x200,
1068 kInt64Flag = 0x1000,
1069 kUint64Flag = 0x2000,
1070 kDoubleFlag = 0x4000,
1071 kStringFlag = 0x100000,
1072 kCopyFlag = 0x200000,
1078 kNumberIntFlag =
kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
1079 kNumberUintFlag =
kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
1080 kNumberInt64Flag =
kNumberType | kNumberFlag | kInt64Flag,
1081 kNumberUint64Flag =
kNumberType | kNumberFlag | kUint64Flag,
1082 kNumberDoubleFlag =
kNumberType | kNumberFlag | kDoubleFlag,
1083 kNumberAnyFlag =
kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
1085 kCopyStringFlag =
kStringType | kStringFlag | kCopyFlag,
1092 static const SizeType kDefaultArrayCapacity = 16;
1093 static const SizeType kDefaultObjectCapacity = 16;
1103 #if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
1148 flags_ = kArrayFlag;
1150 memcpy(data_.a.elements, values, count *
sizeof(
GenericValue));
1151 data_.a.size = data_.a.capacity = count;
1155 void SetObjectRaw(
Member* members,
SizeType count, Allocator& allocator) {
1156 flags_ = kObjectFlag;
1157 data_.o.members = (
Member*)allocator.Malloc(count *
sizeof(
Member));
1158 memcpy(data_.o.members, members, count *
sizeof(
Member));
1159 data_.o.size = data_.o.capacity = count;
1164 flags_ = kConstStringFlag;
1166 data_.s.length = s.length;
1171 flags_ = kCopyStringFlag;
1172 data_.s.str = (
Ch *)allocator.Malloc((s.length + 1) *
sizeof(
Ch));
1173 data_.s.length = s.length;
1174 memcpy(const_cast<Ch*>(data_.s.str), s, s.length *
sizeof(
Ch));
1175 const_cast<Ch*
>(data_.s.str)[s.length] =
'\0';
1181 flags_ = rhs.flags_;
1182 rhs.flags_ = kNullFlag;
1203 template <
typename Encoding,
typename Allocator = MemoryPoolAllocator<> >
1206 typedef typename Encoding::Ch
Ch;
1214 GenericDocument(
Allocator* allocator = 0,
size_t stackCapacity = kDefaultStackCapacity) : stack_(allocator, stackCapacity), parseResult_() {}
1226 template <
unsigned parseFlags,
typename SourceEncoding,
typename InputStream>
1228 ValueType::SetNull();
1230 ClearStackOnExit scope(*
this);
1231 parseResult_ = reader.template Parse<parseFlags>(is, *
this);
1234 this->RawAssign(*stack_.template Pop<ValueType>(1));
1245 template <
unsigned parseFlags,
typename InputStream>
1247 return ParseStream<parseFlags,Encoding,InputStream>(is);
1255 template <
typename InputStream>
1257 return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
1270 template <
unsigned parseFlags,
typename SourceEncoding>
1273 return ParseStream<parseFlags | kParseInsituFlag, SourceEncoding>(s);
1281 template <
unsigned parseFlags>
1283 return ParseInsitu<parseFlags, Encoding>(str);
1291 return ParseInsitu<kParseDefaultFlags, Encoding>(str);
1303 template <
unsigned parseFlags,
typename SourceEncoding>
1307 return ParseStream<parseFlags, SourceEncoding>(s);
1314 template <
unsigned parseFlags>
1316 return Parse<parseFlags, Encoding>(str);
1323 return Parse<kParseDefaultFlags>(str);
1349 struct ClearStackOnExit {
1351 ~ClearStackOnExit() { d_.ClearStack(); }
1353 ClearStackOnExit(
const ClearStackOnExit&);
1354 ClearStackOnExit& operator=(
const ClearStackOnExit&);
1359 template <
typename,
typename,
typename>
friend class GenericReader;
1363 bool Null() {
new (stack_.template Push<ValueType>())
ValueType();
return true; }
1364 bool Bool(
bool b) {
new (stack_.template Push<ValueType>())
ValueType(b);
return true; }
1365 bool Int(
int i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
1366 bool Uint(
unsigned i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
1367 bool Int64(int64_t i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
1368 bool Uint64(uint64_t i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
1369 bool Double(
double d) {
new (stack_.template Push<ValueType>())
ValueType(d);
return true; }
1371 bool String(
const Ch* str,
SizeType length,
bool copy) {
1375 new (stack_.template Push<ValueType>())
ValueType(str, length);
1379 bool StartObject() {
new (stack_.template Push<ValueType>())
ValueType(
kObjectType);
return true; }
1381 bool EndObject(
SizeType memberCount) {
1382 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
1383 stack_.template Top<ValueType>()->SetObjectRaw(members, (
SizeType)memberCount,
GetAllocator());
1387 bool StartArray() {
new (stack_.template Push<ValueType>())
ValueType(
kArrayType);
return true; }
1389 bool EndArray(
SizeType elementCount) {
1390 ValueType* elements = stack_.template Pop<ValueType>(elementCount);
1391 stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount,
GetAllocator());
1400 if (Allocator::kNeedFree)
1401 while (stack_.GetSize() > 0)
1402 (stack_.template Pop<ValueType>(1))->~
ValueType();
1407 static const size_t kDefaultStackCapacity = 1024;
1408 internal::Stack<Allocator> stack_;
1409 ParseResult parseResult_;
1416 template <
typename Encoding,
typename Allocator>
1417 template <
typename SourceAllocator>
1423 RawAssign(*d.stack_.template Pop<GenericValue>(1));
1428 #if defined(_MSC_VER) || defined(__GNUC__)
1432 #endif // RAPIDJSON_DOCUMENT_H_