1 // Tencent is pleased to support the open source community by making RapidJSON available. 2 // 3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved. 4 // 5 // Licensed under the MIT License (the "License"); you may not use this file except 6 // in compliance with the License. You may obtain a copy of the License at 7 // 8 // http://opensource.org/licenses/MIT 9 // 10 // Unless required by applicable law or agreed to in writing, software distributed 11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the 13 // specific language governing permissions and limitations under the License. 14 15 #ifndef RAPIDJSON_DOCUMENT_H_ 16 #define RAPIDJSON_DOCUMENT_H_ 17 18 /*! \file document.h */ 19 20 #include "reader.h" 21 #include "internal/meta.h" 22 #include "internal/strfunc.h" 23 #include <new> // placement new 24 25 #ifdef _MSC_VER 26 RAPIDJSON_DIAG_PUSH 27 RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant 28 #elif defined(__GNUC__) 29 RAPIDJSON_DIAG_PUSH 30 RAPIDJSON_DIAG_OFF(effc++) 31 #endif 32 33 /////////////////////////////////////////////////////////////////////////////// 34 // RAPIDJSON_HAS_STDSTRING 35 36 #ifndef RAPIDJSON_HAS_STDSTRING 37 #ifdef RAPIDJSON_DOXYGEN_RUNNING 38 #define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation 39 #else 40 #define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default 41 #endif 42 /*! \def RAPIDJSON_HAS_STDSTRING 43 \ingroup RAPIDJSON_CONFIG 44 \brief Enable RapidJSON support for \c std::string 45 46 By defining this preprocessor symbol to \c 1, several convenience functions for using 47 \ref rapidjson::GenericValue with \c std::string are enabled, especially 48 for construction and comparison. 49 50 \hideinitializer 51 */ 52 #endif // !defined(RAPIDJSON_HAS_STDSTRING) 53 54 #if RAPIDJSON_HAS_STDSTRING 55 #include <string> 56 #endif // RAPIDJSON_HAS_STDSTRING 57 58 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS 59 #include <iterator> // std::iterator, std::random_access_iterator_tag 60 #endif 61 62 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 63 #include <utility> // std::move 64 #endif 65 66 RAPIDJSON_NAMESPACE_BEGIN 67 68 // Forward declaration. 69 template <typename Encoding, typename Allocator> 70 class GenericValue; 71 72 template <typename Encoding, typename Allocator, typename StackAllocator> 73 class GenericDocument; 74 75 //! Name-value pair in a JSON object value. 76 /*! 77 This class was internal to GenericValue. It used to be a inner struct. 78 But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct. 79 https://code.google.com/p/rapidjson/issues/detail?id=64 80 */ 81 template <typename Encoding, typename Allocator> 82 struct GenericMember { 83 GenericValue<Encoding, Allocator> name; //!< name of member (must be a string) 84 GenericValue<Encoding, Allocator> value; //!< value of member. 85 }; 86 87 /////////////////////////////////////////////////////////////////////////////// 88 // GenericMemberIterator 89 90 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS 91 92 //! (Constant) member iterator for a JSON object value 93 /*! 94 \tparam Const Is this a constant iterator? 95 \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) 96 \tparam Allocator Allocator type for allocating memory of object, array and string. 97 98 This class implements a Random Access Iterator for GenericMember elements 99 of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements]. 100 101 \note This iterator implementation is mainly intended to avoid implicit 102 conversions from iterator values to \c NULL, 103 e.g. from GenericValue::FindMember. 104 105 \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a 106 pointer-based implementation, if your platform doesn't provide 107 the C++ <iterator> header. 108 109 \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator 110 */ 111 template <bool Const, typename Encoding, typename Allocator> 112 class GenericMemberIterator 113 : public std::iterator<std::random_access_iterator_tag 114 , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> { 115 116 friend class GenericValue<Encoding,Allocator>; 117 template <bool, typename, typename> friend class GenericMemberIterator; 118 119 typedef GenericMember<Encoding,Allocator> PlainType; 120 typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType; 121 typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType; 122 123 public: 124 //! Iterator type itself 125 typedef GenericMemberIterator Iterator; 126 //! Constant iterator type 127 typedef GenericMemberIterator<true,Encoding,Allocator> ConstIterator; 128 //! Non-constant iterator type 129 typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator; 130 131 //! Pointer to (const) GenericMember 132 typedef typename BaseType::pointer Pointer; 133 //! Reference to (const) GenericMember 134 typedef typename BaseType::reference Reference; 135 //! Signed integer type (e.g. \c ptrdiff_t) 136 typedef typename BaseType::difference_type DifferenceType; 137 138 //! Default constructor (singular value) 139 /*! Creates an iterator pointing to no element. 140 \note All operations, except for comparisons, are undefined on such values. 141 */ GenericMemberIterator()142 GenericMemberIterator() : ptr_() {} 143 144 //! Iterator conversions to more const 145 /*! 146 \param it (Non-const) iterator to copy from 147 148 Allows the creation of an iterator from another GenericMemberIterator 149 that is "less const". Especially, creating a non-constant iterator 150 from a constant iterator are disabled: 151 \li const -> non-const (not ok) 152 \li const -> const (ok) 153 \li non-const -> const (ok) 154 \li non-const -> non-const (ok) 155 156 \note If the \c Const template parameter is already \c false, this 157 constructor effectively defines a regular copy-constructor. 158 Otherwise, the copy constructor is implicitly defined. 159 */ GenericMemberIterator(const NonConstIterator & it)160 GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {} 161 162 //! @name stepping 163 //@{ 164 Iterator& operator++(){ ++ptr_; return *this; } 165 Iterator& operator--(){ --ptr_; return *this; } 166 Iterator operator++(int){ Iterator old(*this); ++ptr_; return old; } 167 Iterator operator--(int){ Iterator old(*this); --ptr_; return old; } 168 //@} 169 170 //! @name increment/decrement 171 //@{ 172 Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); } 173 Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); } 174 175 Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; } 176 Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; } 177 //@} 178 179 //! @name relations 180 //@{ 181 bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; } 182 bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; } 183 bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; } 184 bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; } 185 bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; } 186 bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; } 187 //@} 188 189 //! @name dereference 190 //@{ 191 Reference operator*() const { return *ptr_; } 192 Pointer operator->() const { return ptr_; } 193 Reference operator[](DifferenceType n) const { return ptr_[n]; } 194 //@} 195 196 //! Distance 197 DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; } 198 199 private: 200 //! Internal constructor from plain pointer GenericMemberIterator(Pointer p)201 explicit GenericMemberIterator(Pointer p) : ptr_(p) {} 202 203 Pointer ptr_; //!< raw pointer 204 }; 205 206 #else // RAPIDJSON_NOMEMBERITERATORCLASS 207 208 // class-based member iterator implementation disabled, use plain pointers 209 210 template <bool Const, typename Encoding, typename Allocator> 211 struct GenericMemberIterator; 212 213 //! non-const GenericMemberIterator 214 template <typename Encoding, typename Allocator> 215 struct GenericMemberIterator<false,Encoding,Allocator> { 216 //! use plain pointer as iterator type 217 typedef GenericMember<Encoding,Allocator>* Iterator; 218 }; 219 //! const GenericMemberIterator 220 template <typename Encoding, typename Allocator> 221 struct GenericMemberIterator<true,Encoding,Allocator> { 222 //! use plain const pointer as iterator type 223 typedef const GenericMember<Encoding,Allocator>* Iterator; 224 }; 225 226 #endif // RAPIDJSON_NOMEMBERITERATORCLASS 227 228 /////////////////////////////////////////////////////////////////////////////// 229 // GenericStringRef 230 231 //! Reference to a constant string (not taking a copy) 232 /*! 233 \tparam CharType character type of the string 234 235 This helper class is used to automatically infer constant string 236 references for string literals, especially from \c const \b (!) 237 character arrays. 238 239 The main use is for creating JSON string values without copying the 240 source string via an \ref Allocator. This requires that the referenced 241 string pointers have a sufficient lifetime, which exceeds the lifetime 242 of the associated GenericValue. 243 244 \b Example 245 \code 246 Value v("foo"); // ok, no need to copy & calculate length 247 const char foo[] = "foo"; 248 v.SetString(foo); // ok 249 250 const char* bar = foo; 251 // Value x(bar); // not ok, can't rely on bar's lifetime 252 Value x(StringRef(bar)); // lifetime explicitly guaranteed by user 253 Value y(StringRef(bar, 3)); // ok, explicitly pass length 254 \endcode 255 256 \see StringRef, GenericValue::SetString 257 */ 258 template<typename CharType> 259 struct GenericStringRef { 260 typedef CharType Ch; //!< character type of the string 261 262 //! Create string reference from \c const character array 263 /*! 264 This constructor implicitly creates a constant string reference from 265 a \c const character array. It has better performance than 266 \ref StringRef(const CharType*) by inferring the string \ref length 267 from the array length, and also supports strings containing null 268 characters. 269 270 \tparam N length of the string, automatically inferred 271 272 \param str Constant character array, lifetime assumed to be longer 273 than the use of the string in e.g. a GenericValue 274 275 \post \ref s == str 276 277 \note Constant complexity. 278 \note There is a hidden, private overload to disallow references to 279 non-const character arrays to be created via this constructor. 280 By this, e.g. function-scope arrays used to be filled via 281 \c snprintf are excluded from consideration. 282 In such cases, the referenced string should be \b copied to the 283 GenericValue instead. 284 */ 285 template<SizeType N> 286 GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT 287 : s(str), length(N-1) {} 288 289 //! Explicitly create string reference from \c const character pointer 290 /*! 291 This constructor can be used to \b explicitly create a reference to 292 a constant string pointer. 293 294 \see StringRef(const CharType*) 295 296 \param str Constant character pointer, lifetime assumed to be longer 297 than the use of the string in e.g. a GenericValue 298 299 \post \ref s == str 300 301 \note There is a hidden, private overload to disallow references to 302 non-const character arrays to be created via this constructor. 303 By this, e.g. function-scope arrays used to be filled via 304 \c snprintf are excluded from consideration. 305 In such cases, the referenced string should be \b copied to the 306 GenericValue instead. 307 */ 308 explicit GenericStringRef(const CharType* str) 309 : s(str), length(internal::StrLen(str)){ RAPIDJSON_ASSERT(s != NULL); } 310 311 //! Create constant string reference from pointer and length 312 /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue 313 \param len length of the string, excluding the trailing NULL terminator 314 315 \post \ref s == str && \ref length == len 316 \note Constant complexity. 317 */ 318 GenericStringRef(const CharType* str, SizeType len) 319 : s(str), length(len) { RAPIDJSON_ASSERT(s != NULL); } 320 321 //! implicit conversion to plain CharType pointer 322 operator const Ch *() const { return s; } 323 324 const Ch* const s; //!< plain CharType pointer 325 const SizeType length; //!< length of the string (excluding the trailing NULL terminator) 326 327 private: 328 //! Disallow copy-assignment 329 GenericStringRef operator=(const GenericStringRef&); 330 //! Disallow construction from non-const array 331 template<SizeType N> 332 GenericStringRef(CharType (&str)[N]) /* = delete */; 333 }; 334 335 //! Mark a character pointer as constant string 336 /*! Mark a plain character pointer as a "string literal". This function 337 can be used to avoid copying a character string to be referenced as a 338 value in a JSON GenericValue object, if the string's lifetime is known 339 to be valid long enough. 340 \tparam CharType Character type of the string 341 \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue 342 \return GenericStringRef string reference object 343 \relatesalso GenericStringRef 344 345 \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember 346 */ 347 template<typename CharType> 348 inline GenericStringRef<CharType> StringRef(const CharType* str) { 349 return GenericStringRef<CharType>(str, internal::StrLen(str)); 350 } 351 352 //! Mark a character pointer as constant string 353 /*! Mark a plain character pointer as a "string literal". This function 354 can be used to avoid copying a character string to be referenced as a 355 value in a JSON GenericValue object, if the string's lifetime is known 356 to be valid long enough. 357 358 This version has better performance with supplied length, and also 359 supports string containing null characters. 360 361 \tparam CharType character type of the string 362 \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue 363 \param length The length of source string. 364 \return GenericStringRef string reference object 365 \relatesalso GenericStringRef 366 */ 367 template<typename CharType> 368 inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) { 369 return GenericStringRef<CharType>(str, SizeType(length)); 370 } 371 372 #if RAPIDJSON_HAS_STDSTRING 373 //! Mark a string object as constant string 374 /*! Mark a string object (e.g. \c std::string) as a "string literal". 375 This function can be used to avoid copying a string to be referenced as a 376 value in a JSON GenericValue object, if the string's lifetime is known 377 to be valid long enough. 378 379 \tparam CharType character type of the string 380 \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue 381 \return GenericStringRef string reference object 382 \relatesalso GenericStringRef 383 \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. 384 */ 385 template<typename CharType> 386 inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) { 387 return GenericStringRef<CharType>(str.data(), SizeType(str.size())); 388 } 389 #endif 390 391 /////////////////////////////////////////////////////////////////////////////// 392 // GenericValue type traits 393 namespace internal { 394 395 template <typename T, typename Encoding = void, typename Allocator = void> 396 struct IsGenericValueImpl : FalseType {}; 397 398 // select candidates according to nested encoding and allocator types 399 template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type> 400 : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {}; 401 402 // helper to match arbitrary GenericValue instantiations, including derived classes 403 template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {}; 404 405 } // namespace internal 406 407 /////////////////////////////////////////////////////////////////////////////// 408 // GenericValue 409 410 //! Represents a JSON value. Use Value for UTF8 encoding and default allocator. 411 /*! 412 A JSON value can be one of 7 types. This class is a variant type supporting 413 these types. 414 415 Use the Value if UTF8 and default allocator 416 417 \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) 418 \tparam Allocator Allocator type for allocating memory of object, array and string. 419 */ 420 template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 421 class GenericValue { 422 public: 423 //! Name-value pair in an object. 424 typedef GenericMember<Encoding, Allocator> Member; 425 typedef Encoding EncodingType; //!< Encoding type from template parameter. 426 typedef Allocator AllocatorType; //!< Allocator type from template parameter. 427 typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. 428 typedef GenericStringRef<Ch> StringRefType; //!< Reference to a constant string 429 typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator; //!< Member iterator for iterating in object. 430 typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator; //!< Constant member iterator for iterating in object. 431 typedef GenericValue* ValueIterator; //!< Value iterator for iterating in array. 432 typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array. 433 typedef GenericValue<Encoding, Allocator> ValueType; //!< Value type of itself. 434 435 //!@name Constructors and destructor. 436 //@{ 437 438 //! Default constructor creates a null value. 439 GenericValue() RAPIDJSON_NOEXCEPT : data_(), flags_(kNullFlag) {} 440 441 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 442 //! Move constructor in C++11 443 GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_), flags_(rhs.flags_) { 444 rhs.flags_ = kNullFlag; // give up contents 445 } 446 #endif 447 448 private: 449 //! Copy constructor is not permitted. 450 GenericValue(const GenericValue& rhs); 451 452 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 453 //! Moving from a GenericDocument is not permitted. 454 template <typename StackAllocator> 455 GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs); 456 457 //! Move assignment from a GenericDocument is not permitted. 458 template <typename StackAllocator> 459 GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs); 460 #endif 461 462 public: 463 464 //! Constructor with JSON value type. 465 /*! This creates a Value of specified type with default content. 466 \param type Type of the value. 467 \note Default content for number is zero. 468 */ 469 explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_(), flags_() { 470 static const unsigned defaultFlags[7] = { 471 kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag, 472 kNumberAnyFlag 473 }; 474 RAPIDJSON_ASSERT(type <= kNumberType); 475 flags_ = defaultFlags[type]; 476 477 // Use ShortString to store empty string. 478 if (type == kStringType) 479 data_.ss.SetLength(0); 480 } 481 482 //! Explicit copy constructor (with allocator) 483 /*! Creates a copy of a Value by using the given Allocator 484 \tparam SourceAllocator allocator of \c rhs 485 \param rhs Value to copy from (read-only) 486 \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator(). 487 \see CopyFrom() 488 */ 489 template< typename SourceAllocator > 490 GenericValue(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator & allocator); 491 492 //! Constructor for boolean value. 493 /*! \param b Boolean value 494 \note This constructor is limited to \em real boolean values and rejects 495 implicitly converted types like arbitrary pointers. Use an explicit cast 496 to \c bool, if you want to construct a boolean JSON value in such cases. 497 */ 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 501 #else 502 explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT 503 #endif 504 : data_(), flags_(b ? kTrueFlag : kFalseFlag) { 505 // safe-guard against failing SFINAE 506 RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value)); 507 } 508 509 //! Constructor for int value. 510 explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberIntFlag) { 511 data_.n.i64 = i; 512 if (i >= 0) 513 flags_ |= kUintFlag | kUint64Flag; 514 } 515 516 //! Constructor for unsigned value. 517 explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberUintFlag) { 518 data_.n.u64 = u; 519 if (!(u & 0x80000000)) 520 flags_ |= kIntFlag | kInt64Flag; 521 } 522 523 //! Constructor for int64_t value. 524 explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberInt64Flag) { 525 data_.n.i64 = i64; 526 if (i64 >= 0) { 527 flags_ |= kNumberUint64Flag; 528 if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) 529 flags_ |= kUintFlag; 530 if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) 531 flags_ |= kIntFlag; 532 } 533 else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) 534 flags_ |= kIntFlag; 535 } 536 537 //! Constructor for uint64_t value. 538 explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberUint64Flag) { 539 data_.n.u64 = u64; 540 if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000))) 541 flags_ |= kInt64Flag; 542 if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) 543 flags_ |= kUintFlag; 544 if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) 545 flags_ |= kIntFlag; 546 } 547 548 //! Constructor for double value. 549 explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberDoubleFlag) { data_.n.d = d; } 550 551 //! Constructor for constant string (i.e. do not make a copy of string) 552 GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_(), flags_() { SetStringRaw(StringRef(s, length)); } 553 554 //! Constructor for constant string (i.e. do not make a copy of string) 555 explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_(), flags_() { SetStringRaw(s); } 556 557 //! Constructor for copy-string (i.e. do make a copy of string) 558 GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_(), flags_() { SetStringRaw(StringRef(s, length), allocator); } 559 560 //! Constructor for copy-string (i.e. do make a copy of string) 561 GenericValue(const Ch*s, Allocator& allocator) : data_(), flags_() { SetStringRaw(StringRef(s), allocator); } 562 563 #if RAPIDJSON_HAS_STDSTRING 564 //! Constructor for copy-string from a string object (i.e. do make a copy of string) 565 /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. 566 */ 567 GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_(), flags_() { SetStringRaw(StringRef(s), allocator); } 568 #endif 569 570 //! Destructor. 571 /*! Need to destruct elements of array, members of object, or copy-string. 572 */ 573 ~GenericValue() { 574 if (Allocator::kNeedFree) { // Shortcut by Allocator's trait 575 switch(flags_) { 576 case kArrayFlag: 577 for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v) 578 v->~GenericValue(); 579 Allocator::Free(data_.a.elements); 580 break; 581 582 case kObjectFlag: 583 for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) 584 m->~Member(); 585 Allocator::Free(data_.o.members); 586 break; 587 588 case kCopyStringFlag: 589 Allocator::Free(const_cast<Ch*>(data_.s.str)); 590 break; 591 592 default: 593 break; // Do nothing for other types. 594 } 595 } 596 } 597 598 //@} 599 600 //!@name Assignment operators 601 //@{ 602 603 //! Assignment with move semantics. 604 /*! \param rhs Source of the assignment. It will become a null value after assignment. 605 */ 606 GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT { 607 RAPIDJSON_ASSERT(this != &rhs); 608 this->~GenericValue(); 609 RawAssign(rhs); 610 return *this; 611 } 612 613 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 614 //! Move assignment in C++11 615 GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT { 616 return *this = rhs.Move(); 617 } 618 #endif 619 620 //! Assignment of constant string reference (no copy) 621 /*! \param str Constant string reference to be assigned 622 \note This overload is needed to avoid clashes with the generic primitive type assignment overload below. 623 \see GenericStringRef, operator=(T) 624 */ 625 GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT { 626 GenericValue s(str); 627 return *this = s; 628 } 629 630 //! Assignment with primitive types. 631 /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t 632 \param value The value to be assigned. 633 634 \note The source type \c T explicitly disallows all pointer types, 635 especially (\c const) \ref Ch*. This helps avoiding implicitly 636 referencing character strings with insufficient lifetime, use 637 \ref SetString(const Ch*, Allocator&) (for copying) or 638 \ref StringRef() (to explicitly mark the pointer as constant) instead. 639 All other pointer types would implicitly convert to \c bool, 640 use \ref SetBool() instead. 641 */ 642 template <typename T> 643 RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&)) 644 operator=(T value) { 645 GenericValue v(value); 646 return *this = v; 647 } 648 649 //! Deep-copy assignment from Value 650 /*! Assigns a \b copy of the Value to the current Value object 651 \tparam SourceAllocator Allocator type of \c rhs 652 \param rhs Value to copy from (read-only) 653 \param allocator Allocator to use for copying 654 */ 655 template <typename SourceAllocator> 656 GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator) { 657 RAPIDJSON_ASSERT((void*)this != (void const*)&rhs); 658 this->~GenericValue(); 659 new (this) GenericValue(rhs, allocator); 660 return *this; 661 } 662 663 //! Exchange the contents of this value with those of other. 664 /*! 665 \param other Another value. 666 \note Constant complexity. 667 */ 668 GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT { 669 GenericValue temp; 670 temp.RawAssign(*this); 671 RawAssign(other); 672 other.RawAssign(temp); 673 return *this; 674 } 675 676 //! free-standing swap function helper 677 /*! 678 Helper function to enable support for common swap implementation pattern based on \c std::swap: 679 \code 680 void swap(MyClass& a, MyClass& b) { 681 using std::swap; 682 swap(a.value, b.value); 683 // ... 684 } 685 \endcode 686 \see Swap() 687 */ 688 friend inline void swap(GenericValue& a, GenericValue& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } 689 690 //! Prepare Value for move semantics 691 /*! \return *this */ 692 GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; } 693 //@} 694 695 //!@name Equal-to and not-equal-to operators 696 //@{ 697 //! Equal-to operator 698 /*! 699 \note If an object contains duplicated named member, comparing equality with any object is always \c false. 700 \note Linear time complexity (number of all values in the subtree and total lengths of all strings). 701 */ 702 template <typename SourceAllocator> 703 bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const { 704 typedef GenericValue<Encoding, SourceAllocator> RhsType; 705 if (GetType() != rhs.GetType()) 706 return false; 707 708 switch (GetType()) { 709 case kObjectType: // Warning: O(n^2) inner-loop 710 if (data_.o.size != rhs.data_.o.size) 711 return false; 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) 715 return false; 716 } 717 return true; 718 719 case kArrayType: 720 if (data_.a.size != rhs.data_.a.size) 721 return false; 722 for (SizeType i = 0; i < data_.a.size; i++) 723 if ((*this)[i] != rhs[i]) 724 return false; 725 return true; 726 727 case kStringType: 728 return StringEqual(rhs); 729 730 case kNumberType: 731 if (IsDouble() || rhs.IsDouble()) { 732 double a = GetDouble(); // May convert from integer to double. 733 double b = rhs.GetDouble(); // Ditto 734 return a >= b && a <= b; // Prevent -Wfloat-equal 735 } 736 else 737 return data_.n.u64 == rhs.data_.n.u64; 738 739 default: // kTrueType, kFalseType, kNullType 740 return true; 741 } 742 } 743 744 //! Equal-to operator with const C-string pointer 745 bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); } 746 747 #if RAPIDJSON_HAS_STDSTRING 748 //! Equal-to operator with string object 749 /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. 750 */ 751 bool operator==(const std::basic_string<Ch>& rhs) const { return *this == GenericValue(StringRef(rhs)); } 752 #endif 753 754 //! Equal-to operator with primitive types 755 /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false 756 */ 757 template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); } 758 759 //! Not-equal-to operator 760 /*! \return !(*this == rhs) 761 */ 762 template <typename SourceAllocator> 763 bool operator!=(const GenericValue<Encoding, SourceAllocator>& rhs) const { return !(*this == rhs); } 764 765 //! Not-equal-to operator with const C-string pointer 766 bool operator!=(const Ch* rhs) const { return !(*this == rhs); } 767 768 //! Not-equal-to operator with arbitrary types 769 /*! \return !(*this == rhs) 770 */ 771 template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); } 772 773 //! Equal-to operator with arbitrary types (symmetric version) 774 /*! \return (rhs == lhs) 775 */ 776 template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; } 777 778 //! Not-Equal-to operator with arbitrary types (symmetric version) 779 /*! \return !(rhs == lhs) 780 */ 781 template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); } 782 //@} 783 784 //!@name Type 785 //@{ 786 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; } 801 802 //@} 803 804 //!@name Null 805 //@{ 806 807 GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; } 808 809 //@} 810 811 //!@name Bool 812 //@{ 813 814 bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return flags_ == kTrueFlag; } 815 //!< Set boolean value 816 /*! \post IsBool() == true */ 817 GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; } 818 819 //@} 820 821 //!@name Object 822 //@{ 823 824 //! Set this value as an empty object. 825 /*! \post IsObject() == true */ 826 GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; } 827 828 //! Get the number of members in the object. 829 SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; } 830 831 //! Check whether the object is empty. 832 bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; } 833 834 //! Get a value from an object associated with the name. 835 /*! \pre IsObject() == true 836 \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType)) 837 \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7. 838 Since 0.2, if the name is not correct, it will assert. 839 If user is unsure whether a member exists, user should use HasMember() first. 840 A better approach is to use FindMember(). 841 \note Linear time complexity. 842 */ 843 template <typename T> 844 RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) { 845 GenericValue n(StringRef(name)); 846 return (*this)[n]; 847 } 848 template <typename T> 849 RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; } 850 851 //! Get a value from an object associated with the name. 852 /*! \pre IsObject() == true 853 \tparam SourceAllocator Allocator of the \c name value 854 855 \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen(). 856 And it can also handle strings with embedded null characters. 857 858 \note Linear time complexity. 859 */ 860 template <typename SourceAllocator> 861 GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) { 862 MemberIterator member = FindMember(name); 863 if (member != MemberEnd()) 864 return member->value; 865 else { 866 RAPIDJSON_ASSERT(false); // see above note 867 static GenericValue NullValue; 868 return NullValue; 869 } 870 } 871 template <typename SourceAllocator> 872 const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; } 873 874 #if RAPIDJSON_HAS_STDSTRING 875 //! Get a value from an object associated with name (string object). 876 GenericValue& operator[](const std::basic_string<Ch>& name) { return (*this)[GenericValue(StringRef(name))]; } 877 const GenericValue& operator[](const std::basic_string<Ch>& name) const { return (*this)[GenericValue(StringRef(name))]; } 878 #endif 879 880 //! Const member iterator 881 /*! \pre IsObject() == true */ 882 ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(data_.o.members); } 883 //! Const \em past-the-end member iterator 884 /*! \pre IsObject() == true */ 885 ConstMemberIterator MemberEnd() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(data_.o.members + data_.o.size); } 886 //! Member iterator 887 /*! \pre IsObject() == true */ 888 MemberIterator MemberBegin() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(data_.o.members); } 889 //! \em Past-the-end member iterator 890 /*! \pre IsObject() == true */ 891 MemberIterator MemberEnd() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(data_.o.members + data_.o.size); } 892 893 //! Check whether a member exists in the object. 894 /*! 895 \param name Member name to be searched. 896 \pre IsObject() == true 897 \return Whether a member with that name exists. 898 \note It is better to use FindMember() directly if you need the obtain the value as well. 899 \note Linear time complexity. 900 */ 901 bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); } 902 903 #if RAPIDJSON_HAS_STDSTRING 904 //! Check whether a member exists in the object with string object. 905 /*! 906 \param name Member name to be searched. 907 \pre IsObject() == true 908 \return Whether a member with that name exists. 909 \note It is better to use FindMember() directly if you need the obtain the value as well. 910 \note Linear time complexity. 911 */ 912 bool HasMember(const std::basic_string<Ch>& name) const { return FindMember(name) != MemberEnd(); } 913 #endif 914 915 //! Check whether a member exists in the object with GenericValue name. 916 /*! 917 This version is faster because it does not need a StrLen(). It can also handle string with null character. 918 \param name Member name to be searched. 919 \pre IsObject() == true 920 \return Whether a member with that name exists. 921 \note It is better to use FindMember() directly if you need the obtain the value as well. 922 \note Linear time complexity. 923 */ 924 template <typename SourceAllocator> 925 bool HasMember(const GenericValue<Encoding, SourceAllocator>& name) const { return FindMember(name) != MemberEnd(); } 926 927 //! Find member by name. 928 /*! 929 \param name Member name to be searched. 930 \pre IsObject() == true 931 \return Iterator to member, if it exists. 932 Otherwise returns \ref MemberEnd(). 933 934 \note Earlier versions of Rapidjson returned a \c NULL pointer, in case 935 the requested member doesn't exist. For consistency with e.g. 936 \c std::map, this has been changed to MemberEnd() now. 937 \note Linear time complexity. 938 */ 939 MemberIterator FindMember(const Ch* name) { 940 GenericValue n(StringRef(name)); 941 return FindMember(n); 942 } 943 944 ConstMemberIterator FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); } 945 946 //! Find member by name. 947 /*! 948 This version is faster because it does not need a StrLen(). It can also handle string with null character. 949 \param name Member name to be searched. 950 \pre IsObject() == true 951 \return Iterator to member, if it exists. 952 Otherwise returns \ref MemberEnd(). 953 954 \note Earlier versions of Rapidjson returned a \c NULL pointer, in case 955 the requested member doesn't exist. For consistency with e.g. 956 \c std::map, this has been changed to MemberEnd() now. 957 \note Linear time complexity. 958 */ 959 template <typename SourceAllocator> 960 MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) { 961 RAPIDJSON_ASSERT(IsObject()); 962 RAPIDJSON_ASSERT(name.IsString()); 963 MemberIterator member = MemberBegin(); 964 for ( ; member != MemberEnd(); ++member) 965 if (name.StringEqual(member->name)) 966 break; 967 return member; 968 } 969 template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); } 970 971 #if RAPIDJSON_HAS_STDSTRING 972 //! Find member by string object name. 973 /*! 974 \param name Member name to be searched. 975 \pre IsObject() == true 976 \return Iterator to member, if it exists. 977 Otherwise returns \ref MemberEnd(). 978 */ 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)); } 981 #endif 982 983 //! Add a member (name-value pair) to the object. 984 /*! \param name A string value as name of member. 985 \param value Value of any type. 986 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 987 \return The value itself for fluent API. 988 \note The ownership of \c name and \c value will be transferred to this object on success. 989 \pre IsObject() && name.IsString() 990 \post name.IsNull() && value.IsNull() 991 \note Amortized Constant time complexity. 992 */ 993 GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) { 994 RAPIDJSON_ASSERT(IsObject()); 995 RAPIDJSON_ASSERT(name.IsString()); 996 997 Object& o = data_.o; 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))); 1002 } 1003 else { 1004 SizeType oldCapacity = o.capacity; 1005 o.capacity += (oldCapacity + 1) / 2; // grow by factor 1.5 1006 o.members = reinterpret_cast<Member*>(allocator.Realloc(o.members, oldCapacity * sizeof(Member), o.capacity * sizeof(Member))); 1007 } 1008 } 1009 o.members[o.size].name.RawAssign(name); 1010 o.members[o.size].value.RawAssign(value); 1011 o.size++; 1012 return *this; 1013 } 1014 1015 //! Add a constant string value as member (name-value pair) to the object. 1016 /*! \param name A string value as name of member. 1017 \param value constant string reference as value of member. 1018 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1019 \return The value itself for fluent API. 1020 \pre IsObject() 1021 \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below. 1022 \note Amortized Constant time complexity. 1023 */ 1024 GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) { 1025 GenericValue v(value); 1026 return AddMember(name, v, allocator); 1027 } 1028 1029 #if RAPIDJSON_HAS_STDSTRING 1030 //! Add a string object as member (name-value pair) to the object. 1031 /*! \param name A string value as name of member. 1032 \param value constant string reference as value of member. 1033 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1034 \return The value itself for fluent API. 1035 \pre IsObject() 1036 \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below. 1037 \note Amortized Constant time complexity. 1038 */ 1039 GenericValue& AddMember(GenericValue& name, std::basic_string<Ch>& value, Allocator& allocator) { 1040 GenericValue v(value, allocator); 1041 return AddMember(name, v, allocator); 1042 } 1043 #endif 1044 1045 //! Add any primitive value as member (name-value pair) to the object. 1046 /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t 1047 \param name A string value as name of member. 1048 \param value Value of primitive type \c T as value of member 1049 \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator(). 1050 \return The value itself for fluent API. 1051 \pre IsObject() 1052 1053 \note The source type \c T explicitly disallows all pointer types, 1054 especially (\c const) \ref Ch*. This helps avoiding implicitly 1055 referencing character strings with insufficient lifetime, use 1056 \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref 1057 AddMember(StringRefType, StringRefType, Allocator&). 1058 All other pointer types would implicitly convert to \c bool, 1059 use an explicit cast instead, if needed. 1060 \note Amortized Constant time complexity. 1061 */ 1062 template <typename T> 1063 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&)) 1064 AddMember(GenericValue& name, T value, Allocator& allocator) { 1065 GenericValue v(value); 1066 return AddMember(name, v, allocator); 1067 } 1068 1069 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1070 GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) { 1071 return AddMember(name, value, allocator); 1072 } 1073 GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) { 1074 return AddMember(name, value, allocator); 1075 } 1076 GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) { 1077 return AddMember(name, value, allocator); 1078 } 1079 GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) { 1080 GenericValue n(name); 1081 return AddMember(n, value, allocator); 1082 } 1083 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 1084 1085 1086 //! Add a member (name-value pair) to the object. 1087 /*! \param name A constant string reference as name of member. 1088 \param value Value of any type. 1089 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1090 \return The value itself for fluent API. 1091 \note The ownership of \c value will be transferred to this object on success. 1092 \pre IsObject() 1093 \post value.IsNull() 1094 \note Amortized Constant time complexity. 1095 */ 1096 GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) { 1097 GenericValue n(name); 1098 return AddMember(n, value, allocator); 1099 } 1100 1101 //! Add a constant string value as member (name-value pair) to the object. 1102 /*! \param name A constant string reference as name of member. 1103 \param value constant string reference as value of member. 1104 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1105 \return The value itself for fluent API. 1106 \pre IsObject() 1107 \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below. 1108 \note Amortized Constant time complexity. 1109 */ 1110 GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) { 1111 GenericValue v(value); 1112 return AddMember(name, v, allocator); 1113 } 1114 1115 //! Add any primitive value as member (name-value pair) to the object. 1116 /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t 1117 \param name A constant string reference as name of member. 1118 \param value Value of primitive type \c T as value of member 1119 \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator(). 1120 \return The value itself for fluent API. 1121 \pre IsObject() 1122 1123 \note The source type \c T explicitly disallows all pointer types, 1124 especially (\c const) \ref Ch*. This helps avoiding implicitly 1125 referencing character strings with insufficient lifetime, use 1126 \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref 1127 AddMember(StringRefType, StringRefType, Allocator&). 1128 All other pointer types would implicitly convert to \c bool, 1129 use an explicit cast instead, if needed. 1130 \note Amortized Constant time complexity. 1131 */ 1132 template <typename T> 1133 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&)) 1134 AddMember(StringRefType name, T value, Allocator& allocator) { 1135 GenericValue n(name); 1136 return AddMember(n, value, allocator); 1137 } 1138 1139 //! Remove all members in the object. 1140 /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged. 1141 \note Linear time complexity. 1142 */ 1143 void RemoveAllMembers() { 1144 RAPIDJSON_ASSERT(IsObject()); 1145 for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) 1146 m->~Member(); 1147 data_.o.size = 0; 1148 } 1149 1150 //! Remove a member in object by its name. 1151 /*! \param name Name of member to be removed. 1152 \return Whether the member existed. 1153 \note This function may reorder the object members. Use \ref 1154 EraseMember(ConstMemberIterator) if you need to preserve the 1155 relative order of the remaining members. 1156 \note Linear time complexity. 1157 */ 1158 bool RemoveMember(const Ch* name) { 1159 GenericValue n(StringRef(name)); 1160 return RemoveMember(n); 1161 } 1162 1163 #if RAPIDJSON_HAS_STDSTRING 1164 bool RemoveMember(const std::basic_string<Ch>& name) { return RemoveMember(GenericValue(StringRef(name))); } 1165 #endif 1166 1167 template <typename SourceAllocator> 1168 bool RemoveMember(const GenericValue<Encoding, SourceAllocator>& name) { 1169 MemberIterator m = FindMember(name); 1170 if (m != MemberEnd()) { 1171 RemoveMember(m); 1172 return true; 1173 } 1174 else 1175 return false; 1176 } 1177 1178 //! Remove a member in object by iterator. 1179 /*! \param m member iterator (obtained by FindMember() or MemberBegin()). 1180 \return the new iterator after removal. 1181 \note This function may reorder the object members. Use \ref 1182 EraseMember(ConstMemberIterator) if you need to preserve the 1183 relative order of the remaining members. 1184 \note Constant time complexity. 1185 */ 1186 MemberIterator RemoveMember(MemberIterator m) { 1187 RAPIDJSON_ASSERT(IsObject()); 1188 RAPIDJSON_ASSERT(data_.o.size > 0); 1189 RAPIDJSON_ASSERT(data_.o.members != 0); 1190 RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd()); 1191 1192 MemberIterator last(data_.o.members + (data_.o.size - 1)); 1193 if (data_.o.size > 1 && m != last) { 1194 // Move the last one to this place 1195 *m = *last; 1196 } 1197 else { 1198 // Only one left, just destroy 1199 m->~Member(); 1200 } 1201 --data_.o.size; 1202 return m; 1203 } 1204 1205 //! Remove a member from an object by iterator. 1206 /*! \param pos iterator to the member to remove 1207 \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd() 1208 \return Iterator following the removed element. 1209 If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned. 1210 \note This function preserves the relative order of the remaining object 1211 members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator). 1212 \note Linear time complexity. 1213 */ 1214 MemberIterator EraseMember(ConstMemberIterator pos) { 1215 return EraseMember(pos, pos +1); 1216 } 1217 1218 //! Remove members in the range [first, last) from an object. 1219 /*! \param first iterator to the first member to remove 1220 \param last iterator following the last member to remove 1221 \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd() 1222 \return Iterator following the last removed element. 1223 \note This function preserves the relative order of the remaining object 1224 members. 1225 \note Linear time complexity. 1226 */ 1227 MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) { 1228 RAPIDJSON_ASSERT(IsObject()); 1229 RAPIDJSON_ASSERT(data_.o.size > 0); 1230 RAPIDJSON_ASSERT(data_.o.members != 0); 1231 RAPIDJSON_ASSERT(first >= MemberBegin()); 1232 RAPIDJSON_ASSERT(first <= last); 1233 RAPIDJSON_ASSERT(last <= MemberEnd()); 1234 1235 MemberIterator pos = MemberBegin() + (first - MemberBegin()); 1236 for (MemberIterator itr = pos; itr != last; ++itr) 1237 itr->~Member(); 1238 std::memmove(&*pos, &*last, (MemberEnd() - last) * sizeof(Member)); 1239 data_.o.size -= (last - first); 1240 return pos; 1241 } 1242 1243 //! Erase a member in object by its name. 1244 /*! \param name Name of member to be removed. 1245 \return Whether the member existed. 1246 \note Linear time complexity. 1247 */ 1248 bool EraseMember(const Ch* name) { 1249 GenericValue n(StringRef(name)); 1250 return EraseMember(n); 1251 } 1252 1253 #if RAPIDJSON_HAS_STDSTRING 1254 bool EraseMember(const std::basic_string<Ch>& name) { return EraseMember(GenericValue(StringRef(name))); } 1255 #endif 1256 1257 template <typename SourceAllocator> 1258 bool EraseMember(const GenericValue<Encoding, SourceAllocator>& name) { 1259 MemberIterator m = FindMember(name); 1260 if (m != MemberEnd()) { 1261 EraseMember(m); 1262 return true; 1263 } 1264 else 1265 return false; 1266 } 1267 1268 //@} 1269 1270 //!@name Array 1271 //@{ 1272 1273 //! Set this value as an empty array. 1274 /*! \post IsArray == true */ 1275 GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; } 1276 1277 //! Get the number of elements in array. 1278 SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; } 1279 1280 //! Get the capacity of array. 1281 SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; } 1282 1283 //! Check whether the array is empty. 1284 bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; } 1285 1286 //! Remove all elements in the array. 1287 /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged. 1288 \note Linear time complexity. 1289 */ 1290 void Clear() { 1291 RAPIDJSON_ASSERT(IsArray()); 1292 for (SizeType i = 0; i < data_.a.size; ++i) 1293 data_.a.elements[i].~GenericValue(); 1294 data_.a.size = 0; 1295 } 1296 1297 //! Get an element from array by index. 1298 /*! \pre IsArray() == true 1299 \param index Zero-based index of element. 1300 \see operator[](T*) 1301 */ 1302 GenericValue& operator[](SizeType index) { 1303 RAPIDJSON_ASSERT(IsArray()); 1304 RAPIDJSON_ASSERT(index < data_.a.size); 1305 return data_.a.elements[index]; 1306 } 1307 const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; } 1308 1309 //! Element iterator 1310 /*! \pre IsArray() == true */ 1311 ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements; } 1312 //! \em Past-the-end element iterator 1313 /*! \pre IsArray() == true */ 1314 ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements + data_.a.size; } 1315 //! Constant element iterator 1316 /*! \pre IsArray() == true */ 1317 ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); } 1318 //! Constant \em past-the-end element iterator 1319 /*! \pre IsArray() == true */ 1320 ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); } 1321 1322 //! Request the array to have enough capacity to store elements. 1323 /*! \param newCapacity The capacity that the array at least need to have. 1324 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1325 \return The value itself for fluent API. 1326 \note Linear time complexity. 1327 */ 1328 GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) { 1329 RAPIDJSON_ASSERT(IsArray()); 1330 if (newCapacity > data_.a.capacity) { 1331 data_.a.elements = (GenericValue*)allocator.Realloc(data_.a.elements, data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue)); 1332 data_.a.capacity = newCapacity; 1333 } 1334 return *this; 1335 } 1336 1337 //! Append a GenericValue at the end of the array. 1338 /*! \param value Value to be appended. 1339 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1340 \pre IsArray() == true 1341 \post value.IsNull() == true 1342 \return The value itself for fluent API. 1343 \note The ownership of \c value will be transferred to this array on success. 1344 \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. 1345 \note Amortized constant time complexity. 1346 */ 1347 GenericValue& PushBack(GenericValue& value, Allocator& allocator) { 1348 RAPIDJSON_ASSERT(IsArray()); 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); 1352 return *this; 1353 } 1354 1355 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1356 GenericValue& PushBack(GenericValue&& value, Allocator& allocator) { 1357 return PushBack(value, allocator); 1358 } 1359 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 1360 1361 //! Append a constant string reference at the end of the array. 1362 /*! \param value Constant string reference to be appended. 1363 \param allocator Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator(). 1364 \pre IsArray() == true 1365 \return The value itself for fluent API. 1366 \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. 1367 \note Amortized constant time complexity. 1368 \see GenericStringRef 1369 */ 1370 GenericValue& PushBack(StringRefType value, Allocator& allocator) { 1371 return (*this).template PushBack<StringRefType>(value, allocator); 1372 } 1373 1374 //! Append a primitive value at the end of the array. 1375 /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t 1376 \param value Value of primitive type T to be appended. 1377 \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). 1378 \pre IsArray() == true 1379 \return The value itself for fluent API. 1380 \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. 1381 1382 \note The source type \c T explicitly disallows all pointer types, 1383 especially (\c const) \ref Ch*. This helps avoiding implicitly 1384 referencing character strings with insufficient lifetime, use 1385 \ref PushBack(GenericValue&, Allocator&) or \ref 1386 PushBack(StringRefType, Allocator&). 1387 All other pointer types would implicitly convert to \c bool, 1388 use an explicit cast instead, if needed. 1389 \note Amortized constant time complexity. 1390 */ 1391 template <typename T> 1392 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&)) 1393 PushBack(T value, Allocator& allocator) { 1394 GenericValue v(value); 1395 return PushBack(v, allocator); 1396 } 1397 1398 //! Remove the last element in the array. 1399 /*! 1400 \note Constant time complexity. 1401 */ 1402 GenericValue& PopBack() { 1403 RAPIDJSON_ASSERT(IsArray()); 1404 RAPIDJSON_ASSERT(!Empty()); 1405 data_.a.elements[--data_.a.size].~GenericValue(); 1406 return *this; 1407 } 1408 1409 //! Remove an element of array by iterator. 1410 /*! 1411 \param pos iterator to the element to remove 1412 \pre IsArray() == true && \ref Begin() <= \c pos < \ref End() 1413 \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned. 1414 \note Linear time complexity. 1415 */ 1416 ValueIterator Erase(ConstValueIterator pos) { 1417 return Erase(pos, pos + 1); 1418 } 1419 1420 //! Remove elements in the range [first, last) of the array. 1421 /*! 1422 \param first iterator to the first element to remove 1423 \param last iterator following the last element to remove 1424 \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End() 1425 \return Iterator following the last removed element. 1426 \note Linear time complexity. 1427 */ 1428 ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) { 1429 RAPIDJSON_ASSERT(IsArray()); 1430 RAPIDJSON_ASSERT(data_.a.size > 0); 1431 RAPIDJSON_ASSERT(data_.a.elements != 0); 1432 RAPIDJSON_ASSERT(first >= Begin()); 1433 RAPIDJSON_ASSERT(first <= last); 1434 RAPIDJSON_ASSERT(last <= End()); 1435 ValueIterator pos = Begin() + (first - Begin()); 1436 for (ValueIterator itr = pos; itr != last; ++itr) 1437 itr->~GenericValue(); 1438 std::memmove(pos, last, (End() - last) * sizeof(GenericValue)); 1439 data_.a.size -= (last - first); 1440 return pos; 1441 } 1442 1443 //@} 1444 1445 //!@name Number 1446 //@{ 1447 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; } 1450 int64_t GetInt64() const { RAPIDJSON_ASSERT(flags_ & kInt64Flag); return data_.n.i64; } 1451 uint64_t GetUint64() const { RAPIDJSON_ASSERT(flags_ & kUint64Flag); return data_.n.u64; } 1452 1453 double GetDouble() const { 1454 RAPIDJSON_ASSERT(IsNumber()); 1455 if ((flags_ & kDoubleFlag) != 0) return data_.n.d; // exact type, no conversion. 1456 if ((flags_ & kIntFlag) != 0) return data_.n.i.i; // int -> double 1457 if ((flags_ & kUintFlag) != 0) return data_.n.u.u; // unsigned -> double 1458 if ((flags_ & kInt64Flag) != 0) return (double)data_.n.i64; // int64_t -> double (may lose precision) 1459 RAPIDJSON_ASSERT((flags_ & kUint64Flag) != 0); return (double)data_.n.u64; // uint64_t -> double (may lose precision) 1460 } 1461 1462 GenericValue& SetInt(int i) { this->~GenericValue(); new (this) GenericValue(i); return *this; } 1463 GenericValue& SetUint(unsigned u) { this->~GenericValue(); new (this) GenericValue(u); return *this; } 1464 GenericValue& SetInt64(int64_t i64) { this->~GenericValue(); new (this) GenericValue(i64); return *this; } 1465 GenericValue& SetUint64(uint64_t u64) { this->~GenericValue(); new (this) GenericValue(u64); return *this; } 1466 GenericValue& SetDouble(double d) { this->~GenericValue(); new (this) GenericValue(d); return *this; } 1467 1468 //@} 1469 1470 //!@name String 1471 //@{ 1472 1473 const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return ((flags_ & kInlineStrFlag) ? data_.ss.str : data_.s.str); } 1474 1475 //! Get the length of string. 1476 /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength(). 1477 */ 1478 SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return ((flags_ & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); } 1479 1480 //! Set this value as a string without copying source string. 1481 /*! This version has better performance with supplied length, and also support string containing null character. 1482 \param s source string pointer. 1483 \param length The length of source string, excluding the trailing null terminator. 1484 \return The value itself for fluent API. 1485 \post IsString() == true && GetString() == s && GetStringLength() == length 1486 \see SetString(StringRefType) 1487 */ 1488 GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); } 1489 1490 //! Set this value as a string without copying source string. 1491 /*! \param s source string reference 1492 \return The value itself for fluent API. 1493 \post IsString() == true && GetString() == s && GetStringLength() == s.length 1494 */ 1495 GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; } 1496 1497 //! Set this value as a string by copying from source string. 1498 /*! This version has better performance with supplied length, and also support string containing null character. 1499 \param s source string. 1500 \param length The length of source string, excluding the trailing null terminator. 1501 \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). 1502 \return The value itself for fluent API. 1503 \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length 1504 */ 1505 GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(StringRef(s, length), allocator); return *this; } 1506 1507 //! Set this value as a string by copying from source string. 1508 /*! \param s source string. 1509 \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). 1510 \return The value itself for fluent API. 1511 \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length 1512 */ 1513 GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(s, internal::StrLen(s), allocator); } 1514 1515 #if RAPIDJSON_HAS_STDSTRING 1516 //! Set this value as a string by copying from source string. 1517 /*! \param s source string. 1518 \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). 1519 \return The value itself for fluent API. 1520 \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size() 1521 \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. 1522 */ 1523 GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(s.data(), SizeType(s.size()), allocator); } 1524 #endif 1525 1526 //@} 1527 1528 //! Generate events of this value to a Handler. 1529 /*! This function adopts the GoF visitor pattern. 1530 Typical usage is to output this JSON value as JSON text via Writer, which is a Handler. 1531 It can also be used to deep clone this value via GenericDocument, which is also a Handler. 1532 \tparam Handler type of handler. 1533 \param handler An object implementing concept Handler. 1534 */ 1535 template <typename Handler> 1536 bool Accept(Handler& handler) const { 1537 switch(GetType()) { 1538 case kNullType: return handler.Null(); 1539 case kFalseType: return handler.Bool(false); 1540 case kTrueType: return handler.Bool(true); 1541 1542 case kObjectType: 1543 if (!handler.StartObject()) 1544 return false; 1545 for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) { 1546 RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator. 1547 if (!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.flags_ & kCopyFlag) != 0)) 1548 return false; 1549 if (!m->value.Accept(handler)) 1550 return false; 1551 } 1552 return handler.EndObject(data_.o.size); 1553 1554 case kArrayType: 1555 if (!handler.StartArray()) 1556 return false; 1557 for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v) 1558 if (!v->Accept(handler)) 1559 return false; 1560 return handler.EndArray(data_.a.size); 1561 1562 case kStringType: 1563 return handler.String(GetString(), GetStringLength(), (flags_ & kCopyFlag) != 0); 1564 1565 default: 1566 RAPIDJSON_ASSERT(GetType() == kNumberType); 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); 1572 } 1573 } 1574 1575 private: 1576 template <typename, typename> friend class GenericValue; 1577 template <typename, typename, typename> friend class GenericDocument; 1578 1579 enum { 1580 kBoolFlag = 0x100, 1581 kNumberFlag = 0x200, 1582 kIntFlag = 0x400, 1583 kUintFlag = 0x800, 1584 kInt64Flag = 0x1000, 1585 kUint64Flag = 0x2000, 1586 kDoubleFlag = 0x4000, 1587 kStringFlag = 0x100000, 1588 kCopyFlag = 0x200000, 1589 kInlineStrFlag = 0x400000, 1590 1591 // Initial flags of different types. 1592 kNullFlag = kNullType, 1593 kTrueFlag = kTrueType | kBoolFlag, 1594 kFalseFlag = kFalseType | kBoolFlag, 1595 kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag, 1596 kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag, 1597 kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag, 1598 kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag, 1599 kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag, 1600 kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag, 1601 kConstStringFlag = kStringType | kStringFlag, 1602 kCopyStringFlag = kStringType | kStringFlag | kCopyFlag, 1603 kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag, 1604 kObjectFlag = kObjectType, 1605 kArrayFlag = kArrayType, 1606 1607 kTypeMask = 0xFF // bitwise-and with mask of 0xFF can be optimized by compiler 1608 }; 1609 1610 static const SizeType kDefaultArrayCapacity = 16; 1611 static const SizeType kDefaultObjectCapacity = 16; 1612 1613 struct String { 1614 const Ch* str; 1615 SizeType length; 1616 unsigned hashcode; //!< reserved 1617 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode 1618 1619 // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars 1620 // (excluding the terminating zero) and store a value to determine the length of the contained 1621 // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string 1622 // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as 1623 // the string terminator as well. For getting the string length back from that value just use 1624 // "MaxSize - str[LenPos]". 1625 // This allows to store 11-chars strings in 32-bit mode and 15-chars strings in 64-bit mode 1626 // inline (for `UTF8`-encoded strings). 1627 struct ShortString { 1628 enum { MaxChars = sizeof(String) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize }; 1629 Ch str[MaxChars]; 1630 1631 inline static bool Usable(SizeType len) { return (MaxSize >= len); } 1632 inline void SetLength(SizeType len) { str[LenPos] = (Ch)(MaxSize - len); } 1633 inline SizeType GetLength() const { return (SizeType)(MaxSize - str[LenPos]); } 1634 }; // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode 1635 1636 // By using proper binary layout, retrieval of different integer types do not need conversions. 1637 union Number { 1638 #if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN 1639 struct I { 1640 int i; 1641 char padding[4]; 1642 }i; 1643 struct U { 1644 unsigned u; 1645 char padding2[4]; 1646 }u; 1647 #else 1648 struct I { 1649 char padding[4]; 1650 int i; 1651 }i; 1652 struct U { 1653 char padding2[4]; 1654 unsigned u; 1655 }u; 1656 #endif 1657 int64_t i64; 1658 uint64_t u64; 1659 double d; 1660 }; // 8 bytes 1661 1662 struct Object { 1663 Member* members; 1664 SizeType size; 1665 SizeType capacity; 1666 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode 1667 1668 struct Array { 1669 GenericValue* elements; 1670 SizeType size; 1671 SizeType capacity; 1672 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode 1673 1674 union Data { 1675 String s; 1676 ShortString ss; 1677 Number n; 1678 Object o; 1679 Array a; 1680 }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode 1681 1682 // Initialize this value as array with initial data, without calling destructor. 1683 void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) { 1684 flags_ = kArrayFlag; 1685 if (count) { 1686 data_.a.elements = (GenericValue*)allocator.Malloc(count * sizeof(GenericValue)); 1687 std::memcpy(data_.a.elements, values, count * sizeof(GenericValue)); 1688 } 1689 else 1690 data_.a.elements = NULL; 1691 data_.a.size = data_.a.capacity = count; 1692 } 1693 1694 //! Initialize this value as object with initial data, without calling destructor. 1695 void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) { 1696 flags_ = kObjectFlag; 1697 if (count) { 1698 data_.o.members = (Member*)allocator.Malloc(count * sizeof(Member)); 1699 std::memcpy(data_.o.members, members, count * sizeof(Member)); 1700 } 1701 else 1702 data_.o.members = NULL; 1703 data_.o.size = data_.o.capacity = count; 1704 } 1705 1706 //! Initialize this value as constant string, without calling destructor. 1707 void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT { 1708 flags_ = kConstStringFlag; 1709 data_.s.str = s; 1710 data_.s.length = s.length; 1711 } 1712 1713 //! Initialize this value as copy string with initial data, without calling destructor. 1714 void SetStringRaw(StringRefType s, Allocator& allocator) { 1715 Ch* str = NULL; 1716 if(ShortString::Usable(s.length)) { 1717 flags_ = kShortStringFlag; 1718 data_.ss.SetLength(s.length); 1719 str = data_.ss.str; 1720 } else { 1721 flags_ = kCopyStringFlag; 1722 data_.s.length = s.length; 1723 str = (Ch *)allocator.Malloc((s.length + 1) * sizeof(Ch)); 1724 data_.s.str = str; 1725 } 1726 std::memcpy(str, s, s.length * sizeof(Ch)); 1727 str[s.length] = '\0'; 1728 } 1729 1730 //! Assignment without calling destructor 1731 void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT { 1732 data_ = rhs.data_; 1733 flags_ = rhs.flags_; 1734 rhs.flags_ = kNullFlag; 1735 } 1736 1737 template <typename SourceAllocator> 1738 bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const { 1739 RAPIDJSON_ASSERT(IsString()); 1740 RAPIDJSON_ASSERT(rhs.IsString()); 1741 1742 const SizeType len1 = GetStringLength(); 1743 const SizeType len2 = rhs.GetStringLength(); 1744 if(len1 != len2) { return false; } 1745 1746 const Ch* const str1 = GetString(); 1747 const Ch* const str2 = rhs.GetString(); 1748 if(str1 == str2) { return true; } // fast path for constant string 1749 1750 return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0); 1751 } 1752 1753 Data data_; 1754 unsigned flags_; 1755 }; 1756 1757 //! GenericValue with UTF8 encoding 1758 typedef GenericValue<UTF8<> > Value; 1759 1760 /////////////////////////////////////////////////////////////////////////////// 1761 // GenericDocument 1762 1763 //! A document for parsing JSON text as DOM. 1764 /*! 1765 \note implements Handler concept 1766 \tparam Encoding Encoding for both parsing and string storage. 1767 \tparam Allocator Allocator for allocating memory for the DOM 1768 \tparam StackAllocator Allocator for allocating memory for stack during parsing. 1769 \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor. To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue. 1770 */ 1771 template <typename Encoding, typename Allocator = MemoryPoolAllocator<>, typename StackAllocator = CrtAllocator> 1772 class GenericDocument : public GenericValue<Encoding, Allocator> { 1773 public: 1774 typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. 1775 typedef GenericValue<Encoding, Allocator> ValueType; //!< Value type of the document. 1776 typedef Allocator AllocatorType; //!< Allocator type from template parameter. 1777 1778 //! Constructor 1779 /*! Creates an empty document of specified type. 1780 \param type Mandatory type of object to create. 1781 \param allocator Optional allocator for allocating memory. 1782 \param stackCapacity Optional initial capacity of stack in bytes. 1783 \param stackAllocator Optional allocator for allocating memory for stack. 1784 */ 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_() 1787 { 1788 if (!allocator_) 1789 ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator()); 1790 } 1791 1792 //! Constructor 1793 /*! Creates an empty document which type is Null. 1794 \param allocator Optional allocator for allocating memory. 1795 \param stackCapacity Optional initial capacity of stack in bytes. 1796 \param stackAllocator Optional allocator for allocating memory for stack. 1797 */ 1798 GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : 1799 allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_() 1800 { 1801 if (!allocator_) 1802 ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator()); 1803 } 1804 1805 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1806 //! Move constructor in C++11 1807 GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT 1808 : ValueType(std::forward<ValueType>(rhs)), // explicit cast to avoid prohibited move from Document 1809 allocator_(rhs.allocator_), 1810 ownAllocator_(rhs.ownAllocator_), 1811 stack_(std::move(rhs.stack_)), 1812 parseResult_(rhs.parseResult_) 1813 { 1814 rhs.allocator_ = 0; 1815 rhs.ownAllocator_ = 0; 1816 rhs.parseResult_ = ParseResult(); 1817 } 1818 #endif 1819 1820 ~GenericDocument() { 1821 Destroy(); 1822 } 1823 1824 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS 1825 //! Move assignment in C++11 1826 GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT 1827 { 1828 // The cast to ValueType is necessary here, because otherwise it would 1829 // attempt to call GenericValue's templated assignment operator. 1830 ValueType::operator=(std::forward<ValueType>(rhs)); 1831 1832 // Calling the destructor here would prematurely call stack_'s destructor 1833 Destroy(); 1834 1835 allocator_ = rhs.allocator_; 1836 ownAllocator_ = rhs.ownAllocator_; 1837 stack_ = std::move(rhs.stack_); 1838 parseResult_ = rhs.parseResult_; 1839 1840 rhs.allocator_ = 0; 1841 rhs.ownAllocator_ = 0; 1842 rhs.parseResult_ = ParseResult(); 1843 1844 return *this; 1845 } 1846 #endif 1847 1848 //! Exchange the contents of this document with those of another. 1849 /*! 1850 \param other Another document. 1851 \note Constant complexity. 1852 \see GenericValue::Swap 1853 */ 1854 GenericDocument& Swap(GenericDocument& rhs) RAPIDJSON_NOEXCEPT { 1855 ValueType::Swap(rhs); 1856 stack_.Swap(rhs.stack_); 1857 internal::Swap(allocator_, rhs.allocator_); 1858 internal::Swap(ownAllocator_, rhs.ownAllocator_); 1859 internal::Swap(parseResult_, rhs.parseResult_); 1860 return *this; 1861 } 1862 1863 //! free-standing swap function helper 1864 /*! 1865 Helper function to enable support for common swap implementation pattern based on \c std::swap: 1866 \code 1867 void swap(MyClass& a, MyClass& b) { 1868 using std::swap; 1869 swap(a.doc, b.doc); 1870 // ... 1871 } 1872 \endcode 1873 \see Swap() 1874 */ 1875 friend inline void swap(GenericDocument& a, GenericDocument& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } 1876 1877 //!@name Parse from stream 1878 //!@{ 1879 1880 //! Parse JSON text from an input stream (with Encoding conversion) 1881 /*! \tparam parseFlags Combination of \ref ParseFlag. 1882 \tparam SourceEncoding Encoding of input stream 1883 \tparam InputStream Type of input stream, implementing Stream concept 1884 \param is Input stream to be parsed. 1885 \return The document itself for fluent API. 1886 */ 1887 template <unsigned parseFlags, typename SourceEncoding, typename InputStream> 1888 GenericDocument& ParseStream(InputStream& is) { 1889 ValueType::SetNull(); // Remove existing root if exist 1890 GenericReader<SourceEncoding, Encoding, StackAllocator> reader( 1891 stack_.HasAllocator() ? &stack_.GetAllocator() : 0); 1892 ClearStackOnExit scope(*this); 1893 parseResult_ = reader.template Parse<parseFlags>(is, *this); 1894 if (parseResult_) { 1895 RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object 1896 this->RawAssign(*stack_.template Pop<ValueType>(1)); // Add this-> to prevent issue 13. 1897 } 1898 return *this; 1899 } 1900 1901 //! Parse JSON text from an input stream 1902 /*! \tparam parseFlags Combination of \ref ParseFlag. 1903 \tparam InputStream Type of input stream, implementing Stream concept 1904 \param is Input stream to be parsed. 1905 \return The document itself for fluent API. 1906 */ 1907 template <unsigned parseFlags, typename InputStream> 1908 GenericDocument& ParseStream(InputStream& is) { 1909 return ParseStream<parseFlags, Encoding, InputStream>(is); 1910 } 1911 1912 //! Parse JSON text from an input stream (with \ref kParseDefaultFlags) 1913 /*! \tparam InputStream Type of input stream, implementing Stream concept 1914 \param is Input stream to be parsed. 1915 \return The document itself for fluent API. 1916 */ 1917 template <typename InputStream> 1918 GenericDocument& ParseStream(InputStream& is) { 1919 return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is); 1920 } 1921 //!@} 1922 1923 //!@name Parse in-place from mutable string 1924 //!@{ 1925 1926 //! Parse JSON text from a mutable string 1927 /*! \tparam parseFlags Combination of \ref ParseFlag. 1928 \param str Mutable zero-terminated string to be parsed. 1929 \return The document itself for fluent API. 1930 */ 1931 template <unsigned parseFlags> 1932 GenericDocument& ParseInsitu(Ch* str) { 1933 GenericInsituStringStream<Encoding> s(str); 1934 return ParseStream<parseFlags | kParseInsituFlag>(s); 1935 } 1936 1937 //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags) 1938 /*! \param str Mutable zero-terminated string to be parsed. 1939 \return The document itself for fluent API. 1940 */ 1941 GenericDocument& ParseInsitu(Ch* str) { 1942 return ParseInsitu<kParseDefaultFlags>(str); 1943 } 1944 //!@} 1945 1946 //!@name Parse from read-only string 1947 //!@{ 1948 1949 //! Parse JSON text from a read-only string (with Encoding conversion) 1950 /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag). 1951 \tparam SourceEncoding Transcoding from input Encoding 1952 \param str Read-only zero-terminated string to be parsed. 1953 */ 1954 template <unsigned parseFlags, typename SourceEncoding> 1955 GenericDocument& Parse(const Ch* str) { 1956 RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag)); 1957 GenericStringStream<SourceEncoding> s(str); 1958 return ParseStream<parseFlags, SourceEncoding>(s); 1959 } 1960 1961 //! Parse JSON text from a read-only string 1962 /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag). 1963 \param str Read-only zero-terminated string to be parsed. 1964 */ 1965 template <unsigned parseFlags> 1966 GenericDocument& Parse(const Ch* str) { 1967 return Parse<parseFlags, Encoding>(str); 1968 } 1969 1970 //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags) 1971 /*! \param str Read-only zero-terminated string to be parsed. 1972 */ 1973 GenericDocument& Parse(const Ch* str) { 1974 return Parse<kParseDefaultFlags>(str); 1975 } 1976 //!@} 1977 1978 //!@name Handling parse errors 1979 //!@{ 1980 1981 //! Whether a parse error has occured in the last parsing. 1982 bool HasParseError() const { return parseResult_.IsError(); } 1983 1984 //! Get the \ref ParseErrorCode of last parsing. 1985 ParseErrorCode GetParseError() const { return parseResult_.Code(); } 1986 1987 //! Get the position of last parsing error in input, 0 otherwise. 1988 size_t GetErrorOffset() const { return parseResult_.Offset(); } 1989 1990 //!@} 1991 1992 //! Get the allocator of this document. 1993 Allocator& GetAllocator() { 1994 RAPIDJSON_ASSERT(allocator_); 1995 return *allocator_; 1996 } 1997 1998 //! Get the capacity of stack in bytes. 1999 size_t GetStackCapacity() const { return stack_.GetCapacity(); } 2000 2001 private: 2002 // clear stack on any exit from ParseStream, e.g. due to exception 2003 struct ClearStackOnExit { 2004 explicit ClearStackOnExit(GenericDocument& d) : d_(d) {} 2005 ~ClearStackOnExit() { d_.ClearStack(); } 2006 private: 2007 ClearStackOnExit(const ClearStackOnExit&); 2008 ClearStackOnExit& operator=(const ClearStackOnExit&); 2009 GenericDocument& d_; 2010 }; 2011 2012 // callers of the following private Handler functions 2013 template <typename,typename,typename> friend class GenericReader; // for parsing 2014 template <typename, typename> friend class GenericValue; // for deep copying 2015 2016 // Implementation of Handler 2017 bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; } 2018 bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; } 2019 bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; } 2020 bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; } 2021 bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; } 2022 bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; } 2023 bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; } 2024 2025 bool String(const Ch* str, SizeType length, bool copy) { 2026 if (copy) 2027 new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator()); 2028 else 2029 new (stack_.template Push<ValueType>()) ValueType(str, length); 2030 return true; 2031 } 2032 2033 bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; } 2034 2035 bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); } 2036 2037 bool EndObject(SizeType memberCount) { 2038 typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount); 2039 stack_.template Top<ValueType>()->SetObjectRaw(members, (SizeType)memberCount, GetAllocator()); 2040 return true; 2041 } 2042 2043 bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; } 2044 2045 bool EndArray(SizeType elementCount) { 2046 ValueType* elements = stack_.template Pop<ValueType>(elementCount); 2047 stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator()); 2048 return true; 2049 } 2050 2051 private: 2052 //! Prohibit copying 2053 GenericDocument(const GenericDocument&); 2054 //! Prohibit assignment 2055 GenericDocument& operator=(const GenericDocument&); 2056 2057 void ClearStack() { 2058 if (Allocator::kNeedFree) 2059 while (stack_.GetSize() > 0) // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects) 2060 (stack_.template Pop<ValueType>(1))->~ValueType(); 2061 else 2062 stack_.Clear(); 2063 stack_.ShrinkToFit(); 2064 } 2065 2066 void Destroy() { 2067 RAPIDJSON_DELETE(ownAllocator_); 2068 } 2069 2070 static const size_t kDefaultStackCapacity = 1024; 2071 Allocator* allocator_; 2072 Allocator* ownAllocator_; 2073 internal::Stack<StackAllocator> stack_; 2074 ParseResult parseResult_; 2075 }; 2076 2077 //! GenericDocument with UTF8 encoding 2078 typedef GenericDocument<UTF8<> > Document; 2079 2080 // defined here due to the dependency on GenericDocument 2081 template <typename Encoding, typename Allocator> 2082 template <typename SourceAllocator> 2083 inline 2084 GenericValue<Encoding,Allocator>::GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator) 2085 { 2086 switch (rhs.GetType()) { 2087 case kObjectType: 2088 case kArrayType: { // perform deep copy via SAX Handler 2089 GenericDocument<Encoding,Allocator> d(&allocator); 2090 rhs.Accept(d); 2091 RawAssign(*d.stack_.template Pop<GenericValue>(1)); 2092 } 2093 break; 2094 case kStringType: 2095 if (rhs.flags_ == kConstStringFlag) { 2096 flags_ = rhs.flags_; 2097 data_ = *reinterpret_cast<const Data*>(&rhs.data_); 2098 } else { 2099 SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator); 2100 } 2101 break; 2102 default: // kNumberType, kTrueType, kFalseType, kNullType 2103 flags_ = rhs.flags_; 2104 data_ = *reinterpret_cast<const Data*>(&rhs.data_); 2105 } 2106 } 2107 2108 RAPIDJSON_NAMESPACE_END 2109 2110 #if defined(_MSC_VER) || defined(__GNUC__) 2111 RAPIDJSON_DIAG_POP 2112 #endif 2113 2114 #endif // RAPIDJSON_DOCUMENT_H_ 2115