blob: c39f423fa5adf0831e78d5d96894d10bf3337970 [file] [log] [blame]
Baptiste Lepilleur7469f1d2010-04-20 21:35:19 +00001// Copyright 2007-2010 Baptiste Lepilleur
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
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)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100012#include <string>
13#include <vector>
Christopher Dunn75279cc2015-03-08 12:20:06 -050014#include <exception>
Christopher Dunn6d135cb2007-06-13 15:51:04 +000015
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100016#ifndef JSON_USE_CPPTL_SMALLMAP
17#include <map>
18#else
19#include <cpptl/smallmap.h>
20#endif
21#ifdef JSON_USE_CPPTL
22#include <cpptl/forwards.h>
23#endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +000024
Gauravd97ea5b2016-03-16 11:15:09 +053025//Conditional NORETURN attribute on the throw functions would:
26// a) suppress false positives from static code analysis
27// b) possibly improve optimization opportunities.
28#if !defined(JSONCPP_NORETURN)
29# if defined(_MSC_VER)
30# define JSONCPP_NORETURN __declspec(noreturn)
31# elif defined(__GNUC__)
32# define JSONCPP_NORETURN __attribute__ ((__noreturn__))
33# else
34# define JSONCPP_NORETURN
35# endif
36#endif
37
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100038// Disable warning C4251: <data member>: <type> needs to have dll-interface to
39// be used by...
Baptiste Lepilleureafd7022013-05-08 20:21:11 +000040#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100041#pragma warning(push)
42#pragma warning(disable : 4251)
Baptiste Lepilleureafd7022013-05-08 20:21:11 +000043#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
44
Sergiy80d6e666f2016-12-03 22:29:14 +020045#pragma pack(push, 8)
46
Christopher Dunn6d135cb2007-06-13 15:51:04 +000047/** \brief JSON (JavaScript Object Notation).
48 */
49namespace Json {
50
Christopher Dunn75279cc2015-03-08 12:20:06 -050051/** Base class for all exceptions we throw.
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050052 *
53 * We use nothing but these internally. Of course, STL can throw others.
Christopher Dunn75279cc2015-03-08 12:20:06 -050054 */
Christopher Dunn949babd2015-07-23 00:19:12 -050055class JSON_API Exception : public std::exception {
56public:
Christopher Dunnde5b7922016-03-06 11:19:46 -060057 Exception(JSONCPP_STRING const& msg);
Omkar Wagh91c1d232016-11-07 13:57:00 -050058 ~Exception() JSONCPP_NOEXCEPT JSONCPP_OVERRIDE;
59 char const* what() const JSONCPP_NOEXCEPT JSONCPP_OVERRIDE;
Christopher Dunn949babd2015-07-23 00:19:12 -050060protected:
Christopher Dunnde5b7922016-03-06 11:19:46 -060061 JSONCPP_STRING msg_;
Christopher Dunn949babd2015-07-23 00:19:12 -050062};
63
Christopher Dunn53837942015-03-08 12:31:00 -050064/** Exceptions which the user cannot easily avoid.
65 *
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050066 * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
67 *
68 * \remark derived from Json::Exception
Christopher Dunn53837942015-03-08 12:31:00 -050069 */
Christopher Dunn949babd2015-07-23 00:19:12 -050070class JSON_API RuntimeError : public Exception {
71public:
Christopher Dunnde5b7922016-03-06 11:19:46 -060072 RuntimeError(JSONCPP_STRING const& msg);
Christopher Dunn949babd2015-07-23 00:19:12 -050073};
74
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050075/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
Christopher Dunn53837942015-03-08 12:31:00 -050076 *
77 * These are precondition-violations (user bugs) and internal errors (our bugs).
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050078 *
79 * \remark derived from Json::Exception
Christopher Dunn53837942015-03-08 12:31:00 -050080 */
Christopher Dunn949babd2015-07-23 00:19:12 -050081class JSON_API LogicError : public Exception {
82public:
Christopher Dunnde5b7922016-03-06 11:19:46 -060083 LogicError(JSONCPP_STRING const& msg);
Christopher Dunn949babd2015-07-23 00:19:12 -050084};
Christopher Dunn53837942015-03-08 12:31:00 -050085
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050086/// used internally
Gauravd97ea5b2016-03-16 11:15:09 +053087JSONCPP_NORETURN void throwRuntimeError(JSONCPP_STRING const& msg);
Christopher Dunn4e30c4f2015-03-08 12:56:32 -050088/// used internally
Gauravd97ea5b2016-03-16 11:15:09 +053089JSONCPP_NORETURN void throwLogicError(JSONCPP_STRING const& msg);
Christopher Dunn75279cc2015-03-08 12:20:06 -050090
Aaron Jacobs9fa4e842014-07-01 08:48:54 +100091/** \brief Type of the value held by a Value object.
92 */
93enum ValueType {
94 nullValue = 0, ///< 'null' value
95 intValue, ///< signed integer value
96 uintValue, ///< unsigned integer value
97 realValue, ///< double value
98 stringValue, ///< UTF-8 string value
99 booleanValue, ///< bool value
100 arrayValue, ///< array value (ordered list)
101 objectValue ///< object value (collection of name/value pairs).
102};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000103
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000104enum CommentPlacement {
105 commentBefore = 0, ///< a comment placed on the line before a value
106 commentAfterOnSameLine, ///< a comment just after a value on the same line
107 commentAfter, ///< a comment on the line after a value (only make sense for
Aaron Jacobs3a0c4fc2014-07-01 09:20:48 +1000108 /// root value)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000109 numberOfCommentPlacement
110};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000111
112//# ifdef JSON_USE_CPPTL
113// typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
114// typedef CppTL::AnyEnumerator<const Value &> EnumValues;
115//# endif
116
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000117/** \brief Lightweight wrapper to tag static string.
118 *
119 * Value constructor and objectValue member assignement takes advantage of the
120 * StaticString and avoid the cost of string duplication when storing the
121 * string or the member name.
122 *
123 * Example of usage:
124 * \code
125 * Json::Value aValue( StaticString("some text") );
126 * Json::Value object;
127 * static const StaticString code("code");
128 * object[code] = 1234;
129 * \endcode
130 */
131class JSON_API StaticString {
132public:
Christopher Dunnff617522015-03-06 10:31:46 -0600133 explicit StaticString(const char* czstring) : c_str_(czstring) {}
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000134
Christopher Dunnff617522015-03-06 10:31:46 -0600135 operator const char*() const { return c_str_; }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000136
Christopher Dunnff617522015-03-06 10:31:46 -0600137 const char* c_str() const { return c_str_; }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000138
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000139private:
Christopher Dunnff617522015-03-06 10:31:46 -0600140 const char* c_str_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000141};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000142
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000143/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
144 *
145 * This class is a discriminated union wrapper that can represents a:
146 * - signed integer [range: Value::minInt - Value::maxInt]
147 * - unsigned integer (range: 0 - Value::maxUInt)
148 * - double
149 * - UTF-8 string
150 * - boolean
151 * - 'null'
152 * - an ordered list of Value
153 * - collection of name/value pairs (javascript object)
154 *
155 * The type of the held value is represented by a #ValueType and
156 * can be obtained using type().
157 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600158 * Values of an #objectValue or #arrayValue can be accessed using operator[]()
159 * methods.
160 * Non-const methods will automatically create the a #nullValue element
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000161 * if it does not exist.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600162 * The sequence of an #arrayValue will be automatically resized and initialized
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000163 * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
164 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600165 * The get() methods can be used to obtain default value in the case the
166 * required element does not exist.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000167 *
168 * It is possible to iterate over the list of a #objectValue values using
169 * the getMemberNames() method.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600170 *
Christopher Dunnc28610f2015-02-21 11:44:16 -0600171 * \note #Value string-length fit in size_t, but keys must be < 2^30.
172 * (The reason is an implementation detail.) A #CharReader will raise an
Christopher Dunn25342ba2015-03-02 18:05:26 -0600173 * exception if a bound is exceeded to avoid security holes in your app,
174 * but the Value API does *not* check bounds. That is the responsibility
175 * of the caller.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000176 */
177class JSON_API Value {
178 friend class ValueIteratorBase;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000179public:
Christopher Dunnde5b7922016-03-06 11:19:46 -0600180 typedef std::vector<JSONCPP_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
Christopher Dunn8a702972015-03-03 10:38:27 -0600193 static const Value& null; ///< We regret this reference to a global instance; prefer the simpler Value().
194 static const Value& nullRef; ///< just a kludge for binary-compatibility; same as null
Christopher Dunn0f288ae2016-06-26 18:47:43 -0500195 static Value const& nullSingleton(); ///< Prefer this to null or nullRef.
196
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000197 /// Minimum signed integer value that can be stored in a Json::Value.
198 static const LargestInt minLargestInt;
199 /// Maximum signed integer value that can be stored in a Json::Value.
200 static const LargestInt maxLargestInt;
201 /// Maximum unsigned integer value that can be stored in a Json::Value.
202 static const LargestUInt maxLargestUInt;
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000203
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000204 /// Minimum signed int value that can be stored in a Json::Value.
205 static const Int minInt;
206 /// Maximum signed int value that can be stored in a Json::Value.
207 static const Int maxInt;
208 /// Maximum unsigned int value that can be stored in a Json::Value.
209 static const UInt maxUInt;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000210
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000211#if defined(JSON_HAS_INT64)
212 /// Minimum signed 64 bits int value that can be stored in a Json::Value.
213 static const Int64 minInt64;
214 /// Maximum signed 64 bits int value that can be stored in a Json::Value.
215 static const Int64 maxInt64;
216 /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
217 static const UInt64 maxUInt64;
Aaron Jacobsf1053e72011-05-24 03:18:02 +0000218#endif // defined(JSON_HAS_INT64)
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000219
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000220private:
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000221#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000222 class CZString {
223 public:
224 enum DuplicationPolicy {
225 noDuplication = 0,
226 duplicate,
227 duplicateOnCopy
228 };
229 CZString(ArrayIndex index);
Christopher Dunnc28610f2015-02-21 11:44:16 -0600230 CZString(char const* str, unsigned length, DuplicationPolicy allocate);
231 CZString(CZString const& other);
Motti2b008912015-04-20 17:44:47 +0300232#if JSON_HAS_RVALUE_REFERENCES
233 CZString(CZString&& other);
234#endif
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000235 ~CZString();
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000236 CZString& operator=(CZString other);
Christopher Dunnc28610f2015-02-21 11:44:16 -0600237 bool operator<(CZString const& other) const;
238 bool operator==(CZString const& other) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000239 ArrayIndex index() const;
Christopher Dunnc28610f2015-02-21 11:44:16 -0600240 //const char* c_str() const; ///< \deprecated
241 char const* data() const;
242 unsigned length() const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000243 bool isStaticString() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000244
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000245 private:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000246 void swap(CZString& other);
Christopher Dunnc28610f2015-02-21 11:44:16 -0600247
Christopher Dunn57ad0512015-03-02 12:10:35 -0600248 struct StringStorage {
Dan Liufcbab022015-04-27 05:20:05 +0100249 unsigned policy_: 2;
Christopher Dunn57ad0512015-03-02 12:10:35 -0600250 unsigned length_: 30; // 1GB max
251 };
252
Christopher Dunnc28610f2015-02-21 11:44:16 -0600253 char const* cstr_; // actually, a prefixed string, unless policy is noDup
Christopher Dunn57ad0512015-03-02 12:10:35 -0600254 union {
255 ArrayIndex index_;
256 StringStorage storage_;
257 };
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000258 };
259
260public:
261#ifndef JSON_USE_CPPTL_SMALLMAP
262 typedef std::map<CZString, Value> ObjectValues;
263#else
264 typedef CppTL::SmallMap<CZString, Value> ObjectValues;
265#endif // ifndef JSON_USE_CPPTL_SMALLMAP
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000266#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
267
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000268public:
269 /** \brief Create a default Value of the given type.
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000270
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000271 This is a very useful constructor.
272 To create an empty array, pass arrayValue.
273 To create an empty object, pass objectValue.
274 Another Value can then be set to this one by assignment.
275This is useful since clear() and resize() will not alter types.
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000276
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000277 Examples:
278\code
279Json::Value null_value; // null
280Json::Value arr_value(Json::arrayValue); // []
281Json::Value obj_value(Json::objectValue); // {}
282\endcode
283 */
284 Value(ValueType type = nullValue);
285 Value(Int value);
286 Value(UInt value);
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000287#if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000288 Value(Int64 value);
289 Value(UInt64 value);
Baptiste Lepilleur842e9ac2010-12-27 17:45:23 +0000290#endif // if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000291 Value(double value);
Christopher Dunn8a702972015-03-03 10:38:27 -0600292 Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
Christopher Dunn89704032015-07-11 12:09:59 -0500293 Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000294 /** \brief Constructs a value from a static string.
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000295
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000296 * Like other value string constructor but do not duplicate the string for
297 * internal storage. The given string must remain alive after the call to this
298 * constructor.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600299 * \note This works only for null-terminated strings. (We cannot change the
300 * size of this class, so we have nowhere to store the length,
301 * which might be computed later for various operations.)
302 *
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000303 * Example of usage:
304 * \code
Christopher Dunnc28610f2015-02-21 11:44:16 -0600305 * static StaticString foo("some text");
306 * Json::Value aValue(foo);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000307 * \endcode
308 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000309 Value(const StaticString& value);
Christopher Dunnde5b7922016-03-06 11:19:46 -0600310 Value(const JSONCPP_STRING& value); ///< Copy data() til size(). Embedded zeroes too.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000311#ifdef JSON_USE_CPPTL
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000312 Value(const CppTL::ConstString& value);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000313#endif
314 Value(bool value);
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600315 /// Deep copy.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000316 Value(const Value& other);
Motti2b008912015-04-20 17:44:47 +0300317#if JSON_HAS_RVALUE_REFERENCES
318 /// Move constructor
319 Value(Value&& other);
320#endif
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000321 ~Value();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000322
Christopher Dunn7f439f42015-03-06 09:22:57 -0600323 /// Deep copy, then swap(other).
324 /// \note Over-write existing comments. To preserve comments, use #swapPayload().
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000325 Value& operator=(Value other);
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600326 /// Swap everything.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000327 void swap(Value& other);
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600328 /// Swap values but leave comments and source offsets in place.
329 void swapPayload(Value& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000330
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000331 ValueType type() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000332
Christopher Dunn66eb72f2015-01-20 11:02:22 -0600333 /// Compare payload only, not comments etc.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000334 bool operator<(const Value& other) const;
335 bool operator<=(const Value& other) const;
336 bool operator>=(const Value& other) const;
337 bool operator>(const Value& other) const;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000338 bool operator==(const Value& other) const;
339 bool operator!=(const Value& other) const;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000340 int compare(const Value& other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000341
Christopher Dunn8a702972015-03-03 10:38:27 -0600342 const char* asCString() const; ///< Embedded zeroes could cause you trouble!
dawescae564652016-03-14 19:11:02 -0500343#if JSONCPP_USING_SECURE_MEMORY
344 unsigned getCStringLength() const; //Allows you to understand the length of the CString
345#endif
Christopher Dunnde5b7922016-03-06 11:19:46 -0600346 JSONCPP_STRING asString() const; ///< Embedded zeroes are possible.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600347 /** Get raw char* of string-value.
348 * \return false if !string. (Seg-fault if str or end are NULL.)
349 */
350 bool getString(
Christopher Dunn89704032015-07-11 12:09:59 -0500351 char const** begin, char const** end) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000352#ifdef JSON_USE_CPPTL
353 CppTL::ConstString asConstString() const;
354#endif
355 Int asInt() const;
356 UInt asUInt() const;
Aaron Jacobsf1053e72011-05-24 03:18:02 +0000357#if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000358 Int64 asInt64() const;
359 UInt64 asUInt64() const;
Aaron Jacobsf1053e72011-05-24 03:18:02 +0000360#endif // if defined(JSON_HAS_INT64)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000361 LargestInt asLargestInt() const;
362 LargestUInt asLargestUInt() const;
363 float asFloat() const;
364 double asDouble() const;
365 bool asBool() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000366
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000367 bool isNull() const;
368 bool isBool() const;
369 bool isInt() const;
370 bool isInt64() const;
371 bool isUInt() const;
372 bool isUInt64() const;
373 bool isIntegral() const;
374 bool isDouble() const;
375 bool isNumeric() const;
376 bool isString() const;
377 bool isArray() const;
378 bool isObject() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000379
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000380 bool isConvertibleTo(ValueType other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000381
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000382 /// Number of values in array or object
383 ArrayIndex size() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000384
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000385 /// \brief Return true if empty array, empty object, or null;
386 /// otherwise, false.
387 bool empty() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000388
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000389 /// Return isNull()
390 bool operator!() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000391
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000392 /// Remove all object members and array elements.
393 /// \pre type() is arrayValue, objectValue, or nullValue
394 /// \post type() is unchanged
395 void clear();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000396
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000397 /// Resize the array to size elements.
398 /// New elements are initialized to null.
399 /// May only be called on nullValue or arrayValue.
400 /// \pre type() is arrayValue or nullValue
401 /// \post type() is arrayValue
402 void resize(ArrayIndex size);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000403
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000404 /// Access an array element (zero based index ).
405 /// If the array contains less than index element, then null value are
406 /// inserted
407 /// in the array so that its size is index+1.
408 /// (You may need to say 'value[0u]' to get your compiler to distinguish
409 /// this from the operator[] which takes a string.)
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000410 Value& operator[](ArrayIndex index);
Baptiste Lepilleurfa130ef2010-12-24 12:47:14 +0000411
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000412 /// Access an array element (zero based index ).
413 /// If the array contains less than index element, then null value are
414 /// inserted
415 /// in the array so that its size is index+1.
416 /// (You may need to say 'value[0u]' to get your compiler to distinguish
417 /// this from the operator[] which takes a string.)
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000418 Value& operator[](int index);
Baptiste Lepilleurfa130ef2010-12-24 12:47:14 +0000419
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000420 /// Access an array element (zero based index )
421 /// (You may need to say 'value[0u]' to get your compiler to distinguish
422 /// this from the operator[] which takes a string.)
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000423 const Value& operator[](ArrayIndex index) const;
Baptiste Lepilleurfa130ef2010-12-24 12:47:14 +0000424
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000425 /// Access an array element (zero based index )
426 /// (You may need to say 'value[0u]' to get your compiler to distinguish
427 /// this from the operator[] which takes a string.)
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000428 const Value& operator[](int index) const;
Baptiste Lepilleurfa130ef2010-12-24 12:47:14 +0000429
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000430 /// If the array contains at least index+1 elements, returns the element
431 /// value,
432 /// otherwise returns defaultValue.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000433 Value get(ArrayIndex index, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000434 /// Return true if index < size().
435 bool isValidIndex(ArrayIndex index) const;
436 /// \brief Append value to array at the end.
437 ///
438 /// Equivalent to jsonvalue[jsonvalue.size()] = value;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000439 Value& append(const Value& value);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000440
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000441 /// Access an object value by name, create a null member if it does not exist.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600442 /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
443 /// Exceeding that will cause an exception.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000444 Value& operator[](const char* key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000445 /// Access an object value by name, returns null if there is no member with
446 /// that name.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000447 const Value& operator[](const char* key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000448 /// Access an object value by name, create a null member if it does not exist.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600449 /// \param key may contain embedded nulls.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600450 Value& operator[](const JSONCPP_STRING& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000451 /// Access an object value by name, returns null if there is no member with
452 /// that name.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600453 /// \param key may contain embedded nulls.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600454 const Value& operator[](const JSONCPP_STRING& key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000455 /** \brief Access an object value by name, create a null member if it does not
456 exist.
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000457
Christopher Dunn25342ba2015-03-02 18:05:26 -0600458 * If the object has no entry for that name, then the member name used to store
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000459 * the new entry is not duplicated.
460 * Example of use:
461 * \code
462 * Json::Value object;
463 * static const StaticString code("code");
464 * object[code] = 1234;
465 * \endcode
466 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000467 Value& operator[](const StaticString& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000468#ifdef JSON_USE_CPPTL
469 /// Access an object value by name, create a null member if it does not exist.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000470 Value& operator[](const CppTL::ConstString& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000471 /// Access an object value by name, returns null if there is no member with
472 /// that name.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000473 const Value& operator[](const CppTL::ConstString& key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000474#endif
475 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600476 /// \note deep copy
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000477 Value get(const char* key, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000478 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600479 /// \note deep copy
Christopher Dunn89704032015-07-11 12:09:59 -0500480 /// \note key may contain embedded nulls.
481 Value get(const char* begin, const char* end, const Value& defaultValue) const;
Christopher Dunn25342ba2015-03-02 18:05:26 -0600482 /// Return the member named key if it exist, defaultValue otherwise.
Christopher Dunn0fd28752015-03-05 16:38:43 -0600483 /// \note deep copy
Christopher Dunn25342ba2015-03-02 18:05:26 -0600484 /// \param key may contain embedded nulls.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600485 Value get(const JSONCPP_STRING& key, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000486#ifdef JSON_USE_CPPTL
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 CppTL::ConstString& key, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000490#endif
Christopher Dunn25342ba2015-03-02 18:05:26 -0600491 /// Most general and efficient version of isMember()const, get()const,
492 /// and operator[]const
Christopher Dunn89704032015-07-11 12:09:59 -0500493 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
494 Value const* find(char const* begin, char const* end) const;
Christopher Dunnc28610f2015-02-21 11:44:16 -0600495 /// Most general and efficient version of object-mutators.
Christopher Dunn89704032015-07-11 12:09:59 -0500496 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
Christopher Dunnc28610f2015-02-21 11:44:16 -0600497 /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
Christopher Dunn89704032015-07-11 12:09:59 -0500498 Value const* demand(char const* begin, char const* end);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000499 /// \brief Remove and return the named member.
500 ///
501 /// Do nothing if it did not exist.
502 /// \return the removed Value, or null.
503 /// \pre type() is objectValue or nullValue
504 /// \post type() is unchanged
Christopher Dunn76746b02015-01-21 16:01:30 -0600505 /// \deprecated
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000506 Value removeMember(const char* key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000507 /// Same as removeMember(const char*)
Christopher Dunn25342ba2015-03-02 18:05:26 -0600508 /// \param key may contain embedded nulls.
Christopher Dunn76746b02015-01-21 16:01:30 -0600509 /// \deprecated
Christopher Dunnde5b7922016-03-06 11:19:46 -0600510 Value removeMember(const JSONCPP_STRING& key);
Christopher Dunn89704032015-07-11 12:09:59 -0500511 /// Same as removeMember(const char* begin, const char* end, Value* removed),
Christopher Dunn25342ba2015-03-02 18:05:26 -0600512 /// but 'key' is null-terminated.
513 bool removeMember(const char* key, Value* removed);
Christopher Dunn76746b02015-01-21 16:01:30 -0600514 /** \brief Remove the named map member.
515
516 Update 'removed' iff removed.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600517 \param key may contain embedded nulls.
Christopher Dunn76746b02015-01-21 16:01:30 -0600518 \return true iff removed (no exceptions)
519 */
Christopher Dunnde5b7922016-03-06 11:19:46 -0600520 bool removeMember(JSONCPP_STRING const& key, Value* removed);
521 /// Same as removeMember(JSONCPP_STRING const& key, Value* removed)
Christopher Dunn89704032015-07-11 12:09:59 -0500522 bool removeMember(const char* begin, const char* end, Value* removed);
Christopher Dunn9de2c2d2015-01-20 16:15:40 -0600523 /** \brief Remove the indexed array element.
524
525 O(n) expensive operations.
526 Update 'removed' iff removed.
Christopher Dunne87e41c2015-01-20 16:24:11 -0600527 \return true iff removed (no exceptions)
Christopher Dunn9de2c2d2015-01-20 16:15:40 -0600528 */
529 bool removeIndex(ArrayIndex i, Value* removed);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000530
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000531 /// Return true if the object has a member named key.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600532 /// \note 'key' must be null-terminated.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000533 bool isMember(const char* key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000534 /// Return true if the object has a member named key.
Christopher Dunn25342ba2015-03-02 18:05:26 -0600535 /// \param key may contain embedded nulls.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600536 bool isMember(const JSONCPP_STRING& key) const;
537 /// Same as isMember(JSONCPP_STRING const& key)const
Christopher Dunn89704032015-07-11 12:09:59 -0500538 bool isMember(const char* begin, const char* end) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000539#ifdef JSON_USE_CPPTL
540 /// Return true if the object has a member named key.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000541 bool isMember(const CppTL::ConstString& key) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000542#endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000543
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000544 /// \brief Return a list of the member names.
545 ///
546 /// If null, return an empty list.
547 /// \pre type() is objectValue or nullValue
548 /// \post if type() was nullValue, it remains nullValue
549 Members getMemberNames() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000550
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000551 //# ifdef JSON_USE_CPPTL
552 // EnumMemberNames enumMemberNames() const;
553 // EnumValues enumValues() const;
554 //# endif
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000555
Christopher Dunn1e3149a2015-01-25 14:16:13 -0600556 /// \deprecated Always pass len.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600557 JSONCPP_DEPRECATED("Use setComment(JSONCPP_STRING const&) instead.")
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000558 void setComment(const char* comment, CommentPlacement placement);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000559 /// Comments must be //... or /* ... */
Christopher Dunn1e3149a2015-01-25 14:16:13 -0600560 void setComment(const char* comment, size_t len, CommentPlacement placement);
561 /// Comments must be //... or /* ... */
Christopher Dunnde5b7922016-03-06 11:19:46 -0600562 void setComment(const JSONCPP_STRING& comment, CommentPlacement placement);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000563 bool hasComment(CommentPlacement placement) const;
564 /// Include delimiters and embedded newlines.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600565 JSONCPP_STRING getComment(CommentPlacement placement) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000566
Christopher Dunnde5b7922016-03-06 11:19:46 -0600567 JSONCPP_STRING toStyledString() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000568
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000569 const_iterator begin() const;
570 const_iterator end() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000571
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000572 iterator begin();
573 iterator end();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000574
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000575 // Accessors for the [start, limit) range of bytes within the JSON text from
576 // which this value was parsed, if any.
Christopher Dunnd4513fc2016-02-06 09:25:20 -0600577 void setOffsetStart(ptrdiff_t start);
578 void setOffsetLimit(ptrdiff_t limit);
579 ptrdiff_t getOffsetStart() const;
580 ptrdiff_t getOffsetLimit() const;
Aaron Jacobs68db6552014-04-23 23:41:12 +0000581
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000582private:
Billy Donahue8eb5d892014-11-10 01:35:42 -0500583 void initBasic(ValueType type, bool allocated = false);
584
Christopher Dunnc28610f2015-02-21 11:44:16 -0600585 Value& resolveReference(const char* key);
586 Value& resolveReference(const char* key, const char* end);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000587
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000588 struct CommentInfo {
589 CommentInfo();
590 ~CommentInfo();
591
Christopher Dunn1e3149a2015-01-25 14:16:13 -0600592 void setComment(const char* text, size_t len);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000593
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000594 char* comment_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000595 };
596
597 // struct MemberNamesTransform
598 //{
599 // typedef const char *result_type;
600 // const char *operator()( const CZString &name ) const
601 // {
602 // return name.c_str();
603 // }
604 //};
605
606 union ValueHolder {
607 LargestInt int_;
608 LargestUInt uint_;
609 double real_;
610 bool bool_;
Christopher Dunnc28610f2015-02-21 11:44:16 -0600611 char* string_; // actually ptr to unsigned, followed by str, unless !allocated_
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000612 ObjectValues* map_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000613 } value_;
614 ValueType type_ : 8;
Christopher Dunn2bc61372015-01-24 13:42:37 -0600615 unsigned int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600616 // If not allocated_, string_ must be null-terminated.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000617 CommentInfo* comments_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000618
619 // [start, limit) byte offsets in the source JSON text from which this Value
620 // was extracted.
Christopher Dunnd4513fc2016-02-06 09:25:20 -0600621 ptrdiff_t start_;
622 ptrdiff_t limit_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000623};
624
625/** \brief Experimental and untested: represents an element of the "path" to
626 * access a node.
627 */
628class JSON_API PathArgument {
629public:
630 friend class Path;
631
632 PathArgument();
633 PathArgument(ArrayIndex index);
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000634 PathArgument(const char* key);
Christopher Dunnde5b7922016-03-06 11:19:46 -0600635 PathArgument(const JSONCPP_STRING& key);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000636
637private:
638 enum Kind {
639 kindNone = 0,
640 kindIndex,
641 kindKey
642 };
Christopher Dunnde5b7922016-03-06 11:19:46 -0600643 JSONCPP_STRING key_;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000644 ArrayIndex index_;
645 Kind kind_;
646};
647
648/** \brief Experimental and untested: represents a "path" to access a node.
649 *
650 * Syntax:
651 * - "." => root node
652 * - ".[n]" => elements at index 'n' of root node (an array value)
653 * - ".name" => member named 'name' of root node (an object value)
654 * - ".name1.name2.name3"
655 * - ".[0][1][2].name1[3]"
656 * - ".%" => member name is provided as parameter
657 * - ".[%]" => index is provied as parameter
658 */
659class JSON_API Path {
660public:
Christopher Dunnde5b7922016-03-06 11:19:46 -0600661 Path(const JSONCPP_STRING& path,
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000662 const PathArgument& a1 = PathArgument(),
663 const PathArgument& a2 = PathArgument(),
664 const PathArgument& a3 = PathArgument(),
665 const PathArgument& a4 = PathArgument(),
666 const PathArgument& a5 = PathArgument());
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000667
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000668 const Value& resolve(const Value& root) const;
669 Value resolve(const Value& root, const Value& defaultValue) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000670 /// Creates the "path" to access the specified node and returns a reference on
671 /// the node.
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000672 Value& make(Value& root) const;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000673
674private:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000675 typedef std::vector<const PathArgument*> InArgs;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000676 typedef std::vector<PathArgument> Args;
677
Christopher Dunnde5b7922016-03-06 11:19:46 -0600678 void makePath(const JSONCPP_STRING& path, const InArgs& in);
679 void addPathInArg(const JSONCPP_STRING& path,
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000680 const InArgs& in,
681 InArgs::const_iterator& itInArg,
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000682 PathArgument::Kind kind);
Christopher Dunnde5b7922016-03-06 11:19:46 -0600683 void invalidPath(const JSONCPP_STRING& path, int location);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000684
685 Args args_;
686};
687
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000688/** \brief base class for Value iterators.
689 *
690 */
691class JSON_API ValueIteratorBase {
692public:
693 typedef std::bidirectional_iterator_tag iterator_category;
694 typedef unsigned int size_t;
695 typedef int difference_type;
696 typedef ValueIteratorBase SelfType;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000697
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000698 bool operator==(const SelfType& other) const { return isEqual(other); }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000699
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000700 bool operator!=(const SelfType& other) const { return !isEqual(other); }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000701
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000702 difference_type operator-(const SelfType& other) const {
Kevin Grant4c5832a2015-02-14 20:53:35 -0800703 return other.computeDistance(*this);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000704 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000705
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000706 /// Return either the index or the member name of the referenced value as a
707 /// Value.
708 Value key() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000709
Christopher Dunned495ed2015-03-08 14:01:28 -0500710 /// Return the index of the referenced Value, or -1 if it is not an arrayValue.
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000711 UInt index() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000712
Christopher Dunned495ed2015-03-08 14:01:28 -0500713 /// Return the member name of the referenced Value, or "" if it is not an
714 /// objectValue.
715 /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
Christopher Dunnde5b7922016-03-06 11:19:46 -0600716 JSONCPP_STRING name() const;
Christopher Dunned495ed2015-03-08 14:01:28 -0500717
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000718 /// Return the member name of the referenced Value. "" if it is not an
719 /// objectValue.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600720 /// \deprecated This cannot be used for UTF-8 strings, since there can be embedded nulls.
Christopher Dunned495ed2015-03-08 14:01:28 -0500721 JSONCPP_DEPRECATED("Use `key = name();` instead.")
Christopher Dunnc28610f2015-02-21 11:44:16 -0600722 char const* memberName() const;
723 /// Return the member name of the referenced Value, or NULL if it is not an
724 /// objectValue.
Christopher Dunned495ed2015-03-08 14:01:28 -0500725 /// \note Better version than memberName(). Allows embedded nulls.
Christopher Dunnc28610f2015-02-21 11:44:16 -0600726 char const* memberName(char const** end) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000727
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000728protected:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000729 Value& deref() const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000730
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000731 void increment();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000732
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000733 void decrement();
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000734
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000735 difference_type computeDistance(const SelfType& other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000736
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000737 bool isEqual(const SelfType& other) const;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000738
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000739 void copy(const SelfType& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000740
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000741private:
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000742 Value::ObjectValues::iterator current_;
743 // Indicates that iterator is for a null value.
744 bool isNull_;
Christopher Dunn2a10f4a2015-04-28 04:55:12 +0100745
746public:
747 // For some reason, BORLAND needs these at the end, rather
748 // than earlier. No idea why.
749 ValueIteratorBase();
750 explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000751};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000752
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000753/** \brief const iterator for object and array value.
754 *
755 */
756class JSON_API ValueConstIterator : public ValueIteratorBase {
757 friend class Value;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000758
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000759public:
760 typedef const Value value_type;
Christopher Dunnc28610f2015-02-21 11:44:16 -0600761 //typedef unsigned int size_t;
762 //typedef int difference_type;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000763 typedef const Value& reference;
764 typedef const Value* pointer;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000765 typedef ValueConstIterator SelfType;
766
767 ValueConstIterator();
ycqiuc8a8cfc2015-10-06 16:46:19 +0800768 ValueConstIterator(ValueIterator const& other);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000769
770private:
771/*! \internal Use by Value to create an iterator.
772 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000773 explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000774public:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000775 SelfType& operator=(const ValueIteratorBase& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000776
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000777 SelfType operator++(int) {
778 SelfType temp(*this);
779 ++*this;
780 return temp;
781 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000782
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000783 SelfType operator--(int) {
784 SelfType temp(*this);
785 --*this;
786 return temp;
787 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000788
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000789 SelfType& operator--() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000790 decrement();
791 return *this;
792 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000793
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000794 SelfType& operator++() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000795 increment();
796 return *this;
797 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000798
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000799 reference operator*() const { return deref(); }
Braden McDorman540db3b2014-09-14 02:31:23 -0500800
801 pointer operator->() const { return &deref(); }
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000802};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000803
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000804/** \brief Iterator for object and array value.
805 */
806class JSON_API ValueIterator : public ValueIteratorBase {
807 friend class Value;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000808
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000809public:
810 typedef Value value_type;
811 typedef unsigned int size_t;
812 typedef int difference_type;
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000813 typedef Value& reference;
814 typedef Value* pointer;
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000815 typedef ValueIterator SelfType;
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000816
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000817 ValueIterator();
ycqiuc8a8cfc2015-10-06 16:46:19 +0800818 explicit ValueIterator(const ValueConstIterator& other);
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000819 ValueIterator(const ValueIterator& other);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000820
821private:
822/*! \internal Use by Value to create an iterator.
823 */
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000824 explicit ValueIterator(const Value::ObjectValues::iterator& current);
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000825public:
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000826 SelfType& operator=(const SelfType& other);
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000827
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000828 SelfType operator++(int) {
829 SelfType temp(*this);
830 ++*this;
831 return temp;
832 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000833
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000834 SelfType operator--(int) {
835 SelfType temp(*this);
836 --*this;
837 return temp;
838 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000839
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000840 SelfType& operator--() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000841 decrement();
842 return *this;
843 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000844
Aaron Jacobs11086dd2014-09-15 10:15:29 +1000845 SelfType& operator++() {
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000846 increment();
847 return *this;
848 }
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000849
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000850 reference operator*() const { return deref(); }
Braden McDorman540db3b2014-09-14 02:31:23 -0500851
852 pointer operator->() const { return &deref(); }
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000853};
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000854
855} // namespace Json
856
datadiode9454e682015-01-20 15:25:04 -0600857
858namespace std {
859/// Specialize std::swap() for Json::Value.
860template<>
861inline void swap(Json::Value& a, Json::Value& b) { a.swap(b); }
862}
863
Sergiy80d6e666f2016-12-03 22:29:14 +0200864#pragma pack(pop)
datadiode9454e682015-01-20 15:25:04 -0600865
Baptiste Lepilleureafd7022013-05-08 20:21:11 +0000866#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
Aaron Jacobs9fa4e842014-07-01 08:48:54 +1000867#pragma warning(pop)
Baptiste Lepilleureafd7022013-05-08 20:21:11 +0000868#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
869
Christopher Dunn6d135cb2007-06-13 15:51:04 +0000870#endif // CPPTL_JSON_H_INCLUDED