Debian Codegraph @

Utilities/cmjsoncpp/include/json/value.h

raw
1 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
2 // Distributed under MIT license, or public domain if desired and
3 // recognized in your jurisdiction.
4 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
5
6 #ifndef JSON_VALUE_H_INCLUDED
7 #define JSON_VALUE_H_INCLUDED
8
9 #if !defined(JSON_IS_AMALGAMATION)
10 #include "forwards.h"
11 #endif // if !defined(JSON_IS_AMALGAMATION)
12
13 // Conditional NORETURN attribute on the throw functions would:
14 // a) suppress false positives from static code analysis
15 // b) possibly improve optimization opportunities.
16 #if !defined(JSONCPP_NORETURN)
17 #if defined(_MSC_VER) && _MSC_VER == 1800
18 #define JSONCPP_NORETURN __declspec(noreturn)
19 #else
20 #define JSONCPP_NORETURN [[noreturn]]
21 #endif
22 #endif
23
24 // Support for '= delete' with template declarations was a late addition
25 // to the c++11 standard and is rejected by clang 3.8 and Apple clang 8.2
26 // even though these declare themselves to be c++11 compilers.
27 #if !defined(JSONCPP_TEMPLATE_DELETE)
28 #if defined(__clang__) && defined(__apple_build_version__)
29 #if __apple_build_version__ <= 8000042
30 #define JSONCPP_TEMPLATE_DELETE
31 #endif
32 #elif defined(__clang__)
33 #if __clang_major__ == 3 && __clang_minor__ <= 8
34 #define JSONCPP_TEMPLATE_DELETE
35 #endif
36 #elif defined(__EDG__) && defined(__LCC__)
37 #if __LCC__ < 123
38 #define JSONCPP_TEMPLATE_DELETE
39 #endif
40 #endif
41 #if !defined(JSONCPP_TEMPLATE_DELETE)
42 #define JSONCPP_TEMPLATE_DELETE = delete
43 #endif
44 #endif
45
46 #include <array>
47 #include <exception>
48 #include <map>
49 #include <memory>
50 #include <string>
51 #include <vector>
52
53 // Disable warning C4251: <data member>: <type> needs to have dll-interface to
54 // be used by...
55 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
56 #pragma warning(push)
57 #pragma warning(disable : 4251 4275)
58 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
59
60 #if !defined(__SUNPRO_CC)
61 #pragma pack(push)
62 #pragma pack()
63 #endif
64
65 /** \brief JSON (JavaScript Object Notation).
66 */
67 namespace Json {
68
69 #if JSON_USE_EXCEPTION
70 /** Base class for all exceptions we throw.
71 *
72 * We use nothing but these internally. Of course, STL can throw others.
73 */
74 class JSON_API Exception : public std::exception {
75 public:
76 Exception(String msg);
77 ~Exception() noexcept override;
78 char const* what() const noexcept override;
79
80 protected:
81 String msg_;
82 };
83
84 /** Exceptions which the user cannot easily avoid.
85 *
86 * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
87 *
88 * \remark derived from Json::Exception
89 */
90 class JSON_API RuntimeError : public Exception {
91 public:
92 RuntimeError(String const& msg);
93 };
94
95 /** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
96 *
97 * These are precondition-violations (user bugs) and internal errors (our bugs).
98 *
99 * \remark derived from Json::Exception
100 */
101 class JSON_API LogicError : public Exception {
102 public:
103 LogicError(String const& msg);
104 };
105 #endif
106
107 /// used internally
108 JSONCPP_NORETURN void throwRuntimeError(String const& msg);
109 /// used internally
110 JSONCPP_NORETURN void throwLogicError(String const& msg);
111
112 /** \brief Type of the value held by a Value object.
113 */
114 enum ValueType {
115 nullValue = 0, ///< 'null' value
116 intValue, ///< signed integer value
117 uintValue, ///< unsigned integer value
118 realValue, ///< double value
119 stringValue, ///< UTF-8 string value
120 booleanValue, ///< bool value
121 arrayValue, ///< array value (ordered list)
122 objectValue ///< object value (collection of name/value pairs).
123 };
124
125 enum CommentPlacement {
126 commentBefore = 0, ///< a comment placed on the line before a value
127 commentAfterOnSameLine, ///< a comment just after a value on the same line
128 commentAfter, ///< a comment on the line after a value (only make sense for
129 /// root value)
130 numberOfCommentPlacement
131 };
132
133 /** \brief Type of precision for formatting of real values.
134 */
135 enum PrecisionType {
136 significantDigits = 0, ///< we set max number of significant digits in string
137 decimalPlaces ///< we set max number of digits after "." in string
138 };
139
140 /** \brief Lightweight wrapper to tag static string.
141 *
142 * Value constructor and objectValue member assignment takes advantage of the
143 * StaticString and avoid the cost of string duplication when storing the
144 * string or the member name.
145 *
146 * Example of usage:
147 * \code
148 * Json::Value aValue( StaticString("some text") );
149 * Json::Value object;
150 * static const StaticString code("code");
151 * object[code] = 1234;
152 * \endcode
153 */
154 class JSON_API StaticString {
155 public:
156 explicit StaticString(const char* czstring) : c_str_(czstring) {}
157
158 operator const char*() const { return c_str_; }
159
160 const char* c_str() const { return c_str_; }
161
162 private:
163 const char* c_str_;
164 };
165
166 /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
167 *
168 * This class is a discriminated union wrapper that can represents a:
169 * - signed integer [range: Value::minInt - Value::maxInt]
170 * - unsigned integer (range: 0 - Value::maxUInt)
171 * - double
172 * - UTF-8 string
173 * - boolean
174 * - 'null'
175 * - an ordered list of Value
176 * - collection of name/value pairs (javascript object)
177 *
178 * The type of the held value is represented by a #ValueType and
179 * can be obtained using type().
180 *
181 * Values of an #objectValue or #arrayValue can be accessed using operator[]()
182 * methods.
183 * Non-const methods will automatically create the a #nullValue element
184 * if it does not exist.
185 * The sequence of an #arrayValue will be automatically resized and initialized
186 * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
187 *
188 * The get() methods can be used to obtain default value in the case the
189 * required element does not exist.
190 *
191 * It is possible to iterate over the list of member keys of an object using
192 * the getMemberNames() method.
193 *
194 * \note #Value string-length fit in size_t, but keys must be < 2^30.
195 * (The reason is an implementation detail.) A #CharReader will raise an
196 * exception if a bound is exceeded to avoid security holes in your app,
197 * but the Value API does *not* check bounds. That is the responsibility
198 * of the caller.
199 */
200 class JSON_API Value {
201 friend class ValueIteratorBase;
202
203 public:
204 using Members = std::vector<String>;
205 using iterator = ValueIterator;
206 using const_iterator = ValueConstIterator;
207 using UInt = Json::UInt;
208 using Int = Json::Int;
209 #if defined(JSON_HAS_INT64)
210 using UInt64 = Json::UInt64;
211 using Int64 = Json::Int64;
212 #endif // defined(JSON_HAS_INT64)
213 using LargestInt = Json::LargestInt;
214 using LargestUInt = Json::LargestUInt;
215 using ArrayIndex = Json::ArrayIndex;
216
217 // Required for boost integration, e. g. BOOST_TEST
218 using value_type = std::string;
219
220 #if JSON_USE_NULLREF
221 // Binary compatibility kludges, do not use.
222 static const Value& null;
223 static const Value& nullRef;
224 #endif
225
226 // null and nullRef are deprecated, use this instead.
227 static Value const& nullSingleton();
228
229 /// Minimum signed integer value that can be stored in a Json::Value.
230 static constexpr LargestInt minLargestInt =
231 LargestInt(~(LargestUInt(-1) / 2));
232 /// Maximum signed integer value that can be stored in a Json::Value.
233 static constexpr LargestInt maxLargestInt = LargestInt(LargestUInt(-1) / 2);
234 /// Maximum unsigned integer value that can be stored in a Json::Value.
235 static constexpr LargestUInt maxLargestUInt = LargestUInt(-1);
236
237 /// Minimum signed int value that can be stored in a Json::Value.
238 static constexpr Int minInt = Int(~(UInt(-1) / 2));
239 /// Maximum signed int value that can be stored in a Json::Value.
240 static constexpr Int maxInt = Int(UInt(-1) / 2);
241 /// Maximum unsigned int value that can be stored in a Json::Value.
242 static constexpr UInt maxUInt = UInt(-1);
243
244 #if defined(JSON_HAS_INT64)
245 /// Minimum signed 64 bits int value that can be stored in a Json::Value.
246 static constexpr Int64 minInt64 = Int64(~(UInt64(-1) / 2));
247 /// Maximum signed 64 bits int value that can be stored in a Json::Value.
248 static constexpr Int64 maxInt64 = Int64(UInt64(-1) / 2);
249 /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
250 static constexpr UInt64 maxUInt64 = UInt64(-1);
251 #endif // defined(JSON_HAS_INT64)
252 /// Default precision for real value for string representation.
253 static constexpr UInt defaultRealPrecision = 17;
254 // The constant is hard-coded because some compiler have trouble
255 // converting Value::maxUInt64 to a double correctly (AIX/xlC).
256 // Assumes that UInt64 is a 64 bits integer.
257 static constexpr double maxUInt64AsDouble = 18446744073709551615.0;
258 // Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
259 // when using gcc and clang backend compilers. CZString
260 // cannot be defined as private. See issue #486
261 #ifdef __NVCC__
262 public:
263 #else
264 private:
265 #endif
266 #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
267 class CZString {
268 public:
269 enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
270 CZString(ArrayIndex index);
271 CZString(char const* str, unsigned length, DuplicationPolicy allocate);
272 CZString(CZString const& other);
273 CZString(CZString&& other) noexcept;
274 ~CZString();
275 CZString& operator=(const CZString& other);
276 CZString& operator=(CZString&& other) noexcept;
277
278 bool operator<(CZString const& other) const;
279 bool operator==(CZString const& other) const;
280 ArrayIndex index() const;
281 // const char* c_str() const; ///< deprecated
282 char const* data() const;
283 unsigned length() const;
284 bool isStaticString() const;
285
286 private:
287 void swap(CZString& other);
288
289 struct StringStorage {
290 unsigned policy_ : 2;
291 unsigned length_ : 30; // 1GB max
292 };
293
294 char const* cstr_; // actually, a prefixed string, unless policy is noDup
295 union {
296 ArrayIndex index_;
297 StringStorage storage_;
298 };
299 };
300
301 public:
302 typedef std::map<CZString, Value> ObjectValues;
303 #endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
304
305 public:
306 /**
307 * \brief Create a default Value of the given type.
308 *
309 * This is a very useful constructor.
310 * To create an empty array, pass arrayValue.
311 * To create an empty object, pass objectValue.
312 * Another Value can then be set to this one by assignment.
313 * This is useful since clear() and resize() will not alter types.
314 *
315 * Examples:
316 * \code
317 * Json::Value null_value; // null
318 * Json::Value arr_value(Json::arrayValue); // []
319 * Json::Value obj_value(Json::objectValue); // {}
320 * \endcode
321 */
322 Value(ValueType type = nullValue);
323 Value(Int value);
324 Value(UInt value);
325 #if defined(JSON_HAS_INT64)
326 Value(Int64 value);
327 Value(UInt64 value);
328 #endif // if defined(JSON_HAS_INT64)
329 Value(double value);
330 Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
331 Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
332 /**
333 * \brief Constructs a value from a static string.
334 *
335 * Like other value string constructor but do not duplicate the string for
336 * internal storage. The given string must remain alive after the call to
337 * this constructor.
338 *
339 * \note This works only for null-terminated strings. (We cannot change the
340 * size of this class, so we have nowhere to store the length, which might be
341 * computed later for various operations.)
342 *
343 * Example of usage:
344 * \code
345 * static StaticString foo("some text");
346 * Json::Value aValue(foo);
347 * \endcode
348 */
349 Value(const StaticString& value);
350 Value(const String& value);
351 Value(bool value);
352 Value(std::nullptr_t ptr) = delete;
353 Value(const Value& other);
354 Value(Value&& other) noexcept;
355 ~Value();
356
357 /// \note Overwrite existing comments. To preserve comments, use
358 /// #swapPayload().
359 Value& operator=(const Value& other);
360 Value& operator=(Value&& other) noexcept;
361
362 /// Swap everything.
363 void swap(Value& other);
364 /// Swap values but leave comments and source offsets in place.
365 void swapPayload(Value& other);
366
367 /// copy everything.
368 void copy(const Value& other);
369 /// copy values but leave comments and source offsets in place.
370 void copyPayload(const Value& other);
371
372 ValueType type() const;
373
374 /// Compare payload only, not comments etc.
375 bool operator<(const Value& other) const;
376 bool operator<=(const Value& other) const;
377 bool operator>=(const Value& other) const;
378 bool operator>(const Value& other) const;
379 bool operator==(const Value& other) const;
380 bool operator!=(const Value& other) const;
381 int compare(const Value& other) const;
382
383 const char* asCString() const; ///< Embedded zeroes could cause you trouble!
384 #if JSONCPP_USING_SECURE_MEMORY
385 unsigned getCStringLength() const; // Allows you to understand the length of
386 // the CString
387 #endif
388 String asString() const; ///< Embedded zeroes are possible.
389 /** Get raw char* of string-value.
390 * \return false if !string. (Seg-fault if str or end are NULL.)
391 */
392 bool getString(char const** begin, char const** end) const;
393 Int asInt() const;
394 UInt asUInt() const;
395 #if defined(JSON_HAS_INT64)
396 Int64 asInt64() const;
397 UInt64 asUInt64() const;
398 #endif // if defined(JSON_HAS_INT64)
399 LargestInt asLargestInt() const;
400 LargestUInt asLargestUInt() const;
401 float asFloat() const;
402 double asDouble() const;
403 bool asBool() const;
404
405 bool isNull() const;
406 bool isBool() const;
407 bool isInt() const;
408 bool isInt64() const;
409 bool isUInt() const;
410 bool isUInt64() const;
411 bool isIntegral() const;
412 bool isDouble() const;
413 bool isNumeric() const;
414 bool isString() const;
415 bool isArray() const;
416 bool isObject() const;
417
418 /// The `as<T>` and `is<T>` member function templates and specializations.
419 template <typename T> T as() const JSONCPP_TEMPLATE_DELETE;
420 template <typename T> bool is() const JSONCPP_TEMPLATE_DELETE;
421
422 bool isConvertibleTo(ValueType other) const;
423
424 /// Number of values in array or object
425 ArrayIndex size() const;
426
427 /// \brief Return true if empty array, empty object, or null;
428 /// otherwise, false.
429 bool empty() const;
430
431 /// Return !isNull()
432 explicit operator bool() const;
433
434 /// Remove all object members and array elements.
435 /// \pre type() is arrayValue, objectValue, or nullValue
436 /// \post type() is unchanged
437 void clear();
438
439 /// Resize the array to newSize elements.
440 /// New elements are initialized to null.
441 /// May only be called on nullValue or arrayValue.
442 /// \pre type() is arrayValue or nullValue
443 /// \post type() is arrayValue
444 void resize(ArrayIndex newSize);
445
446 ///@{
447 /// Access an array element (zero based index). If the array contains less
448 /// than index element, then null value are inserted in the array so that
449 /// its size is index+1.
450 /// (You may need to say 'value[0u]' to get your compiler to distinguish
451 /// this from the operator[] which takes a string.)
452 Value& operator[](ArrayIndex index);
453 Value& operator[](int index);
454 ///@}
455
456 ///@{
457 /// Access an array element (zero based index).
458 /// (You may need to say 'value[0u]' to get your compiler to distinguish
459 /// this from the operator[] which takes a string.)
460 const Value& operator[](ArrayIndex index) const;
461 const Value& operator[](int index) const;
462 ///@}
463
464 /// If the array contains at least index+1 elements, returns the element
465 /// value, otherwise returns defaultValue.
466 Value get(ArrayIndex index, const Value& defaultValue) const;
467 /// Return true if index < size().
468 bool isValidIndex(ArrayIndex index) const;
469 /// \brief Append value to array at the end.
470 ///
471 /// Equivalent to jsonvalue[jsonvalue.size()] = value;
472 Value& append(const Value& value);
473 Value& append(Value&& value);
474
475 /// \brief Insert value in array at specific index
476 bool insert(ArrayIndex index, const Value& newValue);
477 bool insert(ArrayIndex index, Value&& newValue);
478
479 /// Access an object value by name, create a null member if it does not exist.
480 /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
481 /// Exceeding that will cause an exception.
482 Value& operator[](const char* key);
483 /// Access an object value by name, returns null if there is no member with
484 /// that name.
485 const Value& operator[](const char* key) const;
486 /// Access an object value by name, create a null member if it does not exist.
487 /// \param key may contain embedded nulls.
488 Value& operator[](const String& key);
489 /// Access an object value by name, returns null if there is no member with
490 /// that name.
491 /// \param key may contain embedded nulls.
492 const Value& operator[](const String& key) const;
493 /** \brief Access an object value by name, create a null member if it does not
494 * exist.
495 *
496 * If the object has no entry for that name, then the member name used to
497 * store the new entry is not duplicated.
498 * Example of use:
499 * \code
500 * Json::Value object;
501 * static const StaticString code("code");
502 * object[code] = 1234;
503 * \endcode
504 */
505 Value& operator[](const StaticString& key);
506 /// Return the member named key if it exist, defaultValue otherwise.
507 /// \note deep copy
508 Value get(const char* key, const Value& defaultValue) const;
509 /// Return the member named key if it exist, defaultValue otherwise.
510 /// \note deep copy
511 /// \note key may contain embedded nulls.
512 Value get(const char* begin, const char* end,
513 const Value& defaultValue) const;
514 /// Return the member named key if it exist, defaultValue otherwise.
515 /// \note deep copy
516 /// \param key may contain embedded nulls.
517 Value get(const String& key, const Value& defaultValue) const;
518 /// Most general and efficient version of isMember()const, get()const,
519 /// and operator[]const
520 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
521 Value const* find(char const* begin, char const* end) const;
522 /// Most general and efficient version of isMember()const, get()const,
523 /// and operator[]const
524 Value const* find(const String& key) const;
525 /// Most general and efficient version of object-mutators.
526 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
527 /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
528 Value* demand(char const* begin, char const* end);
529 /// \brief Remove and return the named member.
530 ///
531 /// Do nothing if it did not exist.
532 /// \pre type() is objectValue or nullValue
533 /// \post type() is unchanged
534 void removeMember(const char* key);
535 /// Same as removeMember(const char*)
536 /// \param key may contain embedded nulls.
537 void removeMember(const String& key);
538 /// Same as removeMember(const char* begin, const char* end, Value* removed),
539 /// but 'key' is null-terminated.
540 bool removeMember(const char* key, Value* removed);
541 /** \brief Remove the named map member.
542 *
543 * Update 'removed' iff removed.
544 * \param key may contain embedded nulls.
545 * \return true iff removed (no exceptions)
546 */
547 bool removeMember(String const& key, Value* removed);
548 /// Same as removeMember(String const& key, Value* removed)
549 bool removeMember(const char* begin, const char* end, Value* removed);
550 /** \brief Remove the indexed array element.
551 *
552 * O(n) expensive operations.
553 * Update 'removed' iff removed.
554 * \return true if removed (no exceptions)
555 */
556 bool removeIndex(ArrayIndex index, Value* removed);
557
558 /// Return true if the object has a member named key.
559 /// \note 'key' must be null-terminated.
560 bool isMember(const char* key) const;
561 /// Return true if the object has a member named key.
562 /// \param key may contain embedded nulls.
563 bool isMember(const String& key) const;
564 /// Same as isMember(String const& key)const
565 bool isMember(const char* begin, const char* end) const;
566
567 /// \brief Return a list of the member names.
568 ///
569 /// If null, return an empty list.
570 /// \pre type() is objectValue or nullValue
571 /// \post if type() was nullValue, it remains nullValue
572 Members getMemberNames() const;
573
574 /// deprecated Always pass len.
575 JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
576 void setComment(const char* comment, CommentPlacement placement) {
577 setComment(String(comment, strlen(comment)), placement);
578 }
579 /// Comments must be //... or /* ... */
580 void setComment(const char* comment, size_t len, CommentPlacement placement) {
581 setComment(String(comment, len), placement);
582 }
583 /// Comments must be //... or /* ... */
584 void setComment(String comment, CommentPlacement placement);
585 bool hasComment(CommentPlacement placement) const;
586 /// Include delimiters and embedded newlines.
587 String getComment(CommentPlacement placement) const;
588
589 String toStyledString() const;
590
591 const_iterator begin() const;
592 const_iterator end() const;
593
594 iterator begin();
595 iterator end();
596
597 /// \brief Returns a reference to the first element in the `Value`.
598 /// Requires that this value holds an array or json object, with at least one
599 /// element.
600 const Value& front() const;
601
602 /// \brief Returns a reference to the first element in the `Value`.
603 /// Requires that this value holds an array or json object, with at least one
604 /// element.
605 Value& front();
606
607 /// \brief Returns a reference to the last element in the `Value`.
608 /// Requires that value holds an array or json object, with at least one
609 /// element.
610 const Value& back() const;
611
612 /// \brief Returns a reference to the last element in the `Value`.
613 /// Requires that this value holds an array or json object, with at least one
614 /// element.
615 Value& back();
616
617 // Accessors for the [start, limit) range of bytes within the JSON text from
618 // which this value was parsed, if any.
619 void setOffsetStart(ptrdiff_t start);
620 void setOffsetLimit(ptrdiff_t limit);
621 ptrdiff_t getOffsetStart() const;
622 ptrdiff_t getOffsetLimit() const;
623
624 private:
625 void setType(ValueType v) {
626 bits_.value_type_ = static_cast<unsigned char>(v);
627 }
628 bool isAllocated() const { return bits_.allocated_; }
629 void setIsAllocated(bool v) { bits_.allocated_ = v; }
630
631 void initBasic(ValueType type, bool allocated = false);
632 void dupPayload(const Value& other);
633 void releasePayload();
634 void dupMeta(const Value& other);
635
636 Value& resolveReference(const char* key);
637 Value& resolveReference(const char* key, const char* end);
638
639 // struct MemberNamesTransform
640 //{
641 // typedef const char *result_type;
642 // const char *operator()( const CZString &name ) const
643 // {
644 // return name.c_str();
645 // }
646 //};
647
648 union ValueHolder {
649 LargestInt int_;
650 LargestUInt uint_;
651 double real_;
652 bool bool_;
653 char* string_; // if allocated_, ptr to { unsigned, char[] }.
654 ObjectValues* map_;
655 } value_;
656
657 struct {
658 // Really a ValueType, but types should agree for bitfield packing.
659 unsigned int value_type_ : 8;
660 // Unless allocated_, string_ must be null-terminated.
661 unsigned int allocated_ : 1;
662 } bits_;
663
664 class Comments {
665 public:
666 Comments() = default;
667 Comments(const Comments& that);
668 Comments(Comments&& that) noexcept;
669 Comments& operator=(const Comments& that);
670 Comments& operator=(Comments&& that) noexcept;
671 bool has(CommentPlacement slot) const;
672 String get(CommentPlacement slot) const;
673 void set(CommentPlacement slot, String comment);
674
675 private:
676 using Array = std::array<String, numberOfCommentPlacement>;
677 std::unique_ptr<Array> ptr_;
678 };
679 Comments comments_;
680
681 // [start, limit) byte offsets in the source JSON text from which this Value
682 // was extracted.
683 ptrdiff_t start_;
684 ptrdiff_t limit_;
685 };
686
687 template <> inline bool Value::as<bool>() const { return asBool(); }
688 template <> inline bool Value::is<bool>() const { return isBool(); }
689
690 template <> inline Int Value::as<Int>() const { return asInt(); }
691 template <> inline bool Value::is<Int>() const { return isInt(); }
692
693 template <> inline UInt Value::as<UInt>() const { return asUInt(); }
694 template <> inline bool Value::is<UInt>() const { return isUInt(); }
695
696 #if defined(JSON_HAS_INT64)
697 template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
698 template <> inline bool Value::is<Int64>() const { return isInt64(); }
699
700 template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
701 template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
702 #endif
703
704 template <> inline double Value::as<double>() const { return asDouble(); }
705 template <> inline bool Value::is<double>() const { return isDouble(); }
706
707 template <> inline String Value::as<String>() const { return asString(); }
708 template <> inline bool Value::is<String>() const { return isString(); }
709
710 /// These `as` specializations are type conversions, and do not have a
711 /// corresponding `is`.
712 template <> inline float Value::as<float>() const { return asFloat(); }
713 template <> inline const char* Value::as<const char*>() const {
714 return asCString();
715 }
716
717 /** \brief Experimental and untested: represents an element of the "path" to
718 * access a node.
719 */
720 class JSON_API PathArgument {
721 public:
722 friend class Path;
723
724 PathArgument();
725 PathArgument(ArrayIndex index);
726 PathArgument(const char* key);
727 PathArgument(String key);
728
729 private:
730 enum Kind { kindNone = 0, kindIndex, kindKey };
731 String key_;
732 ArrayIndex index_{};
733 Kind kind_{kindNone};
734 };
735
736 /** \brief Experimental and untested: represents a "path" to access a node.
737 *
738 * Syntax:
739 * - "." => root node
740 * - ".[n]" => elements at index 'n' of root node (an array value)
741 * - ".name" => member named 'name' of root node (an object value)
742 * - ".name1.name2.name3"
743 * - ".[0][1][2].name1[3]"
744 * - ".%" => member name is provided as parameter
745 * - ".[%]" => index is provided as parameter
746 */
747 class JSON_API Path {
748 public:
749 Path(const String& path, const PathArgument& a1 = PathArgument(),
750 const PathArgument& a2 = PathArgument(),
751 const PathArgument& a3 = PathArgument(),
752 const PathArgument& a4 = PathArgument(),
753 const PathArgument& a5 = PathArgument());
754
755 const Value& resolve(const Value& root) const;
756 Value resolve(const Value& root, const Value& defaultValue) const;
757 /// Creates the "path" to access the specified node and returns a reference on
758 /// the node.
759 Value& make(Value& root) const;
760
761 private:
762 using InArgs = std::vector<const PathArgument*>;
763 using Args = std::vector<PathArgument>;
764
765 void makePath(const String& path, const InArgs& in);
766 void addPathInArg(const String& path, const InArgs& in,
767 InArgs::const_iterator& itInArg, PathArgument::Kind kind);
768 static void invalidPath(const String& path, int location);
769
770 Args args_;
771 };
772
773 /** \brief base class for Value iterators.
774 *
775 */
776 class JSON_API ValueIteratorBase {
777 public:
778 using iterator_category = std::bidirectional_iterator_tag;
779 using size_t = unsigned int;
780 using difference_type = int;
781 using SelfType = ValueIteratorBase;
782
783 bool operator==(const SelfType& other) const { return isEqual(other); }
784
785 bool operator!=(const SelfType& other) const { return !isEqual(other); }
786
787 difference_type operator-(const SelfType& other) const {
788 return other.computeDistance(*this);
789 }
790
791 /// Return either the index or the member name of the referenced value as a
792 /// Value.
793 Value key() const;
794
795 /// Return the index of the referenced Value, or -1 if it is not an
796 /// arrayValue.
797 UInt index() const;
798
799 /// Return the member name of the referenced Value, or "" if it is not an
800 /// objectValue.
801 /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
802 String name() const;
803
804 /// Return the member name of the referenced Value. "" if it is not an
805 /// objectValue.
806 /// deprecated This cannot be used for UTF-8 strings, since there can be
807 /// embedded nulls.
808 JSONCPP_DEPRECATED("Use `key = name();` instead.")
809 char const* memberName() const;
810 /// Return the member name of the referenced Value, or NULL if it is not an
811 /// objectValue.
812 /// \note Better version than memberName(). Allows embedded nulls.
813 char const* memberName(char const** end) const;
814
815 protected:
816 /*! Internal utility functions to assist with implementing
817 * other iterator functions. The const and non-const versions
818 * of the "deref" protected methods expose the protected
819 * current_ member variable in a way that can often be
820 * optimized away by the compiler.
821 */
822 const Value& deref() const;
823 Value& deref();
824
825 void increment();
826
827 void decrement();
828
829 difference_type computeDistance(const SelfType& other) const;
830
831 bool isEqual(const SelfType& other) const;
832
833 void copy(const SelfType& other);
834
835 private:
836 Value::ObjectValues::iterator current_;
837 // Indicates that iterator is for a null value.
838 bool isNull_{true};
839
840 public:
841 // For some reason, BORLAND needs these at the end, rather
842 // than earlier. No idea why.
843 ValueIteratorBase();
844 explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
845 };
846
847 /** \brief const iterator for object and array value.
848 *
849 */
850 class JSON_API ValueConstIterator : public ValueIteratorBase {
851 friend class Value;
852
853 public:
854 using value_type = const Value;
855 // typedef unsigned int size_t;
856 // typedef int difference_type;
857 using reference = const Value&;
858 using pointer = const Value*;
859 using SelfType = ValueConstIterator;
860
861 ValueConstIterator();
862 ValueConstIterator(ValueIterator const& other);
863
864 private:
865 /*! internal Use by Value to create an iterator.
866 */
867 explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
868
869 public:
870 SelfType& operator=(const ValueIteratorBase& other);
871
872 SelfType operator++(int) {
873 SelfType temp(*this);
874 ++*this;
875 return temp;
876 }
877
878 SelfType operator--(int) {
879 SelfType temp(*this);
880 --*this;
881 return temp;
882 }
883
884 SelfType& operator--() {
885 decrement();
886 return *this;
887 }
888
889 SelfType& operator++() {
890 increment();
891 return *this;
892 }
893
894 reference operator*() const { return deref(); }
895
896 pointer operator->() const { return &deref(); }
897 };
898
899 /** \brief Iterator for object and array value.
900 */
901 class JSON_API ValueIterator : public ValueIteratorBase {
902 friend class Value;
903
904 public:
905 using value_type = Value;
906 using size_t = unsigned int;
907 using difference_type = int;
908 using reference = Value&;
909 using pointer = Value*;
910 using SelfType = ValueIterator;
911
912 ValueIterator();
913 explicit ValueIterator(const ValueConstIterator& other);
914 ValueIterator(const ValueIterator& other);
915
916 private:
917 /*! internal Use by Value to create an iterator.
918 */
919 explicit ValueIterator(const Value::ObjectValues::iterator& current);
920
921 public:
922 SelfType& operator=(const SelfType& other);
923
924 SelfType operator++(int) {
925 SelfType temp(*this);
926 ++*this;
927 return temp;
928 }
929
930 SelfType operator--(int) {
931 SelfType temp(*this);
932 --*this;
933 return temp;
934 }
935
936 SelfType& operator--() {
937 decrement();
938 return *this;
939 }
940
941 SelfType& operator++() {
942 increment();
943 return *this;
944 }
945
946 /*! The return value of non-const iterators can be
947 * changed, so the these functions are not const
948 * because the returned references/pointers can be used
949 * to change state of the base class.
950 */
951 reference operator*() const { return const_cast<reference>(deref()); }
952 pointer operator->() const { return const_cast<pointer>(&deref()); }
953 };
954
955 inline void swap(Value& a, Value& b) { a.swap(b); }
956
957 inline const Value& Value::front() const { return *begin(); }
958
959 inline Value& Value::front() { return *begin(); }
960
961 inline const Value& Value::back() const { return *(--end()); }
962
963 inline Value& Value::back() { return *(--end()); }
964
965 } // namespace Json
966
967 #if !defined(__SUNPRO_CC)
968 #pragma pack(pop)
969 #endif
970
971 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
972 #pragma warning(pop)
973 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
974
975 #endif // JSON_H_INCLUDED