15 #ifndef RAPIDJSON_DOCUMENT_H_ 16 #define RAPIDJSON_DOCUMENT_H_ 27 RAPIDJSON_DIAG_OFF(4127)
28 #elif defined(__GNUC__) 30 RAPIDJSON_DIAG_OFF(effc++)
36 #ifndef RAPIDJSON_HAS_STDSTRING 37 #ifdef RAPIDJSON_DOXYGEN_RUNNING 38 #define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation 40 #define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default 52 #endif // !defined(RAPIDJSON_HAS_STDSTRING) 54 #if RAPIDJSON_HAS_STDSTRING 56 #endif // RAPIDJSON_HAS_STDSTRING 58 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS 62 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 69 template <
typename Encoding,
typename Allocator>
72 template <
typename Encoding,
typename Allocator,
typename StackAllocator>
81 template <
typename Encoding,
typename Allocator>
90 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS 111 template <
bool Const,
typename Encoding,
typename Allocator>
113 :
public std::iterator<std::random_access_iterator_tag
114 , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
121 typedef std::iterator<std::random_access_iterator_tag,ValueType>
BaseType;
206 #else // RAPIDJSON_NOMEMBERITERATORCLASS 210 template <
bool Const,
typename Encoding,
typename Allocator>
214 template <
typename Encoding,
typename Allocator>
220 template <
typename Encoding,
typename Allocator>
226 #endif // RAPIDJSON_NOMEMBERITERATORCLASS 258 template<
typename CharType>
322 operator const Ch *()
const {
return s; }
347 template<
typename CharType>
367 template<
typename CharType>
372 #if RAPIDJSON_HAS_STDSTRING 385 template<
typename CharType>
395 template <
typename T,
typename Encoding =
void,
typename Allocator =
void>
400 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>
::Type {};
420 template <
typename Encoding,
typename Allocator = MemoryPoolAllocator<> >
427 typedef typename Encoding::Ch
Ch;
441 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 452 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 453 template <
typename StackAllocator>
458 template <
typename StackAllocator>
470 static const unsigned defaultFlags[7] = {
471 kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
475 flags_ = defaultFlags[
type];
479 data_.ss.SetLength(0);
489 template<
typename SourceAllocator >
498 #ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen 499 template <
typename T>
500 explicit GenericValue(T
b, RAPIDJSON_ENABLEIF((internal::IsSame<T,bool>))) RAPIDJSON_NOEXCEPT
504 : data_(), flags_(b ? kTrueFlag : kFalseFlag) {
510 explicit GenericValue(
int i) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberIntFlag) {
513 flags_ |= kUintFlag | kUint64Flag;
517 explicit GenericValue(
unsigned u) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberUintFlag) {
519 if (!(u & 0x80000000))
520 flags_ |= kIntFlag | kInt64Flag;
527 flags_ |= kNumberUint64Flag;
541 flags_ |= kInt64Flag;
549 explicit GenericValue(
double d) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberDoubleFlag) { data_.n.d = d; }
555 explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_(), flags_() { SetStringRaw(s); }
563 #if RAPIDJSON_HAS_STDSTRING 567 GenericValue(
const std::basic_string<Ch>& s, Allocator& allocator) : data_(), flags_() { SetStringRaw(
StringRef(s), allocator); }
574 if (Allocator::kNeedFree) {
577 for (
GenericValue*
v = data_.a.elements;
v != data_.a.elements + data_.a.size; ++
v)
579 Allocator::Free(data_.a.elements);
583 for (MemberIterator
m = MemberBegin();
m != MemberEnd(); ++
m)
585 Allocator::Free(data_.o.members);
588 case kCopyStringFlag:
589 Allocator::Free(const_cast<Ch*>(data_.s.str));
613 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 616 return *
this = rhs.Move();
642 template <
typename T>
655 template <
typename SourceAllocator>
692 GenericValue& Move() RAPIDJSON_NOEXCEPT {
return *
this; }
702 template <
typename SourceAllocator>
705 if (GetType() != rhs.GetType())
710 if (data_.o.size != rhs.
data_.o.size)
712 for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
713 typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
714 if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
720 if (data_.a.size != rhs.
data_.a.size)
722 for (
SizeType i = 0; i < data_.a.size; i++)
723 if ((*
this)[i] != rhs[i])
728 return StringEqual(rhs);
731 if (IsDouble() || rhs.IsDouble()) {
732 double a = GetDouble();
733 double b = rhs.GetDouble();
734 return a >= b && a <=
b;
737 return data_.n.u64 == rhs.
data_.n.u64;
747 #if RAPIDJSON_HAS_STDSTRING 762 template <
typename SourceAllocator>
766 bool operator!=(
const Ch* rhs)
const {
return !(*
this == rhs); }
787 Type GetType()
const {
return static_cast<Type>(flags_ & kTypeMask); }
788 bool IsNull()
const {
return flags_ == kNullFlag; }
789 bool IsFalse()
const {
return flags_ == kFalseFlag; }
790 bool IsTrue()
const {
return flags_ == kTrueFlag; }
791 bool IsBool()
const {
return (flags_ & kBoolFlag) != 0; }
792 bool IsObject()
const {
return flags_ == kObjectFlag; }
793 bool IsArray()
const {
return flags_ == kArrayFlag; }
794 bool IsNumber()
const {
return (flags_ & kNumberFlag) != 0; }
795 bool IsInt()
const {
return (flags_ & kIntFlag) != 0; }
796 bool IsUint()
const {
return (flags_ & kUintFlag) != 0; }
797 bool IsInt64()
const {
return (flags_ & kInt64Flag) != 0; }
798 bool IsUint64()
const {
return (flags_ & kUint64Flag) != 0; }
799 bool IsDouble()
const {
return (flags_ & kDoubleFlag) != 0; }
800 bool IsString()
const {
return (flags_ & kStringFlag) != 0; }
814 bool GetBool()
const {
RAPIDJSON_ASSERT(IsBool());
return flags_ == kTrueFlag; }
832 bool ObjectEmpty()
const {
RAPIDJSON_ASSERT(IsObject());
return data_.o.size == 0; }
843 template <
typename T>
848 template <
typename T>
860 template <
typename SourceAllocator>
862 MemberIterator member = FindMember(name);
863 if (member != MemberEnd())
864 return member->value;
871 template <
typename SourceAllocator>
874 #if RAPIDJSON_HAS_STDSTRING 882 ConstMemberIterator MemberBegin()
const {
RAPIDJSON_ASSERT(IsObject());
return ConstMemberIterator(data_.o.members); }
885 ConstMemberIterator MemberEnd()
const {
RAPIDJSON_ASSERT(IsObject());
return ConstMemberIterator(data_.o.members + data_.o.size); }
888 MemberIterator MemberBegin() {
RAPIDJSON_ASSERT(IsObject());
return MemberIterator(data_.o.members); }
891 MemberIterator MemberEnd() {
RAPIDJSON_ASSERT(IsObject());
return MemberIterator(data_.o.members + data_.o.size); }
901 bool HasMember(
const Ch* name)
const {
return FindMember(name) != MemberEnd(); }
903 #if RAPIDJSON_HAS_STDSTRING 912 bool HasMember(
const std::basic_string<Ch>& name)
const {
return FindMember(name) != MemberEnd(); }
924 template <
typename SourceAllocator>
939 MemberIterator FindMember(
const Ch* name) {
941 return FindMember(n);
944 ConstMemberIterator FindMember(
const Ch* name)
const {
return const_cast<GenericValue&
>(*this).FindMember(name); }
959 template <
typename SourceAllocator>
963 MemberIterator member = MemberBegin();
964 for ( ; member != MemberEnd(); ++member)
971 #if RAPIDJSON_HAS_STDSTRING 979 MemberIterator FindMember(
const std::basic_string<Ch>& name) {
return FindMember(
StringRef(name)); }
980 ConstMemberIterator FindMember(
const std::basic_string<Ch>& name)
const {
return FindMember(
StringRef(name)); }
998 if (o.size >= o.capacity) {
999 if (o.capacity == 0) {
1000 o.
capacity = kDefaultObjectCapacity;
1001 o.members =
reinterpret_cast<Member*
>(allocator.Malloc(o.capacity *
sizeof(Member)));
1005 o.capacity += (oldCapacity + 1) / 2;
1006 o.members =
reinterpret_cast<Member*
>(allocator.Realloc(o.members, oldCapacity *
sizeof(Member), o.capacity *
sizeof(Member)));
1009 o.members[o.size].name.RawAssign(name);
1010 o.members[o.size].value.RawAssign(value);
1026 return AddMember(name, v, allocator);
1029 #if RAPIDJSON_HAS_STDSTRING 1041 return AddMember(name, v, allocator);
1062 template <
typename T>
1064 AddMember(
GenericValue& name, T value, Allocator& allocator) {
1066 return AddMember(name, v, allocator);
1069 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1071 return AddMember(name, value, allocator);
1074 return AddMember(name, value, allocator);
1077 return AddMember(name, value, allocator);
1081 return AddMember(n, value, allocator);
1083 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 1098 return AddMember(n, value, allocator);
1110 GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) {
1112 return AddMember(name, v, allocator);
1132 template <
typename T>
1134 AddMember(StringRefType name, T value, Allocator& allocator) {
1136 return AddMember(n, value, allocator);
1143 void RemoveAllMembers() {
1145 for (MemberIterator
m = MemberBegin();
m != MemberEnd(); ++
m)
1158 bool RemoveMember(
const Ch* name) {
1160 return RemoveMember(n);
1163 #if RAPIDJSON_HAS_STDSTRING 1164 bool RemoveMember(
const std::basic_string<Ch>& name) {
return RemoveMember(
GenericValue(
StringRef(name))); }
1167 template <
typename SourceAllocator>
1169 MemberIterator
m = FindMember(name);
1170 if (m != MemberEnd()) {
1186 MemberIterator RemoveMember(MemberIterator
m) {
1192 MemberIterator last(data_.o.members + (data_.o.size - 1));
1193 if (data_.o.size > 1 && m != last) {
1214 MemberIterator EraseMember(ConstMemberIterator pos) {
1215 return EraseMember(pos, pos +1);
1227 MemberIterator EraseMember(ConstMemberIterator
first, ConstMemberIterator last) {
1235 MemberIterator pos = MemberBegin() + (first - MemberBegin());
1236 for (MemberIterator itr = pos; itr != last; ++itr)
1238 std::memmove(&*pos, &*last, (MemberEnd() - last) *
sizeof(Member));
1239 data_.o.size -= (last -
first);
1248 bool EraseMember(
const Ch* name) {
1250 return EraseMember(n);
1253 #if RAPIDJSON_HAS_STDSTRING 1254 bool EraseMember(
const std::basic_string<Ch>& name) {
return EraseMember(
GenericValue(
StringRef(name))); }
1257 template <
typename SourceAllocator>
1259 MemberIterator m = FindMember(name);
1260 if (m != MemberEnd()) {
1284 bool Empty()
const {
RAPIDJSON_ASSERT(IsArray());
return data_.a.size == 0; }
1292 for (
SizeType i = 0; i < data_.a.size; ++i)
1293 data_.a.elements[i].~GenericValue();
1305 return data_.a.elements[
index];
1311 ValueIterator Begin() {
RAPIDJSON_ASSERT(IsArray());
return data_.a.elements; }
1314 ValueIterator End() {
RAPIDJSON_ASSERT(IsArray());
return data_.a.elements + data_.a.size; }
1317 ConstValueIterator Begin()
const {
return const_cast<GenericValue&
>(*this).Begin(); }
1320 ConstValueIterator End()
const {
return const_cast<GenericValue&
>(*this).End(); }
1330 if (newCapacity > data_.a.capacity) {
1332 data_.a.capacity = newCapacity;
1349 if (data_.a.size >= data_.a.capacity)
1350 Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
1351 data_.a.elements[data_.a.size++].RawAssign(value);
1355 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1357 return PushBack(value, allocator);
1359 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 1370 GenericValue& PushBack(StringRefType value, Allocator& allocator) {
1371 return (*this).template PushBack<StringRefType>(value, allocator);
1391 template <
typename T>
1393 PushBack(T value, Allocator& allocator) {
1395 return PushBack(v, allocator);
1405 data_.a.elements[--data_.a.size].~GenericValue();
1416 ValueIterator Erase(ConstValueIterator pos) {
1417 return Erase(pos, pos + 1);
1428 ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
1435 ValueIterator pos = Begin() + (first - Begin());
1436 for (ValueIterator itr = pos; itr != last; ++itr)
1438 std::memmove(pos, last, (End() - last) *
sizeof(
GenericValue));
1439 data_.a.size -= (last -
first);
1448 int GetInt()
const {
RAPIDJSON_ASSERT(flags_ & kIntFlag);
return data_.n.i.i; }
1449 unsigned GetUint()
const {
RAPIDJSON_ASSERT(flags_ & kUintFlag);
return data_.n.u.u; }
1453 double GetDouble()
const {
1455 if ((flags_ & kDoubleFlag) != 0)
return data_.n.d;
1456 if ((flags_ & kIntFlag) != 0)
return data_.n.i.i;
1457 if ((flags_ & kUintFlag) != 0)
return data_.n.u.u;
1458 if ((flags_ & kInt64Flag) != 0)
return (
double)data_.n.i64;
1473 const Ch* GetString()
const {
RAPIDJSON_ASSERT(IsString());
return ((flags_ & kInlineStrFlag) ? data_.ss.str : data_.s.str); }
1478 SizeType GetStringLength()
const {
RAPIDJSON_ASSERT(IsString());
return ((flags_ & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }
1515 #if RAPIDJSON_HAS_STDSTRING 1523 GenericValue& SetString(
const std::basic_string<Ch>& s, Allocator& allocator) {
return SetString(s.data(),
SizeType(s.size()), allocator); }
1535 template <
typename Handler>
1536 bool Accept(Handler& handler)
const {
1540 case kTrueType:
return handler.Bool(
true);
1543 if (!handler.StartObject())
1545 for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++
m) {
1547 if (!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.flags_ & kCopyFlag) != 0))
1549 if (!m->value.Accept(handler))
1552 return handler.EndObject(data_.o.size);
1555 if (!handler.StartArray())
1557 for (
GenericValue*
v = data_.a.elements;
v != data_.a.elements + data_.a.size; ++
v)
1558 if (!
v->Accept(handler))
1560 return handler.EndArray(data_.a.size);
1563 return handler.String(GetString(), GetStringLength(), (flags_ & kCopyFlag) != 0);
1567 if (IsInt())
return handler.Int(data_.n.i.i);
1568 else if (IsUint())
return handler.Uint(data_.n.u.u);
1569 else if (IsInt64())
return handler.Int64(data_.n.i64);
1570 else if (IsUint64())
return handler.Uint64(data_.n.u64);
1571 else return handler.Double(data_.n.d);
1576 template <
typename,
typename>
friend class GenericValue;
1628 enum { MaxChars =
sizeof(
String) /
sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
1638 #if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN 1684 flags_ = kArrayFlag;
1687 std::memcpy(data_.a.elements, values, count *
sizeof(
GenericValue));
1690 data_.a.elements = NULL;
1691 data_.a.size = data_.a.capacity =
count;
1696 flags_ = kObjectFlag;
1698 data_.o.members = (Member*)allocator.Malloc(count *
sizeof(Member));
1699 std::memcpy(data_.o.members, members, count *
sizeof(Member));
1702 data_.o.members = NULL;
1703 data_.o.size = data_.o.capacity =
count;
1708 flags_ = kConstStringFlag;
1710 data_.s.length = s.length;
1716 if(ShortString::Usable(s.
length)) {
1717 flags_ = kShortStringFlag;
1718 data_.ss.SetLength(s.
length);
1721 flags_ = kCopyStringFlag;
1722 data_.s.length = s.
length;
1723 str = (Ch *)allocator.Malloc((s.
length + 1) *
sizeof(Ch));
1726 std::memcpy(str, s, s.
length *
sizeof(Ch));
1737 template <
typename SourceAllocator>
1742 const SizeType len1 = GetStringLength();
1743 const SizeType len2 = rhs.GetStringLength();
1744 if(len1 != len2) {
return false; }
1746 const Ch*
const str1 = GetString();
1747 const Ch*
const str2 = rhs.GetString();
1748 if(str1 == str2) {
return true; }
1750 return (std::memcmp(str1, str2,
sizeof(Ch) * len1) == 0);
1771 template <
typename Encoding,
typename Allocator = MemoryPoolAllocator<>,
typename StackAllocator = CrtAllocator>
1774 typedef typename Encoding::Ch
Ch;
1785 explicit GenericDocument(
Type type, Allocator* allocator = 0,
size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
1786 GenericValue<Encoding, Allocator>(type), allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
1798 GenericDocument(Allocator* allocator = 0,
size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
1799 allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
1805 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1808 : ValueType(std::forward<ValueType>(rhs)),
1809 allocator_(rhs.allocator_),
1810 ownAllocator_(rhs.ownAllocator_),
1812 parseResult_(rhs.parseResult_)
1815 rhs.ownAllocator_ = 0;
1824 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1830 ValueType::operator=(std::forward<ValueType>(rhs));
1835 allocator_ = rhs.allocator_;
1836 ownAllocator_ = rhs.ownAllocator_;
1838 parseResult_ = rhs.parseResult_;
1841 rhs.ownAllocator_ = 0;
1856 stack_.Swap(rhs.stack_);
1887 template <
unsigned parseFlags,
typename SourceEncoding,
typename InputStream>
1890 stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
1892 parseResult_ = reader.template Parse<parseFlags>(is, *
this);
1895 ValueType::operator=(*stack_.template Pop<ValueType>(1));
1906 template <
unsigned parseFlags,
typename InputStream>
1908 return ParseStream<parseFlags, Encoding, InputStream>(is);
1916 template <
typename InputStream>
1918 return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
1930 template <
unsigned parseFlags>
1933 return ParseStream<parseFlags | kParseInsituFlag>(
s);
1941 return ParseInsitu<kParseDefaultFlags>(str);
1953 template <
unsigned parseFlags,
typename SourceEncoding>
1957 return ParseStream<parseFlags, SourceEncoding>(
s);
1964 template <
unsigned parseFlags>
1966 return Parse<parseFlags, Encoding>(str);
1973 return Parse<kParseDefaultFlags>(str);
2016 bool Null() {
new (stack_.template Push<ValueType>())
ValueType();
return true; }
2017 bool Bool(
bool b) {
new (stack_.template Push<ValueType>())
ValueType(b);
return true; }
2018 bool Int(
int i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2019 bool Uint(
unsigned i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2022 bool Double(
double d) {
new (stack_.template Push<ValueType>())
ValueType(d);
return true; }
2026 new (stack_.template Push<ValueType>())
ValueType(str, length, GetAllocator());
2028 new (stack_.template Push<ValueType>())
ValueType(str, length);
2037 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
2038 stack_.template Top<ValueType>()->
SetObjectRaw(members, (
SizeType)memberCount, GetAllocator());
2045 ValueType* elements = stack_.template Pop<ValueType>(elementCount);
2046 stack_.template Top<ValueType>()->
SetArrayRaw(elements, elementCount, GetAllocator());
2057 if (Allocator::kNeedFree)
2058 while (stack_.GetSize() > 0)
2059 (stack_.template Pop<ValueType>(1))->~
ValueType();
2062 stack_.ShrinkToFit();
2069 static const size_t kDefaultStackCapacity = 1024;
2080 template <
typename Encoding,
typename Allocator>
2081 template <
typename SourceAllocator>
2085 switch (rhs.GetType()) {
2109 #if defined(_MSC_VER) || defined(__GNUC__) 2113 #endif // RAPIDJSON_DOCUMENT_H_ GenericMember< Encoding, Allocator > PlainType
bool operator==(const ngl::Mat3 &_m1, const ngl::Mat3 &_m2)
GenericMemberIterator(Pointer p)
Internal constructor from plain pointer.
GenericDocument & Swap(GenericDocument &rhs) RAPIDJSON_NOEXCEPT
Exchange the contents of this document with those of another.
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string (with kParseDefaultFlags)
ClearStackOnExit(GenericDocument &d)
Pointer operator->() const
GenericValue< Encoding, Allocator > value
value of member.
bool HasParseError() const
Whether a parse error has occured in the last parsing.
bool String(const Ch *str, SizeType length, bool copy)
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream.
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Iterator operator+(DifferenceType n) const
bool operator==(ConstIterator that) const
Allocator AllocatorType
Allocator type from template parameter.
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
GenericValue< Encoding, Allocator > ValueType
Value type of the document.
GenericMemberIterator(const NonConstIterator &it)
Iterator conversions to more const.
BaseType::reference Reference
Reference to (const) GenericMember.
GenericMemberIterator()
Default constructor (singular value)
GenericValue * ValueIterator
Value iterator for iterating in array.
GLuint GLuint GLsizei GLenum type
const GenericValue * ConstValueIterator
Constant value iterator for iterating in array.
GenericValue(double d) RAPIDJSON_NOEXCEPT
Constructor for double value.
GenericValue(const Ch *s, SizeType length, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
Iterator & operator-=(DifferenceType n)
Name-value pair in a JSON object value.
void RawAssign(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment without calling destructor.
GLenum const void GLuint GLint reference
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string.
GenericStringRef< Ch > StringRefType
Reference to a constant string.
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
ParseErrorCode GetParseError() const
Get the ParseErrorCode of last parsing.
GLsizei const GLfloat * value
Encoding EncodingType
Encoding type from template parameter.
size_t GetStackCapacity() const
Get the capacity of stack in bytes.
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
bool EndObject(SizeType memberCount)
unsigned hashcode
reserved
GenericValue< Encoding, Allocator > ValueType
Value type of itself.
ParseErrorCode
Error code of parsing.
GLint GLsizei const GLuint64 * values
GLuint GLsizei GLsizei * length
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string (with kParseDefaultFlags)
GenericDocument(Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
GenericValue & operator=(StringRefType str) RAPIDJSON_NOEXCEPT
Assignment of constant string reference (no copy)
Allocator & GetAllocator()
Get the allocator of this document.
GLdouble GLdouble GLdouble b
GenericStringRef(const CharType *str)
Explicitly create string reference from const character pointer.
const SizeType length
length of the string (excluding the trailing NULL terminator)
GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame< T, bool >))) RAPIDJSON_NOEXCEPT
Constructor for boolean value.
DifferenceType operator-(ConstIterator that) const
Distance.
Reference operator*() const
bool EndArray(SizeType elementCount)
GenericStringRef(const CharType(&str)[N]) RAPIDJSON_NOEXCEPT
Create string reference from const character array.
bool Key(const Ch *str, SizeType length, bool copy)
void SetStringRaw(StringRefType s, Allocator &allocator)
Initialize this value as copy string with initial data, without calling destructor.
fmt::BufferedFile & move(fmt::BufferedFile &f)
bool StringEqual(const GenericValue< Encoding, SourceAllocator > &rhs) const
Reference to a constant string (not taking a copy)
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
GenericValue() RAPIDJSON_NOEXCEPT
Default constructor creates a null value.
bool operator>=(ConstIterator that) const
Allocator * ownAllocator_
BaseType::pointer Pointer
Pointer to (const) GenericMember.
void SetObjectRaw(Member *members, SizeType count, Allocator &allocator)
Initialize this value as object with initial data, without calling destructor.
static const SizeType kDefaultArrayCapacity
GenericMemberIterator Iterator
Iterator type itself.
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT
Constructor for uint64_t value.
internal::Stack< StackAllocator > stack_
const Ch *const s
plain CharType pointer
BaseType::difference_type DifferenceType
Signed integer type (e.g. ptrdiff_t)
GLuint GLuint GLsizei count
unsigned __int64 uint64_t
SizeType GetLength() const
GenericStringRef(const CharType *str, SizeType len)
Create constant string reference from pointer and length.
GenericDocument< UTF8<> > Document
GenericDocument with UTF8 encoding.
friend void swap(GenericDocument &a, GenericDocument &b) RAPIDJSON_NOEXCEPT
free-standing swap function helper
void SetLength(SizeType len)
GenericValue< Encoding, Allocator > name
name of member (must be a string)
#define RAPIDJSON_NEW(x)
! customization point for global new
internal::MaybeAddConst< Const, PlainType >::Type ValueType
GenericValue(const Ch *s, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Reference operator[](DifferenceType n) const
void Swap(T &a, T &b) RAPIDJSON_NOEXCEPT
Custom swap() to avoid dependency on C++ <algorith> header.
std::iterator< std::random_access_iterator_tag, ValueType > BaseType
GenericMemberIterator< true, Encoding, Allocator > ConstIterator
Constant iterator type.
#define RAPIDJSON_DELETE(x)
! customization point for global delete
GenericValue(const Ch *s, SizeType length) RAPIDJSON_NOEXCEPT
Constructor for constant string (i.e. do not make a copy of string)
bool operator<=(ConstIterator that) const
GenericMemberIterator< false, Encoding, Allocator > NonConstIterator
Non-constant iterator type.
static bool Usable(SizeType len)
void SetArrayRaw(GenericValue *values, SizeType count, Allocator &allocator)
static const SizeType kDefaultObjectCapacity
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string.
SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator.
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with kParseDefaultFlags)
GenericMemberIterator< false, Encoding, Allocator >::Iterator MemberIterator
Member iterator for iterating in object.
GLuint const GLchar * name
CharType Ch
character type of the string
GenericMemberIterator< true, Encoding, Allocator >::Iterator ConstMemberIterator
Constant member iterator for iterating in object.
Result of parsing (wraps ParseErrorCode)
bool operator<(ConstIterator that) const
GenericValue & operator=(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment with move semantics.
bool operator!=(ConstIterator that) const
~GenericValue()
Destructor.
SizeType StrLen(const Ch *s)
Custom strlen() which works on different character types.
GLsizei const void * pointer
Iterator & operator+=(DifferenceType n)
Iterator operator-(DifferenceType n) const
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with Encoding conversion)
GenericValue(Type type) RAPIDJSON_NOEXCEPT
Constructor with JSON value type.
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string (with Encoding conversion)
A read-write string stream.
friend class GenericDocument
(Constant) member iterator for a JSON object value
GenericDocument(Type type, Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT
Initialize this value as constant string, without calling destructor.
GLboolean GLboolean GLboolean GLboolean a
RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T2 >, internal::IsGenericValue< T2 > >),(typename T::ValueType &)) GetValueByPointerWithDefault(T &root
GenericValue(unsigned u) RAPIDJSON_NOEXCEPT
Constructor for unsigned value.
bool operator>(ConstIterator that) const
#define RAPIDJSON_ASSERT(x)
Assertion.
Encoding::Ch Ch
Character type derived from Encoding.
A document for parsing JSON text as DOM.
In-situ(destructive) parsing.
GenericValue(int i) RAPIDJSON_NOEXCEPT
Constructor for int value.
Allocator AllocatorType
Allocator type from template parameter.
GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT
Constructor for int64_t value.
GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT
Constructor for constant string (i.e. do not make a copy of string)
GenericMember< Encoding, Allocator > Member
Name-value pair in an object.
Encoding::Ch Ch
Character type derived from Encoding.