15 #ifndef RAPIDJSON_DOCUMENT_H_ 16 #define RAPIDJSON_DOCUMENT_H_ 30 RAPIDJSON_DIAG_OFF(padded)
31 RAPIDJSON_DIAG_OFF(
switch-
enum)
32 RAPIDJSON_DIAG_OFF(c++98-compat)
33 #elif defined(_MSC_VER) 34 RAPIDJSON_DIAG_OFF(4127)
35 RAPIDJSON_DIAG_OFF(4244)
39 RAPIDJSON_DIAG_OFF(effc++)
41 RAPIDJSON_DIAG_OFF(terminate)
45 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS 49 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 56 template <
typename Encoding,
typename Allocator>
59 template <
typename Encoding,
typename Allocator,
typename StackAllocator>
68 template <
typename Encoding,
typename Allocator>
77 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS 98 template <
bool Const,
typename Encoding,
typename Allocator>
200 #else // RAPIDJSON_NOMEMBERITERATORCLASS 204 template <
bool Const,
typename Encoding,
typename Allocator>
208 template <
typename Encoding,
typename Allocator>
214 template <
typename Encoding,
typename Allocator>
220 #endif // RAPIDJSON_NOMEMBERITERATORCLASS 252 template<
typename CharType>
257 #ifndef __clang__ // -Wdocumentation 286 #ifndef __clang__ // -Wdocumentation 307 :
s(str),
length(NotNullStrLen(str)) {}
310 #ifndef __clang__ // -Wdocumentation 324 operator const Ch *()
const {
return s; }
330 SizeType NotNullStrLen(
const CharType* str) {
336 static const Ch emptyString[];
345 template<
typename CharType>
360 template<
typename CharType>
380 template<
typename CharType>
385 #if RAPIDJSON_HAS_STDSTRING 398 template<
typename CharType>
408 template <
typename T,
typename Encoding =
void,
typename Allocator =
void>
413 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>
::Type {};
425 template <
typename ValueType,
typename T>
428 template<
typename ValueType>
430 static bool Is(
const ValueType& v) {
return v.IsBool(); }
431 static bool Get(
const ValueType& v) {
return v.GetBool(); }
432 static ValueType&
Set(ValueType& v,
bool data) {
return v.SetBool(data); }
433 static ValueType&
Set(ValueType& v,
bool data,
typename ValueType::AllocatorType&) {
return v.SetBool(data); }
436 template<
typename ValueType>
438 static bool Is(
const ValueType& v) {
return v.IsInt(); }
439 static int Get(
const ValueType& v) {
return v.GetInt(); }
440 static ValueType&
Set(ValueType& v,
int data) {
return v.SetInt(data); }
441 static ValueType&
Set(ValueType& v,
int data,
typename ValueType::AllocatorType&) {
return v.SetInt(data); }
444 template<
typename ValueType>
446 static bool Is(
const ValueType& v) {
return v.IsUint(); }
447 static unsigned Get(
const ValueType& v) {
return v.GetUint(); }
448 static ValueType&
Set(ValueType& v,
unsigned data) {
return v.SetUint(data); }
449 static ValueType&
Set(ValueType& v,
unsigned data,
typename ValueType::AllocatorType&) {
return v.SetUint(data); }
454 template<
typename ValueType>
455 struct TypeHelper<ValueType, long> {
456 static bool Is(
const ValueType& v) {
return v.IsInt(); }
457 static long Get(
const ValueType& v) {
return v.GetInt(); }
458 static ValueType& Set(ValueType& v,
long data) {
return v.SetInt(data); }
459 static ValueType& Set(ValueType& v,
long data,
typename ValueType::AllocatorType&) {
return v.SetInt(data); }
463 template<
typename ValueType>
464 struct TypeHelper<ValueType, unsigned long> {
465 static bool Is(
const ValueType& v) {
return v.IsUint(); }
466 static unsigned long Get(
const ValueType& v) {
return v.GetUint(); }
467 static ValueType& Set(ValueType& v,
unsigned long data) {
return v.SetUint(data); }
468 static ValueType& Set(ValueType& v,
unsigned long data,
typename ValueType::AllocatorType&) {
return v.SetUint(data); }
472 template<
typename ValueType>
474 static bool Is(
const ValueType& v) {
return v.IsInt64(); }
475 static int64_t Get(
const ValueType& v) {
return v.GetInt64(); }
476 static ValueType&
Set(ValueType& v,
int64_t data) {
return v.SetInt64(data); }
477 static ValueType&
Set(ValueType& v,
int64_t data,
typename ValueType::AllocatorType&) {
return v.SetInt64(data); }
480 template<
typename ValueType>
482 static bool Is(
const ValueType& v) {
return v.IsUint64(); }
484 static ValueType&
Set(ValueType& v,
uint64_t data) {
return v.SetUint64(data); }
485 static ValueType&
Set(ValueType& v,
uint64_t data,
typename ValueType::AllocatorType&) {
return v.SetUint64(data); }
488 template<
typename ValueType>
490 static bool Is(
const ValueType& v) {
return v.IsDouble(); }
491 static double Get(
const ValueType& v) {
return v.GetDouble(); }
492 static ValueType&
Set(ValueType& v,
double data) {
return v.SetDouble(data); }
493 static ValueType&
Set(ValueType& v,
double data,
typename ValueType::AllocatorType&) {
return v.SetDouble(data); }
496 template<
typename ValueType>
498 static bool Is(
const ValueType& v) {
return v.IsFloat(); }
499 static float Get(
const ValueType& v) {
return v.GetFloat(); }
500 static ValueType&
Set(ValueType& v,
float data) {
return v.SetFloat(data); }
501 static ValueType&
Set(ValueType& v,
float data,
typename ValueType::AllocatorType&) {
return v.SetFloat(data); }
504 template<
typename ValueType>
507 static bool Is(
const ValueType& v) {
return v.IsString(); }
509 static ValueType&
Set(ValueType& v,
const StringType data) {
return v.SetString(
typename ValueType::StringRefType(data)); }
510 static ValueType&
Set(ValueType& v,
const StringType data,
typename ValueType::AllocatorType&
a) {
return v.SetString(data,
a); }
513 #if RAPIDJSON_HAS_STDSTRING 514 template<
typename ValueType>
515 struct TypeHelper<ValueType,
std::basic_string<typename ValueType::Ch> > {
516 typedef std::basic_string<typename ValueType::Ch> StringType;
517 static bool Is(
const ValueType& v) {
return v.IsString(); }
518 static StringType Get(
const ValueType& v) {
return StringType(v.GetString(), v.GetStringLength()); }
519 static ValueType& Set(ValueType& v,
const StringType& data,
typename ValueType::AllocatorType&
a) {
return v.SetString(data,
a); }
523 template<
typename ValueType>
526 static bool Is(
const ValueType& v) {
return v.IsArray(); }
528 static ValueType&
Set(ValueType& v,
ArrayType data) {
return v = data; }
529 static ValueType&
Set(ValueType& v,
ArrayType data,
typename ValueType::AllocatorType&) {
return v = data; }
532 template<
typename ValueType>
533 struct TypeHelper<ValueType, typename ValueType::ConstArray> {
535 static bool Is(
const ValueType& v) {
return v.IsArray(); }
539 template<
typename ValueType>
542 static bool Is(
const ValueType& v) {
return v.IsObject(); }
545 static ValueType&
Set(ValueType& v,
ObjectType data,
typename ValueType::AllocatorType&) {
return v = data; }
548 template<
typename ValueType>
549 struct TypeHelper<ValueType, typename ValueType::ConstObject> {
551 static bool Is(
const ValueType& v) {
return v.IsObject(); }
574 template <
typename Encoding,
typename Allocator = MemoryPoolAllocator<> >
599 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 610 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 611 template <
typename StackAllocator>
616 template <
typename StackAllocator>
628 static const uint16_t defaultFlags[7] = {
648 template <
typename SourceAllocator>
650 switch (rhs.GetType()) {
669 new (&le[i])
GenericValue(re[i], allocator, copyConstStrings);
678 data_ = *
reinterpret_cast<const Data*
>(&rhs.
data_);
685 data_ = *
reinterpret_cast<const Data*
>(&rhs.
data_);
696 #ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen 697 template <
typename T>
698 explicit GenericValue(
T b, RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) RAPIDJSON_NOEXCEPT
765 #if RAPIDJSON_HAS_STDSTRING 779 a.value_.data_ = Data();
790 o.value_.data_ = Data();
798 if (Allocator::kNeedFree) {
840 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 843 return *
this = rhs.Move();
869 template <
typename T>
883 template <
typename SourceAllocator>
885 RAPIDJSON_ASSERT(static_cast<void*>(
this) != static_cast<void const*>(&rhs));
887 new (
this)
GenericValue(rhs, allocator, copyConstStrings);
900 other.RawAssign(temp);
920 GenericValue& Move() RAPIDJSON_NOEXCEPT {
return *
this; }
930 template <
typename SourceAllocator>
933 if (GetType() != rhs.GetType())
940 for (
ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
941 typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
942 if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
951 if ((*
this)[i] != rhs[i])
959 if (IsDouble() || rhs.IsDouble()) {
960 double a = GetDouble();
961 double b = rhs.GetDouble();
962 return a >= b &&
a <= b;
975 #if RAPIDJSON_HAS_STDSTRING 990 template <
typename SourceAllocator>
994 bool operator!=(
const Ch* rhs)
const {
return !(*
this == rhs); }
1031 bool IsLosslessDouble()
const {
1032 if (!IsNumber())
return false;
1035 volatile double d =
static_cast<double>(u);
1037 && (d < static_cast<double>((std::numeric_limits<uint64_t>::max)()))
1038 && (u ==
static_cast<uint64_t>(d));
1042 volatile double d =
static_cast<double>(i);
1043 return (d >= static_cast<double>((std::numeric_limits<int64_t>::min)()))
1044 && (d < static_cast<double>((std::numeric_limits<int64_t>::max)()))
1045 && (i == static_cast<int64_t>(d));
1051 bool IsFloat()
const {
1054 double d = GetDouble();
1055 return d >= -3.4028234e38 && d <= 3.4028234e38;
1058 bool IsLosslessFloat()
const {
1059 if (!IsNumber())
return false;
1060 double a = GetDouble();
1061 if (
a < static_cast<double>(-(std::numeric_limits<float>::max)())
1062 ||
a > static_cast<double>((std::numeric_limits<float>::max)()))
1064 double b =
static_cast<double>(
static_cast<float>(
a));
1065 return a >= b &&
a <= b;
1112 template <
typename T>
1117 template <
typename T>
1129 template <
typename SourceAllocator>
1132 if (member != MemberEnd())
1133 return member->value;
1146 template <
typename SourceAllocator>
1149 #if RAPIDJSON_HAS_STDSTRING 1191 bool HasMember(
const Ch*
name)
const {
return FindMember(
name) != MemberEnd(); }
1193 #if RAPIDJSON_HAS_STDSTRING 1202 bool HasMember(
const std::basic_string<Ch>&
name)
const {
return FindMember(
name) != MemberEnd(); }
1214 template <
typename SourceAllocator>
1231 return FindMember(n);
1249 template <
typename SourceAllocator>
1254 for ( ; member != MemberEnd(); ++member)
1255 if (
name.StringEqual(member->name))
1261 #if RAPIDJSON_HAS_STDSTRING 1288 if (o.size >= o.capacity)
1289 MemberReserve(o.capacity == 0 ?
kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
1291 members[o.size].name.RawAssign(
name);
1292 members[o.size].value.RawAssign(
value);
1308 return AddMember(
name, v, allocator);
1311 #if RAPIDJSON_HAS_STDSTRING 1323 return AddMember(
name, v, allocator);
1344 template <
typename T>
1348 return AddMember(
name, v, allocator);
1351 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1353 return AddMember(
name,
value, allocator);
1356 return AddMember(
name,
value, allocator);
1359 return AddMember(
name,
value, allocator);
1363 return AddMember(n,
value, allocator);
1365 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 1380 return AddMember(n,
value, allocator);
1394 return AddMember(
name, v, allocator);
1414 template <
typename T>
1418 return AddMember(n,
value, allocator);
1425 void RemoveAllMembers() {
1440 bool RemoveMember(
const Ch*
name) {
1442 return RemoveMember(n);
1445 #if RAPIDJSON_HAS_STDSTRING 1449 template <
typename SourceAllocator>
1452 if (m != MemberEnd()) {
1493 return EraseMember(pos, pos +1);
1516 std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) *
sizeof(
Member));
1526 bool EraseMember(
const Ch*
name) {
1528 return EraseMember(n);
1531 #if RAPIDJSON_HAS_STDSTRING 1535 template <
typename SourceAllocator>
1538 if (m != MemberEnd()) {
1637 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1639 return PushBack(
value, allocator);
1641 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 1653 return (*this).template PushBack<StringRefType>(
value, allocator);
1673 template <
typename T>
1675 PushBack(
T value, Allocator& allocator) {
1677 return PushBack(v, allocator);
1699 return Erase(pos, pos + 1);
1741 double GetDouble()
const {
1753 float GetFloat()
const {
1754 return static_cast<float>(GetDouble());
1819 #if RAPIDJSON_HAS_STDSTRING 1827 GenericValue& SetString(
const std::basic_string<Ch>& s, Allocator& allocator) {
return SetString(
StringRef(s), allocator); }
1839 template <
typename T>
1842 template <
typename T>
1845 template <
typename T>
1848 template<
typename T>
1851 template<
typename T>
1863 template <
typename Handler>
1864 bool Accept(Handler& handler)
const {
1868 case kTrueType:
return handler.Bool(
true);
1895 if (IsDouble())
return handler.Double(
data_.
n.
d);
1896 else if (IsInt())
return handler.Int(
data_.
n.
i.
i);
1897 else if (IsUint())
return handler.Uint(
data_.
n.
u.
u);
1898 else if (IsInt64())
return handler.Int64(
data_.
n.
i64);
1899 else return handler.Uint64(
data_.
n.
u64);
1904 template <
typename,
typename>
friend class GenericValue;
1942 #if RAPIDJSON_48BITPOINTER_OPTIMIZATION 1944 #elif RAPIDJSON_64BIT 1977 #if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN 2036 #if defined(__GNUC__) && __GNUC__ >= 8 2037 RAPIDJSON_DIAG_OFF(
class-memaccess)
2054 #if defined(__GNUC__) && __GNUC__ >= 8 2055 RAPIDJSON_DIAG_OFF(
class-memaccess)
2082 str =
static_cast<Ch *
>(allocator.Malloc((s.
length + 1) *
sizeof(
Ch)));
2096 template <
typename SourceAllocator>
2101 const SizeType len1 = GetStringLength();
2102 const SizeType len2 = rhs.GetStringLength();
2103 if(len1 != len2) {
return false; }
2105 const Ch*
const str1 = GetString();
2106 const Ch*
const str2 = rhs.GetString();
2107 if(str1 == str2) {
return true; }
2109 return (std::memcmp(str1, str2,
sizeof(
Ch) * len1) == 0);
2129 template <
typename Encoding,
typename Allocator = MemoryPoolAllocator<>,
typename StackAllocator = CrtAllocator>
2143 explicit GenericDocument(
Type type, Allocator* allocator = 0,
size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
2144 GenericValue<Encoding, Allocator>(type), allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
2156 GenericDocument(Allocator* allocator = 0,
size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
2157 allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
2163 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 2166 :
ValueType(std::forward<ValueType>(rhs)),
2167 allocator_(rhs.allocator_),
2168 ownAllocator_(rhs.ownAllocator_),
2170 parseResult_(rhs.parseResult_)
2173 rhs.ownAllocator_ = 0;
2182 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 2193 allocator_ = rhs.allocator_;
2194 ownAllocator_ = rhs.ownAllocator_;
2196 parseResult_ = rhs.parseResult_;
2199 rhs.ownAllocator_ = 0;
2214 stack_.
Swap(rhs.stack_);
2244 template <
typename Generator>
2246 ClearStackOnExit scope(*
this);
2264 template <
unsigned parseFlags,
typename SourceEncoding,
typename InputStream>
2268 ClearStackOnExit scope(*
this);
2269 parseResult_ = reader.template Parse<parseFlags>(is, *
this);
2283 template <
unsigned parseFlags,
typename InputStream>
2285 return ParseStream<parseFlags, Encoding, InputStream>(is);
2293 template <
typename InputStream>
2295 return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
2307 template <
unsigned parseFlags>
2310 return ParseStream<parseFlags | kParseInsituFlag>(s);
2318 return ParseInsitu<kParseDefaultFlags>(str);
2330 template <
unsigned parseFlags,
typename SourceEncoding>
2334 return ParseStream<parseFlags, SourceEncoding>(s);
2341 template <
unsigned parseFlags>
2343 return Parse<parseFlags, Encoding>(str);
2350 return Parse<kParseDefaultFlags>(str);
2353 template <
unsigned parseFlags,
typename SourceEncoding>
2358 ParseStream<parseFlags, SourceEncoding>(is);
2362 template <
unsigned parseFlags>
2364 return Parse<parseFlags, Encoding>(str, length);
2368 return Parse<kParseDefaultFlags>(str, length);
2371 #if RAPIDJSON_HAS_STDSTRING 2372 template <
unsigned parseFlags,
typename SourceEncoding>
2375 return Parse<parseFlags, SourceEncoding>(str.c_str());
2378 template <
unsigned parseFlags>
2380 return Parse<parseFlags, Encoding>(str.c_str());
2384 return Parse<kParseDefaultFlags>(str);
2386 #endif // RAPIDJSON_HAS_STDSTRING 2403 #ifndef __clang // -Wdocumentation 2428 struct ClearStackOnExit {
2430 ~ClearStackOnExit() { d_.ClearStack(); }
2432 ClearStackOnExit(
const ClearStackOnExit&);
2433 ClearStackOnExit&
operator=(
const ClearStackOnExit&);
2443 bool Null() {
new (stack_.template Push<ValueType>())
ValueType();
return true; }
2444 bool Bool(
bool b) {
new (stack_.template Push<ValueType>())
ValueType(b);
return true; }
2445 bool Int(
int i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2446 bool Uint(
unsigned i) {
new (stack_.template Push<ValueType>())
ValueType(i);
return true; }
2449 bool Double(
double d) {
new (stack_.template Push<ValueType>())
ValueType(d);
return true; }
2455 new (stack_.template Push<ValueType>())
ValueType(str, length);
2463 new (stack_.template Push<ValueType>())
ValueType(str, length);
2472 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
2480 ValueType* elements = stack_.template Pop<ValueType>(elementCount);
2492 if (Allocator::kNeedFree)
2494 (stack_.template Pop<ValueType>(1))->~
ValueType();
2504 static const size_t kDefaultStackCapacity = 1024;
2505 Allocator* allocator_;
2506 Allocator* ownAllocator_;
2519 template <
bool Const,
typename ValueT>
2531 template <
typename,
typename>
2540 bool Empty()
const {
return value_.Empty(); }
2547 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 2549 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 2556 #if RAPIDJSON_HAS_CXX11_RANGE_FOR 2572 template <
bool Const,
typename ValueT>
2586 template <
typename,
typename>
2598 #if RAPIDJSON_HAS_STDSTRING 2605 #if RAPIDJSON_HAS_STDSTRING 2606 bool HasMember(
const std::basic_string<Ch>&
name)
const {
return value_.HasMember(
name); }
2611 #if RAPIDJSON_HAS_STDSTRING 2616 #if RAPIDJSON_HAS_STDSTRING 2620 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 2625 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 2631 #if RAPIDJSON_HAS_STDSTRING 2632 bool RemoveMember(
const std::basic_string<Ch>&
name)
const {
return value_.RemoveMember(
name); }
2639 #if RAPIDJSON_HAS_STDSTRING 2644 #if RAPIDJSON_HAS_CXX11_RANGE_FOR 2658 #endif // RAPIDJSON_DOCUMENT_H_ Pointer operator->() const
static bool Is(const ValueType &v)
GenericValue(Object o) RAPIDJSON_NOEXCEPT
Constructor for Object.
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)
GenericValue(Array a) RAPIDJSON_NOEXCEPT
Constructor for Array.
ParseErrorCode GetParseError() const
Get the ParseErrorCode of last parsing.
MemberIterator FindMember(const Ch *name) const
static bool Is(const ValueType &v)
static bool Is(const ValueType &v)
GenericValue< Encoding, Allocator > value
value of member.
static ValueType & Set(ValueType &v, ObjectType data, typename ValueType::AllocatorType &)
char payload[sizeof(SizeType) *2+sizeof(void *)+2]
MemberIterator RemoveMember(MemberIterator m) const
static bool Is(const ValueType &v)
static ValueType & Set(ValueType &v, const StringType data)
struct GenericValue::Number::I i
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.)
GenericObject & operator=(const GenericObject &rhs)
std::random_access_iterator_tag iterator_category
static ArrayType Get(const ValueType &v)
static bool Is(const ValueType &v)
Allocator AllocatorType
Allocator type from template parameter.
ValueIterator Begin() const
GenericObject< true, ValueType > ConstObject
std::ptrdiff_t difference_type
GenericDocument & Parse(const typename SourceEncoding::Ch *str, size_t length)
static ValueType & Set(ValueType &v, int64_t data, typename ValueType::AllocatorType &)
MemberIterator EraseMember(ConstMemberIterator pos) const
GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame< bool, T >))) RAPIDJSON_NOEXCEPT
Constructor for boolean value.
#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.
GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const
GenericMemberIterator(const NonConstIterator &it)
Iterator conversions to more const.
ValueType::StringRefType StringRefType
GenericObject AddMember(StringRefType name, ValueType &value, AllocatorType &allocator) const
GenericMemberIterator()
Default constructor (singular value)
GenericArray< false, ValueT > Array
GenericValue * ValueIterator
Value iterator for iterating in array.
GTEST_API_ bool IsTrue(bool condition)
const GenericValue * ConstValueIterator
Constant value iterator for iterating in array.
DifferenceType operator-(ConstIterator that) const
Distance.
GenericValue(double d) RAPIDJSON_NOEXCEPT
Constructor for double value.
static ValueType & Set(ValueType &v, bool data, typename ValueType::AllocatorType &)
Reference operator*() const
GenericValue(const Ch *s, SizeType length, Allocator &allocator)
Constructor for copy-string (i.e. do make a copy of string)
bool operator<(ConstIterator that) const
Iterator & operator-=(DifferenceType n)
Name-value pair in a JSON object value.
void RawAssign(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment without calling destructor.
RAPIDJSON_FORCEINLINE Member * SetMembersPointer(Member *members)
static ValueType & Set(ValueType &v, float data)
ParseErrorCode Code() const
Get the error code.
GenericArray PushBack(StringRefType value, AllocatorType &allocator) const
ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string.
GenericStringRef< Ch > StringRefType
Reference to a constant string.
SizeType GetLength() const
Iterator operator+(DifferenceType n) const
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
static ValueType & Set(ValueType &v, int data)
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
ValueType & operator[](SizeType index) const
Encoding EncodingType
Encoding type from template parameter.
static bool Is(const ValueType &v)
MemberIterator MemberBegin() const
static ArrayType Get(ValueType &v)
GenericStringRef(const GenericStringRef &rhs)
bool StringEqual(const GenericValue< Encoding, SourceAllocator > &rhs) const
static float Get(const ValueType &v)
static int64_t Get(const ValueType &v)
bool operator>(ConstIterator that) const
bool operator==(const some_test_data &a, const some_test_data &b)
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
bool operator!=(const some_test_subdata &a, const some_test_subdata &b)
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
static int Get(const ValueType &v)
bool EndObject(SizeType memberCount)
ValueType::AllocatorType AllocatorType
MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const
size_t GetCapacity() const
static ValueType & Set(ValueType &v, double data, typename ValueType::AllocatorType &)
bool EraseMember(const Ch *name) const
static ValueType & Set(ValueType &v, double data)
#define RAPIDJSON_LIKELY(x)
Compiler branching hint for expression with high probability to be true.
GenericValue< Encoding, Allocator > ValueType
Value type of itself.
ParseErrorCode
Error code of parsing.
GenericDocument & Parse(const Ch *str, size_t length)
GenericArray(const GenericArray &rhs)
GenericMemberIterator< true, typename ValueT::EncodingType, typename ValueT::AllocatorType > ConstMemberIterator
void copy(key &AA, const key &A)
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
GenericObject(const GenericObject &rhs)
static unsigned Get(const ValueType &v)
bool operator>=(ConstIterator that) const
GenericDocument & ParseInsitu(Ch *str)
Parse JSON text from a mutable string (with kParseDefaultFlags)
GenericArray< true, ValueT > ConstArray
Iterator & operator=(const NonConstIterator &it)
GenericDocument(Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
GenericObject AddMember(ValueType &name, StringRefType value, AllocatorType &allocator) const
GenericValue & operator=(StringRefType str) RAPIDJSON_NOEXCEPT
Assignment of constant string reference (no copy)
Iterator operator-(DifferenceType n) const
Allocator & GetAllocator()
Get the allocator of this document.
GenericStringRef(const CharType *str)
Explicitly create string reference from const character pointer.
RAPIDJSON_FORCEINLINE const Ch * SetStringPointer(const Ch *str)
static StringType Get(const ValueType &v)
static uint64_t Get(const ValueType &v)
const SizeType length
length of the string (excluding the trailing NULL terminator)
RAPIDJSON_FORCEINLINE GenericValue * SetElementsPointer(GenericValue *elements)
bool EndArray(SizeType elementCount)
ValueType & operator[](T *name) const
GenericStringRef(const CharType(&str)[N]) RAPIDJSON_NOEXCEPT
Create string reference from const character array.
static double Get(const ValueType &v)
ValueType::AllocatorType AllocatorType
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.
#define RAPIDJSON_NEW(TypeName)
! customization point for global new
ValueIterator End() const
static bool Is(const ValueType &v)
mdb_size_t count(MDB_cursor *cur)
Reference to a constant string (not taking a copy)
GenericDocument & Populate(Generator &g)
Populate this document by a generator which produces SAX events.
Represents an in-memory input byte stream.
GenericValue() RAPIDJSON_NOEXCEPT
Default constructor creates a null value.
reference Reference
Reference to (const) GenericMember.
Allocator & GetAllocator()
ValueType::Array ArrayType
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.
struct GenericValue::Number::U u
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
ValueType::ConstObject ObjectType
GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT
Constructor for uint64_t value.
const ValueType::Ch * StringType
static bool Is(const ValueType &v)
bool RemoveMember(const GenericValue< EncodingType, SourceAllocator > &name) const
GenericArray PopBack() const
GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType &allocator) const
const Ch *const s
plain CharType pointer
pointer Pointer
Pointer to (const) GenericMember.
RAPIDJSON_FORCEINLINE GenericValue * GetElementsPointer() const
unsigned __int64 uint64_t
GenericObject AddMember(ValueType &name, ValueType &value, AllocatorType &allocator) const
static bool Is(const ValueType &v)
GenericStringRef(const CharType *str, SizeType len)
Create constant string reference from pointer and length.
bool HasMember(const Ch *name) const
GenericDocument< UTF8<> > Document
GenericDocument with UTF8 encoding.
friend void swap(GenericDocument &a, GenericDocument &b) RAPIDJSON_NOEXCEPT
free-standing swap function helper
size_t GetStackCapacity() const
Get the capacity of stack in bytes.
void SetLength(SizeType len)
GenericValue< Encoding, Allocator > name
name of member (must be a string)
#define RAPIDJSON_UNLIKELY(x)
Compiler branching hint for expression with low probability to be true.
Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
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)
static ValueType & Set(ValueType &v, const StringType data, typename ValueType::AllocatorType &a)
void Swap(T &a, T &b) RAPIDJSON_NOEXCEPT
Custom swap() to avoid dependency on C++ <algorithm> header.
static ValueType & Set(ValueType &v, int64_t data)
GenericMemberIterator< true, Encoding, Allocator > ConstIterator
Constant iterator type.
#define RAPIDJSON_DELETE(x)
! customization point for global delete
static ValueType & Set(ValueType &v, ObjectType data)
GenericValue(const Ch *s, SizeType length) RAPIDJSON_NOEXCEPT
Constructor for constant string (i.e. do not make a copy of string)
static ValueType & Set(ValueType &v, uint64_t data, typename ValueType::AllocatorType &)
GenericObject< true, ValueT > ConstObject
GenericMemberIterator< false, Encoding, Allocator > NonConstIterator
Non-constant iterator type.
static bool Usable(SizeType len)
RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) AddMember(ValueType &name
static ValueType & Set(ValueType &v, float data, typename ValueType::AllocatorType &)
void SetArrayRaw(GenericValue *values, SizeType count, Allocator &allocator)
internal::MaybeAddConst< Const, PlainType >::Type ValueType
ValueType::StringRefType StringRefType
PolymorphicMatcher< internal::IsNullMatcher > IsNull()
static const SizeType kDefaultObjectCapacity
static ValueType & Set(ValueType &v, ArrayType data)
#define RAPIDJSON_SETPOINTER(type, p, x)
static ValueType & Set(ValueType &v, uint64_t data)
static bool Is(const ValueType &v)
SizeType hashcode
reserved
bool RawNumber(const Ch *str, SizeType length, bool copy)
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
ValueType::Object ObjectType
static ValueType & Set(ValueType &v, unsigned data, typename ValueType::AllocatorType &)
bool IsError() const
Whether the result is an error.
Helper class for accessing Value of array type.
GenericDocument & Parse(const Ch *str, size_t length)
GenericDocument & Parse(const Ch *str)
Parse JSON text from a read-only string.
SizeType MemberCount() const
GenericDocument & Parse(const typename SourceEncoding::Ch *str)
Parse JSON text from a read-only string (with Encoding conversion)
ValueType::EncodingType EncodingType
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.
const T & move(const T &t)
bool operator==(ConstIterator that) const
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with kParseDefaultFlags)
static ObjectType Get(ValueType &v)
const GenericPointer< typename T::ValueType > T2 value
void * memcpy(void *a, const void *b, size_t c)
RAPIDJSON_FORCEINLINE Member * GetMembersPointer() const
GenericMemberIterator< false, Encoding, Allocator >::Iterator MemberIterator
Member iterator for iterating in object.
bool operator<=(ConstIterator that) const
RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(const GenericArray &)) PushBack(T value
CharType Ch
character type of the string
Helper class for accessing Value of object type.
GenericMemberIterator< true, Encoding, Allocator >::Iterator ConstMemberIterator
Constant member iterator for iterating in object.
#define RAPIDJSON_GETPOINTER(type, p)
static ValueType & Set(ValueType &v, bool data)
bool HasAllocator() const
Result of parsing (wraps ParseErrorCode)
SizeType Capacity() const
GenericObject< false, ValueT > Object
GenericValue & operator=(GenericValue &rhs) RAPIDJSON_NOEXCEPT
Assignment with move semantics.
~GenericValue()
Destructor.
GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const
connection< TProtocol > & operator=(const connection< TProtocol > &obj)
static ObjectType Get(const ValueType &v)
GenericMemberIterator< Const, typename ValueT::EncodingType, typename ValueT::AllocatorType > MemberIterator
static ValueType & Set(ValueType &v, int data, typename ValueType::AllocatorType &)
Reference operator[](DifferenceType n) const
GenericArray & operator=(const GenericArray &rhs)
internal::MaybeAddConst< Const, PlainType >::Type ValueType
SizeType StrLen(const Ch *s)
Custom strlen() which works on different character types.
Iterator & operator+=(DifferenceType n)
difference_type DifferenceType
Signed integer type (e.g. ptrdiff_t)
RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer< T >),(GenericValue &)) operator
Assignment with primitive types.
const ValueT * ConstValueIterator
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with Encoding conversion)
MemberIterator MemberEnd() const
GenericObject< false, ValueType > Object
ValueType & operator[](const GenericValue< EncodingType, SourceAllocator > &name) const
static ValueType & Set(ValueType &v, unsigned data)
bool EraseMember(const GenericValue< EncodingType, SourceAllocator > &name) const
GenericValue(Type type) RAPIDJSON_NOEXCEPT
Constructor with JSON value type.
MemberIterator FindMember(const GenericValue< EncodingType, SourceAllocator > &name) const
A read-write string stream.
(Constant) member iterator for a JSON object value
GenericArray PushBack(ValueType &value, AllocatorType &allocator) const
void * memmove(void *a, const void *b, size_t c)
ValueIterator Erase(ConstValueIterator pos) const
GenericDocument(Type type, Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity, StackAllocator *stackAllocator=0)
Constructor.
RAPIDJSON_FORCEINLINE const Ch * GetStringPointer() const
void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT
Initialize this value as constant string, without calling destructor.
GenericValue(unsigned u) RAPIDJSON_NOEXCEPT
Constructor for unsigned value.
SizeType MemberCapacity() const
static ValueType & Set(ValueType &v, ArrayType data, typename ValueType::AllocatorType &)
#define RAPIDJSON_ASSERT(x)
Assertion.
static bool Is(const ValueType &v)
ValueType * ValueIterator
GenericArray< true, ValueType > ConstArray
Encoding::Ch Ch
Character type derived from Encoding.
bool HasMember(const GenericValue< EncodingType, SourceAllocator > &name) const
ValueType::ConstArray ArrayType
A document for parsing JSON text as DOM.
GenericValue(float f) RAPIDJSON_NOEXCEPT
Constructor for float value.
In-situ(destructive) parsing.
GenericValue(int i) RAPIDJSON_NOEXCEPT
Constructor for int value.
void Swap(Stack &rhs) RAPIDJSON_NOEXCEPT
bool RemoveMember(const Ch *name) const
Allocator AllocatorType
Allocator type from template parameter.
GenericValue(const GenericValue< Encoding, SourceAllocator > &rhs, Allocator &allocator, bool copyConstStrings=false)
Explicit copy constructor (with allocator)
GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT
Constructor for int64_t value.
static bool Get(const ValueType &v)
static bool Is(const ValueType &v)
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.
size_t Offset() const
Get the error offset, if IsError(), 0 otherwise.
GenericArray< false, ValueType > Array
Encoding::Ch Ch
Character type derived from Encoding.
bool operator!=(ConstIterator that) const