blob: 30ce89f5aff050f8c41884306e035a20eea625b6 [file] [log] [blame]
Devin Jeanpierre59e4d352017-07-21 03:44:36 -07001// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
Baptiste Lepilleur7469f1d2010-04-20 21:35:19 +00002// 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
Christopher Dunn6d135cb2007-06-13 15:51:04 +00006#ifndef CPPTL_JSON_H_INCLUDED
Aaron Jacobs9fa4e842014-07-01 08:48:54 +10007#define CPPTL_JSON_H_INCLUDED
Christopher Dunn6d135cb2007-06-13 15:51:04 +00008
Baptiste Lepilleureadc4782011-05-02 21:09:30 +00009#if !defined(JSON_IS_AMALGAMATION)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100010#include "forwards.h"
Baptiste Lepilleureadc4782011-05-02 21:09:30 +000011#endif // if !defined(JSON_IS_AMALGAMATION)
Billy Donahue433107f2019-01-20 21:53:01 -050012#include <array>
Billy Donahueb5e1fe82018-05-20 16:55:27 -040013#include <exception>
Billy Donahue433107f2019-01-20 21:53:01 -050014#include <memory>
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100015#include <string>
16#include <vector>
Christopher Dunn6d135cb2007-06-13 15:51:04 +000017
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100018#ifndef JSON_USE_CPPTL_SMALLMAP
19#include <map>
20#else
21#include <cpptl/smallmap.h>
22#endif
23#ifdef JSON_USE_CPPTL
24#include <cpptl/forwards.h>
25#endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +000026
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100027// Disable warning C4251: <data member>: <type> needs to have dll-interface to
28// be used by...
Baptiste Lepilleureafd7022013-05-08 20:21:11 +000029#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100030#pragma warning(push)
31#pragma warning(disable : 4251)
Baptiste Lepilleureafd7022013-05-08 20:21:11 +000032#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
33
Sergiy80d6e666f2016-12-03 22:29:14 +020034#pragma pack(push, 8)
35
Christopher Dunn6d135cb2007-06-13 15:51:04 +000036/** \brief JSON (JavaScript Object Notation).
37 */
38namespace Json {
39
Jordan Bayles83cc9212019-06-06 13:41:47 -070040#if JSON_USE_EXCEPTION
Christopher Dunn75279cc2015-03-08 12:20:06 -050041/** Base class for all exceptions we throw.
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050042 *
43 * We use nothing but these internally. Of course, STL can throw others.
Christopher Dunn75279cc2015-03-08 12:20:06 -050044 */
Christopher Dunn949babd2015-07-23 00:19:12 -050045class JSON_API Exception : public std::exception {
46public:
Billy Donahue1c2ed7a2019-01-17 16:35:29 -050047 Exception(String msg);
Hans Johnson2853b1c2019-01-11 13:58:53 -060048 ~Exception() JSONCPP_NOEXCEPT override;
49 char const* what() const JSONCPP_NOEXCEPT override;
Billy Donahueb5e1fe82018-05-20 16:55:27 -040050
Christopher Dunn949babd2015-07-23 00:19:12 -050051protected:
Billy Donahue1c2ed7a2019-01-17 16:35:29 -050052 String msg_;
Christopher Dunn949babd2015-07-23 00:19:12 -050053};
54
Christopher Dunn53837942015-03-08 12:31:00 -050055/** Exceptions which the user cannot easily avoid.
56 *
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050057 * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
Dhruv Paranjape8996c372017-07-08 17:27:07 +053058 *
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050059 * \remark derived from Json::Exception
Christopher Dunn53837942015-03-08 12:31:00 -050060 */
Christopher Dunn949babd2015-07-23 00:19:12 -050061class JSON_API RuntimeError : public Exception {
62public:
Billy Donahue1c2ed7a2019-01-17 16:35:29 -050063 RuntimeError(String const& msg);
Christopher Dunn949babd2015-07-23 00:19:12 -050064};
65
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050066/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
Christopher Dunn53837942015-03-08 12:31:00 -050067 *
68 * These are precondition-violations (user bugs) and internal errors (our bugs).
Dhruv Paranjape8996c372017-07-08 17:27:07 +053069 *
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050070 * \remark derived from Json::Exception
Christopher Dunn53837942015-03-08 12:31:00 -050071 */
Christopher Dunn949babd2015-07-23 00:19:12 -050072class JSON_API LogicError : public Exception {
73public:
Billy Donahue1c2ed7a2019-01-17 16:35:29 -050074 LogicError(String const& msg);
Christopher Dunn949babd2015-07-23 00:19:12 -050075};
Jordan Bayles83cc9212019-06-06 13:41:47 -070076#endif
Christopher Dunn53837942015-03-08 12:31:00 -050077
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050078/// used internally
Jordan Bayles9ef812a2019-07-09 15:03:39 -070079[[noreturn]] void throwRuntimeError(String const& msg);
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050080/// used internally
Jordan Bayles9ef812a2019-07-09 15:03:39 -070081[[noreturn]] void throwLogicError(String const& msg);
Christopher Dunn75279cc2015-03-08 12:20:06 -050082
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100083/** \brief Type of the value held by a Value object.
84 */
85enum ValueType {
86 nullValue = 0, ///< 'null' value
87 intValue, ///< signed integer value
88 uintValue, ///< unsigned integer value
89 realValue, ///< double value
90 stringValue, ///< UTF-8 string value
91 booleanValue, ///< bool value
92 arrayValue, ///< array value (ordered list)
93 objectValue ///< object value (collection of name/value pairs).
94};
Christopher Dunn6d135cb2007-06-13 15:51:04 +000095
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100096enum CommentPlacement {
97 commentBefore = 0, ///< a comment placed on the line before a value
98 commentAfterOnSameLine, ///< a comment just after a value on the same line
99 commentAfter, ///< a comment on the line after a value (only make sense for
Aaron Jacobs3a0c4fc2014-07-01 09:20:48 +1000100 /// root value)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000101 numberOfCommentPlacement
102};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000103
Mike Ra07fc532018-03-13 23:35:31 +0300104/** \brief Type of precision for formatting of real values.
105 */
106enum PrecisionType {
107 significantDigits = 0, ///< we set max number of significant digits in string
108 decimalPlaces ///< we set max number of digits after "." in string
109};
110
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000111//# ifdef JSON_USE_CPPTL
112// typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
113// typedef CppTL::AnyEnumerator<const Value &> EnumValues;
114//# endif
115
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000116/** \brief Lightweight wrapper to tag static string.
117 *
Josh Sorefe6a588a2017-12-03 11:54:29 -0500118 * Value constructor and objectValue member assignment takes advantage of the
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000119 * StaticString and avoid the cost of string duplication when storing the
120 * string or the member name.
121 *
122 * Example of usage:
123 * \code
124 * Json::Value aValue( StaticString("some text") );
125 * Json::Value object;
126 * static const StaticString code("code");
127 * object[code] = 1234;
128 * \endcode
129 */
130class JSON_API StaticString {
131public:
Christopher Dunnff617522015-03-06 10:31:46 -0600132 explicit StaticString(const char* czstring) : c_str_(czstring) {}
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000133
Christopher Dunnff617522015-03-06 10:31:46 -0600134 operator const char*() const { return c_str_; }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000135
Christopher Dunnff617522015-03-06 10:31:46 -0600136 const char* c_str() const { return c_str_; }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000137
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000138private:
Christopher Dunnff617522015-03-06 10:31:46 -0600139 const char* c_str_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000140};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000141
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000142/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
143 *
144 * This class is a discriminated union wrapper that can represents a:
145 * - signed integer [range: Value::minInt - Value::maxInt]
146 * - unsigned integer (range: 0 - Value::maxUInt)
147 * - double
148 * - UTF-8 string
149 * - boolean
150 * - 'null'
151 * - an ordered list of Value
152 * - collection of name/value pairs (javascript object)
153 *
154 * The type of the held value is represented by a #ValueType and
155 * can be obtained using type().
156 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600157 * Values of an #objectValue or #arrayValue can be accessed using operator[]()
158 * methods.
159 * Non-const methods will automatically create the a #nullValue element
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000160 * if it does not exist.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600161 * The sequence of an #arrayValue will be automatically resized and initialized
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000162 * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
163 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600164 * The get() methods can be used to obtain default value in the case the
165 * required element does not exist.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000166 *
Mathias L. Baumann08ddeed2018-12-12 17:59:43 +0100167 * It is possible to iterate over the list of member keys of an object using
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000168 * the getMemberNames() method.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600169 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600170 * \note #Value string-length fit in size_t, but keys must be < 2^30.
171 * (The reason is an implementation detail.) A #CharReader will raise an
Christopher Dunn25342ba2015-03-02 18:05:26 -0600172 * exception if a bound is exceeded to avoid security holes in your app,
173 * but the Value API does *not* check bounds. That is the responsibility
174 * of the caller.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000175 */
176class JSON_API Value {
177 friend class ValueIteratorBase;
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400178
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000179public:
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500180 typedef std::vector<String> Members;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000181 typedef ValueIterator iterator;
182 typedef ValueConstIterator const_iterator;
183 typedef Json::UInt UInt;
184 typedef Json::Int Int;
185#if defined(JSON_HAS_INT64)
186 typedef Json::UInt64 UInt64;
187 typedef Json::Int64 Int64;
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000188#endif // defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000189 typedef Json::LargestInt LargestInt;
190 typedef Json::LargestUInt LargestUInt;
191 typedef Json::ArrayIndex ArrayIndex;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000192
Wolfram Röslerff6b4492017-09-14 09:31:36 +0200193 // Required for boost integration, e. g. BOOST_TEST
194 typedef std::string value_type;
195
Jordan Bayles25c57812019-07-11 14:27:29 -0700196#if JSON_USE_NULLREF
197 // Binary compatibility kludges, do not use.
198 static const Value& null;
199 static const Value& nullRef;
200#endif
201
202 // null and nullRef are deprecated, use this instead.
203 static Value const& nullSingleton();
Christopher Dunn0f288ae2016-06-26 18:47:43 -0500204
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000205 /// Minimum signed integer value that can be stored in a Json::Value.
206 static const LargestInt minLargestInt;
207 /// Maximum signed integer value that can be stored in a Json::Value.
208 static const LargestInt maxLargestInt;
209 /// Maximum unsigned integer value that can be stored in a Json::Value.
210 static const LargestUInt maxLargestUInt;
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000211
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000212 /// Minimum signed int value that can be stored in a Json::Value.
213 static const Int minInt;
214 /// Maximum signed int value that can be stored in a Json::Value.
215 static const Int maxInt;
216 /// Maximum unsigned int value that can be stored in a Json::Value.
217 static const UInt maxUInt;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000218
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000219#if defined(JSON_HAS_INT64)
220 /// Minimum signed 64 bits int value that can be stored in a Json::Value.
221 static const Int64 minInt64;
222 /// Maximum signed 64 bits int value that can be stored in a Json::Value.
223 static const Int64 maxInt64;
224 /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
225 static const UInt64 maxUInt64;
Aaron Jacobsf1053e72011-05-24 03:18:02 +0000226#endif // defined(JSON_HAS_INT64)
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000227
Mike Ra07fc532018-03-13 23:35:31 +0300228 /// Default precision for real value for string representation.
229 static const UInt defaultRealPrecision;
230
Darcy Beurle798f6ba2017-12-22 22:48:20 +0100231// Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
232// when using gcc and clang backend compilers. CZString
233// cannot be defined as private. See issue #486
234#ifdef __NVCC__
235public:
236#else
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000237private:
Darcy Beurle798f6ba2017-12-22 22:48:20 +0100238#endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000239#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000240 class CZString {
241 public:
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400242 enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000243 CZString(ArrayIndex index);
Christopher Dunnc28610f2015-02-21 11:44:16 -0600244 CZString(char const* str, unsigned length, DuplicationPolicy allocate);
245 CZString(CZString const& other);
Motti2b008912015-04-20 17:44:47 +0300246 CZString(CZString&& other);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000247 ~CZString();
Dhruv Paranjape0ba8bd72017-07-08 17:47:13 +0530248 CZString& operator=(const CZString& other);
Dhruv Paranjape0ba8bd72017-07-08 17:47:13 +0530249 CZString& operator=(CZString&& other);
Dhruv Paranjape0ba8bd72017-07-08 17:47:13 +0530250
Christopher Dunnc28610f2015-02-21 11:44:16 -0600251 bool operator<(CZString const& other) const;
252 bool operator==(CZString const& other) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000253 ArrayIndex index() const;
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400254 // const char* c_str() const; ///< \deprecated
Christopher Dunnc28610f2015-02-21 11:44:16 -0600255 char const* data() const;
256 unsigned length() const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000257 bool isStaticString() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000258
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000259 private:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000260 void swap(CZString& other);
Christopher Dunnc28610f2015-02-21 11:44:16 -0600261
Christopher Dunn57ad0512015-03-02 12:10:35 -0600262 struct StringStorage {
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400263 unsigned policy_ : 2;
264 unsigned length_ : 30; // 1GB max
Christopher Dunn57ad0512015-03-02 12:10:35 -0600265 };
266
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400267 char const* cstr_; // actually, a prefixed string, unless policy is noDup
Christopher Dunn57ad0512015-03-02 12:10:35 -0600268 union {
269 ArrayIndex index_;
270 StringStorage storage_;
271 };
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000272 };
273
274public:
275#ifndef JSON_USE_CPPTL_SMALLMAP
276 typedef std::map<CZString, Value> ObjectValues;
277#else
278 typedef CppTL::SmallMap<CZString, Value> ObjectValues;
279#endif // ifndef JSON_USE_CPPTL_SMALLMAP
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000280#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
281
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000282public:
Billy Donahue483eba82019-07-14 18:41:48 -0400283 /**
284 * \brief Create a default Value of the given type.
285 *
286 * This is a very useful constructor.
287 * To create an empty array, pass arrayValue.
288 * To create an empty object, pass objectValue.
289 * Another Value can then be set to this one by assignment.
290 * This is useful since clear() and resize() will not alter types.
291 *
292 * Examples:
293 * \code
294 * Json::Value null_value; // null
295 * Json::Value arr_value(Json::arrayValue); // []
296 * Json::Value obj_value(Json::objectValue); // {}
297 * \endcode
298 */
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000299 Value(ValueType type = nullValue);
300 Value(Int value);
301 Value(UInt value);
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000302#if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000303 Value(Int64 value);
304 Value(UInt64 value);
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000305#endif // if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000306 Value(double value);
Christopher Dunn8a702972015-03-03 10:38:27 -0600307 Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
Christopher Dunn89704032015-07-11 12:09:59 -0500308 Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
Billy Donahue483eba82019-07-14 18:41:48 -0400309 /**
310 * \brief Constructs a value from a static string.
311 *
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000312 * Like other value string constructor but do not duplicate the string for
Billy Donahue483eba82019-07-14 18:41:48 -0400313 * internal storage. The given string must remain alive after the call to
314 * this constructor.
315 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600316 * \note This works only for null-terminated strings. (We cannot change the
Billy Donahue483eba82019-07-14 18:41:48 -0400317 * size of this class, so we have nowhere to store the length, which might be
318 * computed later for various operations.)
Christopher Dunnc28610f2015-02-21 11:44:16 -0600319 *
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000320 * Example of usage:
Billy Donahue483eba82019-07-14 18:41:48 -0400321 * \code
322 * static StaticString foo("some text");
323 * Json::Value aValue(foo);
324 * \endcode
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000325 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000326 Value(const StaticString& value);
Billy Donahue483eba82019-07-14 18:41:48 -0400327 Value(const String& value);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000328#ifdef JSON_USE_CPPTL
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000329 Value(const CppTL::ConstString& value);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000330#endif
331 Value(bool value);
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000332 Value(const Value& other);
Motti2b008912015-04-20 17:44:47 +0300333 Value(Value&& other);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000334 ~Value();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000335
Billy Donahue0c1cc6e2019-01-20 23:59:16 -0500336 /// \note Overwrite existing comments. To preserve comments, use
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400337 /// #swapPayload().
Billy Donahue0c1cc6e2019-01-20 23:59:16 -0500338 Value& operator=(const Value& other);
339 Value& operator=(Value&& other);
Dhruv Paranjape8996c372017-07-08 17:27:07 +0530340
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600341 /// Swap everything.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000342 void swap(Value& other);
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600343 /// Swap values but leave comments and source offsets in place.
344 void swapPayload(Value& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000345
Dhruv Paranjape8996c372017-07-08 17:27:07 +0530346 /// copy everything.
347 void copy(const Value& other);
348 /// copy values but leave comments and source offsets in place.
349 void copyPayload(const Value& other);
350
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000351 ValueType type() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000352
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600353 /// Compare payload only, not comments etc.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000354 bool operator<(const Value& other) const;
355 bool operator<=(const Value& other) const;
356 bool operator>=(const Value& other) const;
357 bool operator>(const Value& other) const;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000358 bool operator==(const Value& other) const;
359 bool operator!=(const Value& other) const;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000360 int compare(const Value& other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000361
Christopher Dunn8a702972015-03-03 10:38:27 -0600362 const char* asCString() const; ///< Embedded zeroes could cause you trouble!
dawescae564652016-03-14 19:11:02 -0500363#if JSONCPP_USING_SECURE_MEMORY
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400364 unsigned getCStringLength() const; // Allows you to understand the length of
365 // the CString
dawescae564652016-03-14 19:11:02 -0500366#endif
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500367 String asString() const; ///< Embedded zeroes are possible.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600368 /** Get raw char* of string-value.
369 * \return false if !string. (Seg-fault if str or end are NULL.)
370 */
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400371 bool getString(char const** begin, char const** end) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000372#ifdef JSON_USE_CPPTL
373 CppTL::ConstString asConstString() const;
374#endif
375 Int asInt() const;
376 UInt asUInt() const;
Aaron Jacobsf1053e72011-05-24 03:18:02 +0000377#if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000378 Int64 asInt64() const;
379 UInt64 asUInt64() const;
Aaron Jacobsf1053e72011-05-24 03:18:02 +0000380#endif // if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000381 LargestInt asLargestInt() const;
382 LargestUInt asLargestUInt() const;
383 float asFloat() const;
384 double asDouble() const;
385 bool asBool() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000386
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000387 bool isNull() const;
388 bool isBool() const;
389 bool isInt() const;
390 bool isInt64() const;
391 bool isUInt() const;
392 bool isUInt64() const;
393 bool isIntegral() const;
394 bool isDouble() const;
395 bool isNumeric() const;
396 bool isString() const;
397 bool isArray() const;
398 bool isObject() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000399
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000400 bool isConvertibleTo(ValueType other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000401
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000402 /// Number of values in array or object
403 ArrayIndex size() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000404
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000405 /// \brief Return true if empty array, empty object, or null;
406 /// otherwise, false.
407 bool empty() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000408
Wolfram Rösler90794222017-12-05 18:18:55 +0100409 /// Return !isNull()
drgler04abe382018-01-13 15:28:19 +0100410 JSONCPP_OP_EXPLICIT operator bool() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000411
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000412 /// Remove all object members and array elements.
413 /// \pre type() is arrayValue, objectValue, or nullValue
414 /// \post type() is unchanged
415 void clear();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000416
Marian Klymovfc201342018-06-02 20:15:26 +0300417 /// Resize the array to newSize elements.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000418 /// New elements are initialized to null.
419 /// May only be called on nullValue or arrayValue.
420 /// \pre type() is arrayValue or nullValue
421 /// \post type() is arrayValue
Marian Klymovfc201342018-06-02 20:15:26 +0300422 void resize(ArrayIndex newSize);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000423
Billy Donahue483eba82019-07-14 18:41:48 -0400424 //@{
425 /// Access an array element (zero based index). If the array contains less
426 /// than index element, then null value are inserted in the array so that
427 /// its size is index+1.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000428 /// (You may need to say 'value[0u]' to get your compiler to distinguish
Billy Donahue483eba82019-07-14 18:41:48 -0400429 /// this from the operator[] which takes a string.)
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000430 Value& operator[](ArrayIndex index);
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000431 Value& operator[](int index);
Billy Donahue483eba82019-07-14 18:41:48 -0400432 //@}
Baptiste Lepilleurfa130ef2010-12-24 12:47:14 +0000433
Billy Donahue483eba82019-07-14 18:41:48 -0400434 //@{
435 /// Access an array element (zero based index).
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000436 /// (You may need to say 'value[0u]' to get your compiler to distinguish
Billy Donahue483eba82019-07-14 18:41:48 -0400437 /// this from the operator[] which takes a string.)
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000438 const Value& operator[](ArrayIndex index) const;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000439 const Value& operator[](int index) const;
Billy Donahue483eba82019-07-14 18:41:48 -0400440 //@}
Baptiste Lepilleurfa130ef2010-12-24 12:47:14 +0000441
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000442 /// If the array contains at least index+1 elements, returns the element
Billy Donahue483eba82019-07-14 18:41:48 -0400443 /// value, otherwise returns defaultValue.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000444 Value get(ArrayIndex index, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000445 /// Return true if index < size().
446 bool isValidIndex(ArrayIndex index) const;
447 /// \brief Append value to array at the end.
448 ///
449 /// Equivalent to jsonvalue[jsonvalue.size()] = value;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000450 Value& append(const Value& value);
Dhruv Paranjape23c44d92017-07-08 17:30:47 +0530451 Value& append(Value&& value);
Dhruv Paranjape23c44d92017-07-08 17:30:47 +0530452
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000453 /// Access an object value by name, create a null member if it does not exist.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600454 /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
Billy Donahue483eba82019-07-14 18:41:48 -0400455 /// Exceeding that will cause an exception.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000456 Value& operator[](const char* key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000457 /// Access an object value by name, returns null if there is no member with
458 /// that name.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000459 const Value& operator[](const char* key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000460 /// Access an object value by name, create a null member if it does not exist.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600461 /// \param key may contain embedded nulls.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500462 Value& operator[](const String& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000463 /// Access an object value by name, returns null if there is no member with
464 /// that name.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600465 /// \param key may contain embedded nulls.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500466 const Value& operator[](const String& key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000467 /** \brief Access an object value by name, create a null member if it does not
Billy Donahue483eba82019-07-14 18:41:48 -0400468 * exist.
469 *
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400470 * If the object has no entry for that name, then the member name used to
Billy Donahue483eba82019-07-14 18:41:48 -0400471 * store the new entry is not duplicated.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000472 * Example of use:
Billy Donahue483eba82019-07-14 18:41:48 -0400473 * \code
474 * Json::Value object;
475 * static const StaticString code("code");
476 * object[code] = 1234;
477 * \endcode
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000478 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000479 Value& operator[](const StaticString& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000480#ifdef JSON_USE_CPPTL
481 /// Access an object value by name, create a null member if it does not exist.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000482 Value& operator[](const CppTL::ConstString& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000483 /// Access an object value by name, returns null if there is no member with
484 /// that name.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000485 const Value& operator[](const CppTL::ConstString& key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000486#endif
487 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600488 /// \note deep copy
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000489 Value get(const char* key, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000490 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600491 /// \note deep copy
Christopher Dunn89704032015-07-11 12:09:59 -0500492 /// \note key may contain embedded nulls.
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400493 Value
494 get(const char* begin, const char* end, const Value& defaultValue) const;
Christopher Dunn25342ba2015-03-02 18:05:26 -0600495 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600496 /// \note deep copy
Christopher Dunn25342ba2015-03-02 18:05:26 -0600497 /// \param key may contain embedded nulls.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500498 Value get(const String& key, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000499#ifdef JSON_USE_CPPTL
500 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600501 /// \note deep copy
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000502 Value get(const CppTL::ConstString& key, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000503#endif
Christopher Dunn25342ba2015-03-02 18:05:26 -0600504 /// Most general and efficient version of isMember()const, get()const,
505 /// and operator[]const
Christopher Dunn89704032015-07-11 12:09:59 -0500506 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
507 Value const* find(char const* begin, char const* end) const;
Christopher Dunnc28610f2015-02-21 11:44:16 -0600508 /// Most general and efficient version of object-mutators.
Christopher Dunn89704032015-07-11 12:09:59 -0500509 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
Christopher Dunnc28610f2015-02-21 11:44:16 -0600510 /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
Frank Richterd76fe562019-03-23 14:31:06 +0100511 Value* demand(char const* begin, char const* end);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000512 /// \brief Remove and return the named member.
513 ///
514 /// Do nothing if it did not exist.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000515 /// \pre type() is objectValue or nullValue
516 /// \post type() is unchanged
Wolfram Röslera06b3902017-10-18 07:19:27 +0200517 void removeMember(const char* key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000518 /// Same as removeMember(const char*)
Christopher Dunn25342ba2015-03-02 18:05:26 -0600519 /// \param key may contain embedded nulls.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500520 void removeMember(const String& key);
Christopher Dunn89704032015-07-11 12:09:59 -0500521 /// Same as removeMember(const char* begin, const char* end, Value* removed),
Christopher Dunn25342ba2015-03-02 18:05:26 -0600522 /// but 'key' is null-terminated.
523 bool removeMember(const char* key, Value* removed);
Christopher Dunn76746b02015-01-21 16:01:30 -0600524 /** \brief Remove the named map member.
Billy Donahue483eba82019-07-14 18:41:48 -0400525 *
526 * Update 'removed' iff removed.
527 * \param key may contain embedded nulls.
528 * \return true iff removed (no exceptions)
529 */
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500530 bool removeMember(String const& key, Value* removed);
531 /// Same as removeMember(String const& key, Value* removed)
Christopher Dunn89704032015-07-11 12:09:59 -0500532 bool removeMember(const char* begin, const char* end, Value* removed);
Christopher Dunn9de2c2d2015-01-20 16:15:40 -0600533 /** \brief Remove the indexed array element.
Billy Donahue483eba82019-07-14 18:41:48 -0400534 *
535 * O(n) expensive operations.
536 * Update 'removed' iff removed.
537 * \return true if removed (no exceptions)
538 */
Marian Klymovfc201342018-06-02 20:15:26 +0300539 bool removeIndex(ArrayIndex index, Value* removed);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000540
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000541 /// Return true if the object has a member named key.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600542 /// \note 'key' must be null-terminated.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000543 bool isMember(const char* key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000544 /// Return true if the object has a member named key.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600545 /// \param key may contain embedded nulls.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500546 bool isMember(const String& key) const;
547 /// Same as isMember(String const& key)const
Christopher Dunn89704032015-07-11 12:09:59 -0500548 bool isMember(const char* begin, const char* end) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000549#ifdef JSON_USE_CPPTL
550 /// Return true if the object has a member named key.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000551 bool isMember(const CppTL::ConstString& key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000552#endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000553
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000554 /// \brief Return a list of the member names.
555 ///
556 /// If null, return an empty list.
557 /// \pre type() is objectValue or nullValue
558 /// \post if type() was nullValue, it remains nullValue
559 Members getMemberNames() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000560
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000561 //# ifdef JSON_USE_CPPTL
562 // EnumMemberNames enumMemberNames() const;
563 // EnumValues enumValues() const;
564 //# endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000565
Christopher Dunn1e3149a2015-01-25 14:16:13 -0600566 /// \deprecated Always pass len.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500567 JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
Billy Donahue433107f2019-01-20 21:53:01 -0500568 void setComment(const char* comment, CommentPlacement placement) {
569 setComment(String(comment, strlen(comment)), placement);
570 }
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000571 /// Comments must be //... or /* ... */
Billy Donahue433107f2019-01-20 21:53:01 -0500572 void setComment(const char* comment, size_t len, CommentPlacement placement) {
573 setComment(String(comment, len), placement);
574 }
Christopher Dunn1e3149a2015-01-25 14:16:13 -0600575 /// Comments must be //... or /* ... */
Billy Donahue433107f2019-01-20 21:53:01 -0500576 void setComment(String comment, CommentPlacement placement);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000577 bool hasComment(CommentPlacement placement) const;
578 /// Include delimiters and embedded newlines.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500579 String getComment(CommentPlacement placement) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000580
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500581 String toStyledString() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000582
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000583 const_iterator begin() const;
584 const_iterator end() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000585
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000586 iterator begin();
587 iterator end();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000588
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000589 // Accessors for the [start, limit) range of bytes within the JSON text from
590 // which this value was parsed, if any.
Christopher Dunnd4513fc2016-02-06 09:25:20 -0600591 void setOffsetStart(ptrdiff_t start);
592 void setOffsetLimit(ptrdiff_t limit);
593 ptrdiff_t getOffsetStart() const;
594 ptrdiff_t getOffsetLimit() const;
Aaron Jacobs68db6552014-04-23 23:41:12 +0000595
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000596private:
Jordan Baylesd5bd1a72019-06-24 14:06:45 -0700597 void setType(ValueType v) {
598 bits_.value_type_ = static_cast<unsigned char>(v);
599 }
Billy Donahue0c1cc6e2019-01-20 23:59:16 -0500600 bool isAllocated() const { return bits_.allocated_; }
601 void setIsAllocated(bool v) { bits_.allocated_ = v; }
602
Billy Donahue8eb5d892014-11-10 01:35:42 -0500603 void initBasic(ValueType type, bool allocated = false);
Andrey Okoshkin9b569c82018-01-12 15:59:20 +0300604 void dupPayload(const Value& other);
Andrey Okoshkinc69148c2018-01-12 11:26:34 +0300605 void releasePayload();
Andrey Okoshkin9b569c82018-01-12 15:59:20 +0300606 void dupMeta(const Value& other);
Billy Donahue8eb5d892014-11-10 01:35:42 -0500607
Christopher Dunnc28610f2015-02-21 11:44:16 -0600608 Value& resolveReference(const char* key);
609 Value& resolveReference(const char* key, const char* end);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000610
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000611 // struct MemberNamesTransform
612 //{
613 // typedef const char *result_type;
614 // const char *operator()( const CZString &name ) const
615 // {
616 // return name.c_str();
617 // }
618 //};
619
620 union ValueHolder {
621 LargestInt int_;
622 LargestUInt uint_;
623 double real_;
624 bool bool_;
Billy Donahue0c1cc6e2019-01-20 23:59:16 -0500625 char* string_; // if allocated_, ptr to { unsigned, char[] }.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000626 ObjectValues* map_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000627 } value_;
Billy Donahue0c1cc6e2019-01-20 23:59:16 -0500628
629 struct {
630 // Really a ValueType, but types should agree for bitfield packing.
631 unsigned int value_type_ : 8;
632 // Unless allocated_, string_ must be null-terminated.
633 unsigned int allocated_ : 1;
634 } bits_;
635
Billy Donahue433107f2019-01-20 21:53:01 -0500636 class Comments {
637 public:
638 Comments() = default;
639 Comments(const Comments& that);
Billy Donahue00558b32019-01-21 16:42:25 -0500640 Comments(Comments&& that);
Billy Donahue433107f2019-01-20 21:53:01 -0500641 Comments& operator=(const Comments& that);
Billy Donahue00558b32019-01-21 16:42:25 -0500642 Comments& operator=(Comments&& that);
Billy Donahue433107f2019-01-20 21:53:01 -0500643 bool has(CommentPlacement slot) const;
644 String get(CommentPlacement slot) const;
645 void set(CommentPlacement slot, String s);
646
647 private:
648 using Array = std::array<String, numberOfCommentPlacement>;
649 std::unique_ptr<Array> ptr_;
650 };
651 Comments comments_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000652
653 // [start, limit) byte offsets in the source JSON text from which this Value
654 // was extracted.
Christopher Dunnd4513fc2016-02-06 09:25:20 -0600655 ptrdiff_t start_;
656 ptrdiff_t limit_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000657};
658
659/** \brief Experimental and untested: represents an element of the "path" to
660 * access a node.
661 */
662class JSON_API PathArgument {
663public:
664 friend class Path;
665
666 PathArgument();
667 PathArgument(ArrayIndex index);
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000668 PathArgument(const char* key);
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500669 PathArgument(const String& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000670
671private:
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400672 enum Kind { kindNone = 0, kindIndex, kindKey };
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500673 String key_;
Hans Johnsone817e4f2019-01-14 17:09:22 -0600674 ArrayIndex index_{};
Billy Donahue2b593a92019-01-18 03:46:57 -0500675 Kind kind_{kindNone};
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000676};
677
678/** \brief Experimental and untested: represents a "path" to access a node.
679 *
680 * Syntax:
681 * - "." => root node
682 * - ".[n]" => elements at index 'n' of root node (an array value)
683 * - ".name" => member named 'name' of root node (an object value)
684 * - ".name1.name2.name3"
685 * - ".[0][1][2].name1[3]"
686 * - ".%" => member name is provided as parameter
687 * - ".[%]" => index is provied as parameter
688 */
689class JSON_API Path {
690public:
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500691 Path(const String& path,
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000692 const PathArgument& a1 = PathArgument(),
693 const PathArgument& a2 = PathArgument(),
694 const PathArgument& a3 = PathArgument(),
695 const PathArgument& a4 = PathArgument(),
696 const PathArgument& a5 = PathArgument());
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000697
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000698 const Value& resolve(const Value& root) const;
699 Value resolve(const Value& root, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000700 /// Creates the "path" to access the specified node and returns a reference on
701 /// the node.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000702 Value& make(Value& root) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000703
704private:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000705 typedef std::vector<const PathArgument*> InArgs;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000706 typedef std::vector<PathArgument> Args;
707
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500708 void makePath(const String& path, const InArgs& in);
709 void addPathInArg(const String& path,
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000710 const InArgs& in,
711 InArgs::const_iterator& itInArg,
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000712 PathArgument::Kind kind);
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500713 static void invalidPath(const String& path, int location);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000714
715 Args args_;
716};
717
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000718/** \brief base class for Value iterators.
719 *
720 */
721class JSON_API ValueIteratorBase {
722public:
723 typedef std::bidirectional_iterator_tag iterator_category;
724 typedef unsigned int size_t;
725 typedef int difference_type;
726 typedef ValueIteratorBase SelfType;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000727
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000728 bool operator==(const SelfType& other) const { return isEqual(other); }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000729
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000730 bool operator!=(const SelfType& other) const { return !isEqual(other); }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000731
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000732 difference_type operator-(const SelfType& other) const {
Kevin Grant4c5832a2015-02-14 20:53:35 -0800733 return other.computeDistance(*this);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000734 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000735
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000736 /// Return either the index or the member name of the referenced value as a
737 /// Value.
738 Value key() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000739
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400740 /// Return the index of the referenced Value, or -1 if it is not an
741 /// arrayValue.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000742 UInt index() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000743
Christopher Dunned495ed2015-03-08 14:01:28 -0500744 /// Return the member name of the referenced Value, or "" if it is not an
745 /// objectValue.
746 /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
Billy Donahue1c2ed7a2019-01-17 16:35:29 -0500747 String name() const;
Christopher Dunned495ed2015-03-08 14:01:28 -0500748
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000749 /// Return the member name of the referenced Value. "" if it is not an
750 /// objectValue.
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400751 /// \deprecated This cannot be used for UTF-8 strings, since there can be
752 /// embedded nulls.
Christopher Dunned495ed2015-03-08 14:01:28 -0500753 JSONCPP_DEPRECATED("Use `key = name();` instead.")
Christopher Dunnc28610f2015-02-21 11:44:16 -0600754 char const* memberName() const;
755 /// Return the member name of the referenced Value, or NULL if it is not an
756 /// objectValue.
Christopher Dunned495ed2015-03-08 14:01:28 -0500757 /// \note Better version than memberName(). Allows embedded nulls.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600758 char const* memberName(char const** end) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000759
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000760protected:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000761 Value& deref() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000762
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000763 void increment();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000764
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000765 void decrement();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000766
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000767 difference_type computeDistance(const SelfType& other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000768
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000769 bool isEqual(const SelfType& other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000770
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000771 void copy(const SelfType& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000772
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000773private:
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000774 Value::ObjectValues::iterator current_;
775 // Indicates that iterator is for a null value.
Billy Donahue2b593a92019-01-18 03:46:57 -0500776 bool isNull_{true};
Christopher Dunn2a10f4a2015-04-28 04:55:12 +0100777
778public:
779 // For some reason, BORLAND needs these at the end, rather
780 // than earlier. No idea why.
781 ValueIteratorBase();
782 explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000783};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000784
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000785/** \brief const iterator for object and array value.
786 *
787 */
788class JSON_API ValueConstIterator : public ValueIteratorBase {
789 friend class Value;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000790
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000791public:
792 typedef const Value value_type;
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400793 // typedef unsigned int size_t;
794 // typedef int difference_type;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000795 typedef const Value& reference;
796 typedef const Value* pointer;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000797 typedef ValueConstIterator SelfType;
798
799 ValueConstIterator();
ycqiuc8a8cfc2015-10-06 16:46:19 +0800800 ValueConstIterator(ValueIterator const& other);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000801
802private:
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400803 /*! \internal Use by Value to create an iterator.
804 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000805 explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400806
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000807public:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000808 SelfType& operator=(const ValueIteratorBase& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000809
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000810 SelfType operator++(int) {
811 SelfType temp(*this);
812 ++*this;
813 return temp;
814 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000815
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000816 SelfType operator--(int) {
817 SelfType temp(*this);
818 --*this;
819 return temp;
820 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000821
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000822 SelfType& operator--() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000823 decrement();
824 return *this;
825 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000826
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000827 SelfType& operator++() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000828 increment();
829 return *this;
830 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000831
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000832 reference operator*() const { return deref(); }
Braden McDorman540db3b2014-09-14 02:31:23 -0500833
834 pointer operator->() const { return &deref(); }
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000835};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000836
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000837/** \brief Iterator for object and array value.
838 */
839class JSON_API ValueIterator : public ValueIteratorBase {
840 friend class Value;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000841
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000842public:
843 typedef Value value_type;
844 typedef unsigned int size_t;
845 typedef int difference_type;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000846 typedef Value& reference;
847 typedef Value* pointer;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000848 typedef ValueIterator SelfType;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000849
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000850 ValueIterator();
ycqiuc8a8cfc2015-10-06 16:46:19 +0800851 explicit ValueIterator(const ValueConstIterator& other);
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000852 ValueIterator(const ValueIterator& other);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000853
854private:
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400855 /*! \internal Use by Value to create an iterator.
856 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000857 explicit ValueIterator(const Value::ObjectValues::iterator& current);
Billy Donahueb5e1fe82018-05-20 16:55:27 -0400858
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000859public:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000860 SelfType& operator=(const SelfType& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000861
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000862 SelfType operator++(int) {
863 SelfType temp(*this);
864 ++*this;
865 return temp;
866 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000867
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000868 SelfType operator--(int) {
869 SelfType temp(*this);
870 --*this;
871 return temp;
872 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000873
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000874 SelfType& operator--() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000875 decrement();
876 return *this;
877 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000878
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000879 SelfType& operator++() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000880 increment();
881 return *this;
882 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000883
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000884 reference operator*() const { return deref(); }
Braden McDorman540db3b2014-09-14 02:31:23 -0500885
886 pointer operator->() const { return &deref(); }
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000887};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000888
Billy Donahue1d956282018-03-06 12:51:58 -0500889inline void swap(Value& a, Value& b) { a.swap(b); }
890
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000891} // namespace Json
892
Sergiy80d6e666f2016-12-03 22:29:14 +0200893#pragma pack(pop)
datadiode9454e682015-01-20 15:25:04 -0600894
Baptiste Lepilleureafd7022013-05-08 20:21:11 +0000895#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000896#pragma warning(pop)
Baptiste Lepilleureafd7022013-05-08 20:21:11 +0000897#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
898
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000899#endif // CPPTL_JSON_H_INCLUDED