|
499
|
1 /// Json-cpp amalgamated header (http://jsoncpp.sourceforge.net/).
|
|
|
2 /// It is intended to be used with #include "json/json.h"
|
|
|
3
|
|
|
4 // //////////////////////////////////////////////////////////////////////
|
|
|
5 // Beginning of content of file: LICENSE
|
|
|
6 // //////////////////////////////////////////////////////////////////////
|
|
|
7
|
|
|
8 /*
|
|
|
9 The JsonCpp library's source code, including accompanying documentation,
|
|
|
10 tests and demonstration applications, are licensed under the following
|
|
|
11 conditions...
|
|
|
12
|
|
|
13 Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
|
|
|
14 jurisdictions which recognize such a disclaimer. In such jurisdictions,
|
|
|
15 this software is released into the Public Domain.
|
|
|
16
|
|
|
17 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
|
|
|
18 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
|
|
|
19 The JsonCpp Authors, and is released under the terms of the MIT License (see below).
|
|
|
20
|
|
|
21 In jurisdictions which recognize Public Domain property, the user of this
|
|
|
22 software may choose to accept it either as 1) Public Domain, 2) under the
|
|
|
23 conditions of the MIT License (see below), or 3) under the terms of dual
|
|
|
24 Public Domain/MIT License conditions described here, as they choose.
|
|
|
25
|
|
|
26 The MIT License is about as close to Public Domain as a license can get, and is
|
|
|
27 described in clear, concise terms at:
|
|
|
28
|
|
|
29 http://en.wikipedia.org/wiki/MIT_License
|
|
|
30
|
|
|
31 The full text of the MIT License follows:
|
|
|
32
|
|
|
33 ========================================================================
|
|
|
34 Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
35
|
|
|
36 Permission is hereby granted, free of charge, to any person
|
|
|
37 obtaining a copy of this software and associated documentation
|
|
|
38 files (the "Software"), to deal in the Software without
|
|
|
39 restriction, including without limitation the rights to use, copy,
|
|
|
40 modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
|
41 of the Software, and to permit persons to whom the Software is
|
|
|
42 furnished to do so, subject to the following conditions:
|
|
|
43
|
|
|
44 The above copyright notice and this permission notice shall be
|
|
|
45 included in all copies or substantial portions of the Software.
|
|
|
46
|
|
|
47 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
48 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
49 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
50 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
51 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
52 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
53 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
54 SOFTWARE.
|
|
|
55 ========================================================================
|
|
|
56 (END LICENSE TEXT)
|
|
|
57
|
|
|
58 The MIT license is compatible with both the GPL and commercial
|
|
|
59 software, affording one all of the rights of Public Domain with the
|
|
|
60 minor nuisance of being required to keep the above copyright notice
|
|
|
61 and license text in the source code. Note also that by accepting the
|
|
|
62 Public Domain "license" you can re-license your copy using whatever
|
|
|
63 license you like.
|
|
|
64
|
|
|
65 */
|
|
|
66
|
|
|
67 // //////////////////////////////////////////////////////////////////////
|
|
|
68 // End of content of file: LICENSE
|
|
|
69 // //////////////////////////////////////////////////////////////////////
|
|
|
70
|
|
|
71
|
|
|
72
|
|
|
73
|
|
|
74
|
|
|
75 #ifndef JSON_AMALGAMATED_H_INCLUDED
|
|
|
76 # define JSON_AMALGAMATED_H_INCLUDED
|
|
|
77 /// If defined, indicates that the source file is amalgamated
|
|
|
78 /// to prevent private header inclusion.
|
|
|
79 #define JSON_IS_AMALGAMATION
|
|
|
80
|
|
|
81 // //////////////////////////////////////////////////////////////////////
|
|
|
82 // Beginning of content of file: include/json/version.h
|
|
|
83 // //////////////////////////////////////////////////////////////////////
|
|
|
84
|
|
|
85 // DO NOT EDIT. This file (and "version") is generated by CMake.
|
|
|
86 // Run CMake configure step to update it.
|
|
|
87 #ifndef JSON_VERSION_H_INCLUDED
|
|
|
88 #define JSON_VERSION_H_INCLUDED
|
|
|
89
|
|
|
90 #define JSONCPP_VERSION_STRING "1.8.4"
|
|
|
91 #define JSONCPP_VERSION_MAJOR 1
|
|
|
92 #define JSONCPP_VERSION_MINOR 8
|
|
|
93 #define JSONCPP_VERSION_PATCH 4
|
|
|
94 #define JSONCPP_VERSION_QUALIFIER
|
|
|
95 #define JSONCPP_VERSION_HEXA \
|
|
|
96 ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | \
|
|
|
97 (JSONCPP_VERSION_PATCH << 8))
|
|
|
98
|
|
|
99 #ifdef JSONCPP_USING_SECURE_MEMORY
|
|
|
100 #undef JSONCPP_USING_SECURE_MEMORY
|
|
|
101 #endif
|
|
|
102 #define JSONCPP_USING_SECURE_MEMORY 0
|
|
|
103 // If non-zero, the library zeroes any memory that it has allocated before
|
|
|
104 // it frees its memory.
|
|
|
105
|
|
|
106 #endif // JSON_VERSION_H_INCLUDED
|
|
|
107
|
|
|
108 // //////////////////////////////////////////////////////////////////////
|
|
|
109 // End of content of file: include/json/version.h
|
|
|
110 // //////////////////////////////////////////////////////////////////////
|
|
|
111
|
|
|
112
|
|
|
113
|
|
|
114
|
|
|
115
|
|
|
116
|
|
|
117 // //////////////////////////////////////////////////////////////////////
|
|
|
118 // Beginning of content of file: include/json/allocator.h
|
|
|
119 // //////////////////////////////////////////////////////////////////////
|
|
|
120
|
|
|
121 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
122 // Distributed under MIT license, or public domain if desired and
|
|
|
123 // recognized in your jurisdiction.
|
|
|
124 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
125
|
|
|
126 #ifndef CPPTL_JSON_ALLOCATOR_H_INCLUDED
|
|
|
127 #define CPPTL_JSON_ALLOCATOR_H_INCLUDED
|
|
|
128
|
|
|
129 #include <cstring>
|
|
|
130 #include <memory>
|
|
|
131
|
|
|
132 #pragma pack(push, 8)
|
|
|
133
|
|
|
134 namespace Json {
|
|
|
135 template <typename T> class SecureAllocator {
|
|
|
136 public:
|
|
|
137 // Type definitions
|
|
|
138 using value_type = T;
|
|
|
139 using pointer = T*;
|
|
|
140 using const_pointer = const T*;
|
|
|
141 using reference = T&;
|
|
|
142 using const_reference = const T&;
|
|
|
143 using size_type = std::size_t;
|
|
|
144 using difference_type = std::ptrdiff_t;
|
|
|
145
|
|
|
146 /**
|
|
|
147 * Allocate memory for N items using the standard allocator.
|
|
|
148 */
|
|
|
149 pointer allocate(size_type n) {
|
|
|
150 // allocate using "global operator new"
|
|
|
151 return static_cast<pointer>(::operator new(n * sizeof(T)));
|
|
|
152 }
|
|
|
153
|
|
|
154 /**
|
|
|
155 * Release memory which was allocated for N items at pointer P.
|
|
|
156 *
|
|
|
157 * The memory block is filled with zeroes before being released.
|
|
|
158 * The pointer argument is tagged as "volatile" to prevent the
|
|
|
159 * compiler optimizing out this critical step.
|
|
|
160 */
|
|
|
161 void deallocate(volatile pointer p, size_type n) {
|
|
|
162 std::memset(p, 0, n * sizeof(T));
|
|
|
163 // free using "global operator delete"
|
|
|
164 ::operator delete(p);
|
|
|
165 }
|
|
|
166
|
|
|
167 /**
|
|
|
168 * Construct an item in-place at pointer P.
|
|
|
169 */
|
|
|
170 template <typename... Args> void construct(pointer p, Args&&... args) {
|
|
|
171 // construct using "placement new" and "perfect forwarding"
|
|
|
172 ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
|
|
|
173 }
|
|
|
174
|
|
|
175 size_type max_size() const { return size_t(-1) / sizeof(T); }
|
|
|
176
|
|
|
177 pointer address(reference x) const { return std::addressof(x); }
|
|
|
178
|
|
|
179 const_pointer address(const_reference x) const { return std::addressof(x); }
|
|
|
180
|
|
|
181 /**
|
|
|
182 * Destroy an item in-place at pointer P.
|
|
|
183 */
|
|
|
184 void destroy(pointer p) {
|
|
|
185 // destroy using "explicit destructor"
|
|
|
186 p->~T();
|
|
|
187 }
|
|
|
188
|
|
|
189 // Boilerplate
|
|
|
190 SecureAllocator() {}
|
|
|
191 template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
|
|
|
192 template <typename U> struct rebind { using other = SecureAllocator<U>; };
|
|
|
193 };
|
|
|
194
|
|
|
195 template <typename T, typename U>
|
|
|
196 bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
|
|
|
197 return true;
|
|
|
198 }
|
|
|
199
|
|
|
200 template <typename T, typename U>
|
|
|
201 bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
|
|
|
202 return false;
|
|
|
203 }
|
|
|
204
|
|
|
205 } // namespace Json
|
|
|
206
|
|
|
207 #pragma pack(pop)
|
|
|
208
|
|
|
209 #endif // CPPTL_JSON_ALLOCATOR_H_INCLUDED
|
|
|
210
|
|
|
211 // //////////////////////////////////////////////////////////////////////
|
|
|
212 // End of content of file: include/json/allocator.h
|
|
|
213 // //////////////////////////////////////////////////////////////////////
|
|
|
214
|
|
|
215
|
|
|
216
|
|
|
217
|
|
|
218
|
|
|
219
|
|
|
220 // //////////////////////////////////////////////////////////////////////
|
|
|
221 // Beginning of content of file: include/json/config.h
|
|
|
222 // //////////////////////////////////////////////////////////////////////
|
|
|
223
|
|
|
224 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
225 // Distributed under MIT license, or public domain if desired and
|
|
|
226 // recognized in your jurisdiction.
|
|
|
227 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
228
|
|
|
229 #ifndef JSON_CONFIG_H_INCLUDED
|
|
|
230 #define JSON_CONFIG_H_INCLUDED
|
|
|
231 #include <cstddef>
|
|
|
232 #include <cstdint>
|
|
|
233 #include <istream>
|
|
|
234 #include <memory>
|
|
|
235 #include <ostream>
|
|
|
236 #include <sstream>
|
|
|
237 #include <string>
|
|
|
238 #include <type_traits>
|
|
|
239
|
|
|
240 /// If defined, indicates that json library is embedded in CppTL library.
|
|
|
241 //# define JSON_IN_CPPTL 1
|
|
|
242
|
|
|
243 /// If defined, indicates that json may leverage CppTL library
|
|
|
244 //# define JSON_USE_CPPTL 1
|
|
|
245 /// If defined, indicates that cpptl vector based map should be used instead of
|
|
|
246 /// std::map
|
|
|
247 /// as Value container.
|
|
|
248 //# define JSON_USE_CPPTL_SMALLMAP 1
|
|
|
249
|
|
|
250 // If non-zero, the library uses exceptions to report bad input instead of C
|
|
|
251 // assertion macros. The default is to use exceptions.
|
|
|
252 #ifndef JSON_USE_EXCEPTION
|
|
|
253 #define JSON_USE_EXCEPTION 1
|
|
|
254 #endif
|
|
|
255
|
|
|
256 /// If defined, indicates that the source file is amalgamated
|
|
|
257 /// to prevent private header inclusion.
|
|
|
258 /// Remarks: it is automatically defined in the generated amalgamated header.
|
|
|
259 // #define JSON_IS_AMALGAMATION
|
|
|
260
|
|
|
261 #ifdef JSON_IN_CPPTL
|
|
|
262 #include <cpptl/config.h>
|
|
|
263 #ifndef JSON_USE_CPPTL
|
|
|
264 #define JSON_USE_CPPTL 1
|
|
|
265 #endif
|
|
|
266 #endif
|
|
|
267
|
|
|
268 #ifdef JSON_IN_CPPTL
|
|
|
269 #define JSON_API CPPTL_API
|
|
|
270 #elif defined(JSON_DLL_BUILD)
|
|
|
271 #if defined(_MSC_VER) || defined(__MINGW32__)
|
|
|
272 #define JSON_API __declspec(dllexport)
|
|
|
273 #define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
|
|
|
274 #endif // if defined(_MSC_VER)
|
|
|
275 #elif defined(JSON_DLL)
|
|
|
276 #if defined(_MSC_VER) || defined(__MINGW32__)
|
|
|
277 #define JSON_API __declspec(dllimport)
|
|
|
278 #define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
|
|
|
279 #endif // if defined(_MSC_VER)
|
|
|
280 #endif // ifdef JSON_IN_CPPTL
|
|
|
281 #if !defined(JSON_API)
|
|
|
282 #define JSON_API
|
|
|
283 #endif
|
|
|
284
|
|
|
285 #if defined(_MSC_VER) && _MSC_VER < 1800
|
|
|
286 #error \
|
|
|
287 "ERROR: Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
|
|
|
288 #endif
|
|
|
289
|
|
|
290 #if defined(_MSC_VER) && _MSC_VER < 1900
|
|
|
291 // As recommended at
|
|
|
292 // https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
|
|
|
293 extern JSON_API int
|
|
|
294 msvc_pre1900_c99_snprintf(char* outBuf, size_t size, const char* format, ...);
|
|
|
295 #define jsoncpp_snprintf msvc_pre1900_c99_snprintf
|
|
|
296 #else
|
|
|
297 #define jsoncpp_snprintf std::snprintf
|
|
|
298 #endif
|
|
|
299
|
|
|
300 // If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
|
|
|
301 // integer
|
|
|
302 // Storages, and 64 bits integer support is disabled.
|
|
|
303 // #define JSON_NO_INT64 1
|
|
|
304
|
|
|
305 #if defined(_MSC_VER) // MSVC
|
|
|
306 #define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
|
|
|
307 #endif // defined(_MSC_VER)
|
|
|
308
|
|
|
309 // JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
|
|
|
310 // C++11 should be used directly in JSONCPP.
|
|
|
311 #define JSONCPP_OVERRIDE override
|
|
|
312
|
|
|
313 #if __cplusplus >= 201103L
|
|
|
314 #define JSONCPP_NOEXCEPT noexcept
|
|
|
315 #define JSONCPP_OP_EXPLICIT explicit
|
|
|
316 #elif defined(_MSC_VER) && _MSC_VER < 1900
|
|
|
317 #define JSONCPP_NOEXCEPT throw()
|
|
|
318 #define JSONCPP_OP_EXPLICIT explicit
|
|
|
319 #elif defined(_MSC_VER) && _MSC_VER >= 1900
|
|
|
320 #define JSONCPP_NOEXCEPT noexcept
|
|
|
321 #define JSONCPP_OP_EXPLICIT explicit
|
|
|
322 #else
|
|
|
323 #define JSONCPP_NOEXCEPT throw()
|
|
|
324 #define JSONCPP_OP_EXPLICIT
|
|
|
325 #endif
|
|
|
326
|
|
|
327 #ifndef JSON_HAS_RVALUE_REFERENCES
|
|
|
328
|
|
|
329 #if defined(_MSC_VER)
|
|
|
330 #define JSON_HAS_RVALUE_REFERENCES 1
|
|
|
331 #endif // MSVC >= 2013
|
|
|
332
|
|
|
333 #ifdef __clang__
|
|
|
334 #if __has_feature(cxx_rvalue_references)
|
|
|
335 #define JSON_HAS_RVALUE_REFERENCES 1
|
|
|
336 #endif // has_feature
|
|
|
337
|
|
|
338 #elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
|
|
|
339 #if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
|
|
|
340 #define JSON_HAS_RVALUE_REFERENCES 1
|
|
|
341 #endif // GXX_EXPERIMENTAL
|
|
|
342
|
|
|
343 #endif // __clang__ || __GNUC__
|
|
|
344
|
|
|
345 #endif // not defined JSON_HAS_RVALUE_REFERENCES
|
|
|
346
|
|
|
347 #ifndef JSON_HAS_RVALUE_REFERENCES
|
|
|
348 #define JSON_HAS_RVALUE_REFERENCES 0
|
|
|
349 #endif
|
|
|
350
|
|
|
351 #ifdef __clang__
|
|
|
352 #if __has_extension(attribute_deprecated_with_message)
|
|
|
353 #define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
|
|
|
354 #endif
|
|
|
355 #elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
|
|
|
356 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
|
|
|
357 #define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
|
|
|
358 #elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
|
|
|
359 #define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
|
|
|
360 #endif // GNUC version
|
|
|
361 #endif // __clang__ || __GNUC__
|
|
|
362
|
|
|
363 #if !defined(JSONCPP_DEPRECATED)
|
|
|
364 #define JSONCPP_DEPRECATED(message)
|
|
|
365 #endif // if !defined(JSONCPP_DEPRECATED)
|
|
|
366
|
|
|
367 #if __GNUC__ >= 6
|
|
|
368 #define JSON_USE_INT64_DOUBLE_CONVERSION 1
|
|
|
369 #endif
|
|
|
370
|
|
|
371 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
372
|
|
|
373 #include "allocator.h"
|
|
|
374 #include "version.h"
|
|
|
375
|
|
|
376 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
377
|
|
|
378 namespace Json {
|
|
|
379 typedef int Int;
|
|
|
380 typedef unsigned int UInt;
|
|
|
381 #if defined(JSON_NO_INT64)
|
|
|
382 typedef int LargestInt;
|
|
|
383 typedef unsigned int LargestUInt;
|
|
|
384 #undef JSON_HAS_INT64
|
|
|
385 #else // if defined(JSON_NO_INT64)
|
|
|
386 // For Microsoft Visual use specific types as long long is not supported
|
|
|
387 #if defined(_MSC_VER) // Microsoft Visual Studio
|
|
|
388 typedef __int64 Int64;
|
|
|
389 typedef unsigned __int64 UInt64;
|
|
|
390 #else // if defined(_MSC_VER) // Other platforms, use long long
|
|
|
391 typedef int64_t Int64;
|
|
|
392 typedef uint64_t UInt64;
|
|
|
393 #endif // if defined(_MSC_VER)
|
|
|
394 typedef Int64 LargestInt;
|
|
|
395 typedef UInt64 LargestUInt;
|
|
|
396 #define JSON_HAS_INT64
|
|
|
397 #endif // if defined(JSON_NO_INT64)
|
|
|
398
|
|
|
399 template <typename T>
|
|
|
400 using Allocator = typename std::conditional<JSONCPP_USING_SECURE_MEMORY,
|
|
|
401 SecureAllocator<T>,
|
|
|
402 std::allocator<T>>::type;
|
|
|
403 using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
|
|
|
404 using IStringStream = std::basic_istringstream<String::value_type,
|
|
|
405 String::traits_type,
|
|
|
406 String::allocator_type>;
|
|
|
407 using OStringStream = std::basic_ostringstream<String::value_type,
|
|
|
408 String::traits_type,
|
|
|
409 String::allocator_type>;
|
|
|
410 using IStream = std::istream;
|
|
|
411 using OStream = std::ostream;
|
|
|
412 } // namespace Json
|
|
|
413
|
|
|
414 // Legacy names (formerly macros).
|
|
|
415 using JSONCPP_STRING = Json::String;
|
|
|
416 using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
|
|
|
417 using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
|
|
|
418 using JSONCPP_ISTREAM = Json::IStream;
|
|
|
419 using JSONCPP_OSTREAM = Json::OStream;
|
|
|
420
|
|
|
421 #endif // JSON_CONFIG_H_INCLUDED
|
|
|
422
|
|
|
423 // //////////////////////////////////////////////////////////////////////
|
|
|
424 // End of content of file: include/json/config.h
|
|
|
425 // //////////////////////////////////////////////////////////////////////
|
|
|
426
|
|
|
427
|
|
|
428
|
|
|
429
|
|
|
430
|
|
|
431
|
|
|
432 // //////////////////////////////////////////////////////////////////////
|
|
|
433 // Beginning of content of file: include/json/forwards.h
|
|
|
434 // //////////////////////////////////////////////////////////////////////
|
|
|
435
|
|
|
436 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
437 // Distributed under MIT license, or public domain if desired and
|
|
|
438 // recognized in your jurisdiction.
|
|
|
439 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
440
|
|
|
441 #ifndef JSON_FORWARDS_H_INCLUDED
|
|
|
442 #define JSON_FORWARDS_H_INCLUDED
|
|
|
443
|
|
|
444 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
445 #include "config.h"
|
|
|
446 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
447
|
|
|
448 namespace Json {
|
|
|
449
|
|
|
450 // writer.h
|
|
|
451 class FastWriter;
|
|
|
452 class StyledWriter;
|
|
|
453
|
|
|
454 // reader.h
|
|
|
455 class Reader;
|
|
|
456
|
|
|
457 // features.h
|
|
|
458 class Features;
|
|
|
459
|
|
|
460 // value.h
|
|
|
461 typedef unsigned int ArrayIndex;
|
|
|
462 class StaticString;
|
|
|
463 class Path;
|
|
|
464 class PathArgument;
|
|
|
465 class Value;
|
|
|
466 class ValueIteratorBase;
|
|
|
467 class ValueIterator;
|
|
|
468 class ValueConstIterator;
|
|
|
469
|
|
|
470 } // namespace Json
|
|
|
471
|
|
|
472 #endif // JSON_FORWARDS_H_INCLUDED
|
|
|
473
|
|
|
474 // //////////////////////////////////////////////////////////////////////
|
|
|
475 // End of content of file: include/json/forwards.h
|
|
|
476 // //////////////////////////////////////////////////////////////////////
|
|
|
477
|
|
|
478
|
|
|
479
|
|
|
480
|
|
|
481
|
|
|
482
|
|
|
483 // //////////////////////////////////////////////////////////////////////
|
|
|
484 // Beginning of content of file: include/json/features.h
|
|
|
485 // //////////////////////////////////////////////////////////////////////
|
|
|
486
|
|
|
487 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
488 // Distributed under MIT license, or public domain if desired and
|
|
|
489 // recognized in your jurisdiction.
|
|
|
490 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
491
|
|
|
492 #ifndef CPPTL_JSON_FEATURES_H_INCLUDED
|
|
|
493 #define CPPTL_JSON_FEATURES_H_INCLUDED
|
|
|
494
|
|
|
495 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
496 #include "forwards.h"
|
|
|
497 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
498
|
|
|
499 #pragma pack(push, 8)
|
|
|
500
|
|
|
501 namespace Json {
|
|
|
502
|
|
|
503 /** \brief Configuration passed to reader and writer.
|
|
|
504 * This configuration object can be used to force the Reader or Writer
|
|
|
505 * to behave in a standard conforming way.
|
|
|
506 */
|
|
|
507 class JSON_API Features {
|
|
|
508 public:
|
|
|
509 /** \brief A configuration that allows all features and assumes all strings
|
|
|
510 * are UTF-8.
|
|
|
511 * - C & C++ comments are allowed
|
|
|
512 * - Root object can be any JSON value
|
|
|
513 * - Assumes Value strings are encoded in UTF-8
|
|
|
514 */
|
|
|
515 static Features all();
|
|
|
516
|
|
|
517 /** \brief A configuration that is strictly compatible with the JSON
|
|
|
518 * specification.
|
|
|
519 * - Comments are forbidden.
|
|
|
520 * - Root object must be either an array or an object value.
|
|
|
521 * - Assumes Value strings are encoded in UTF-8
|
|
|
522 */
|
|
|
523 static Features strictMode();
|
|
|
524
|
|
|
525 /** \brief Initialize the configuration like JsonConfig::allFeatures;
|
|
|
526 */
|
|
|
527 Features();
|
|
|
528
|
|
|
529 /// \c true if comments are allowed. Default: \c true.
|
|
|
530 bool allowComments_{true};
|
|
|
531
|
|
|
532 /// \c true if root must be either an array or an object value. Default: \c
|
|
|
533 /// false.
|
|
|
534 bool strictRoot_{false};
|
|
|
535
|
|
|
536 /// \c true if dropped null placeholders are allowed. Default: \c false.
|
|
|
537 bool allowDroppedNullPlaceholders_{false};
|
|
|
538
|
|
|
539 /// \c true if numeric object key are allowed. Default: \c false.
|
|
|
540 bool allowNumericKeys_{false};
|
|
|
541 };
|
|
|
542
|
|
|
543 } // namespace Json
|
|
|
544
|
|
|
545 #pragma pack(pop)
|
|
|
546
|
|
|
547 #endif // CPPTL_JSON_FEATURES_H_INCLUDED
|
|
|
548
|
|
|
549 // //////////////////////////////////////////////////////////////////////
|
|
|
550 // End of content of file: include/json/features.h
|
|
|
551 // //////////////////////////////////////////////////////////////////////
|
|
|
552
|
|
|
553
|
|
|
554
|
|
|
555
|
|
|
556
|
|
|
557
|
|
|
558 // //////////////////////////////////////////////////////////////////////
|
|
|
559 // Beginning of content of file: include/json/value.h
|
|
|
560 // //////////////////////////////////////////////////////////////////////
|
|
|
561
|
|
|
562 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
563 // Distributed under MIT license, or public domain if desired and
|
|
|
564 // recognized in your jurisdiction.
|
|
|
565 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
566
|
|
|
567 #ifndef CPPTL_JSON_H_INCLUDED
|
|
|
568 #define CPPTL_JSON_H_INCLUDED
|
|
|
569
|
|
|
570 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
571 #include "forwards.h"
|
|
|
572 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
573 #include <exception>
|
|
|
574 #include <string>
|
|
|
575 #include <vector>
|
|
|
576
|
|
|
577 #ifndef JSON_USE_CPPTL_SMALLMAP
|
|
|
578 #include <map>
|
|
|
579 #else
|
|
|
580 #include <cpptl/smallmap.h>
|
|
|
581 #endif
|
|
|
582 #ifdef JSON_USE_CPPTL
|
|
|
583 #include <cpptl/forwards.h>
|
|
|
584 #endif
|
|
|
585
|
|
|
586 // Conditional NORETURN attribute on the throw functions would:
|
|
|
587 // a) suppress false positives from static code analysis
|
|
|
588 // b) possibly improve optimization opportunities.
|
|
|
589 #if !defined(JSONCPP_NORETURN)
|
|
|
590 #if defined(_MSC_VER)
|
|
|
591 #define JSONCPP_NORETURN __declspec(noreturn)
|
|
|
592 #elif defined(__GNUC__)
|
|
|
593 #define JSONCPP_NORETURN __attribute__((__noreturn__))
|
|
|
594 #else
|
|
|
595 #define JSONCPP_NORETURN
|
|
|
596 #endif
|
|
|
597 #endif
|
|
|
598
|
|
|
599 // Disable warning C4251: <data member>: <type> needs to have dll-interface to
|
|
|
600 // be used by...
|
|
|
601 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
602 #pragma warning(push)
|
|
|
603 #pragma warning(disable : 4251)
|
|
|
604 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
605
|
|
|
606 #pragma pack(push, 8)
|
|
|
607
|
|
|
608 /** \brief JSON (JavaScript Object Notation).
|
|
|
609 */
|
|
|
610 namespace Json {
|
|
|
611
|
|
|
612 /** Base class for all exceptions we throw.
|
|
|
613 *
|
|
|
614 * We use nothing but these internally. Of course, STL can throw others.
|
|
|
615 */
|
|
|
616 class JSON_API Exception : public std::exception {
|
|
|
617 public:
|
|
|
618 Exception(String msg);
|
|
|
619 ~Exception() JSONCPP_NOEXCEPT override;
|
|
|
620 char const* what() const JSONCPP_NOEXCEPT override;
|
|
|
621
|
|
|
622 protected:
|
|
|
623 String msg_;
|
|
|
624 };
|
|
|
625
|
|
|
626 /** Exceptions which the user cannot easily avoid.
|
|
|
627 *
|
|
|
628 * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
|
|
|
629 *
|
|
|
630 * \remark derived from Json::Exception
|
|
|
631 */
|
|
|
632 class JSON_API RuntimeError : public Exception {
|
|
|
633 public:
|
|
|
634 RuntimeError(String const& msg);
|
|
|
635 };
|
|
|
636
|
|
|
637 /** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
|
|
|
638 *
|
|
|
639 * These are precondition-violations (user bugs) and internal errors (our bugs).
|
|
|
640 *
|
|
|
641 * \remark derived from Json::Exception
|
|
|
642 */
|
|
|
643 class JSON_API LogicError : public Exception {
|
|
|
644 public:
|
|
|
645 LogicError(String const& msg);
|
|
|
646 };
|
|
|
647
|
|
|
648 /// used internally
|
|
|
649 JSONCPP_NORETURN void throwRuntimeError(String const& msg);
|
|
|
650 /// used internally
|
|
|
651 JSONCPP_NORETURN void throwLogicError(String const& msg);
|
|
|
652
|
|
|
653 /** \brief Type of the value held by a Value object.
|
|
|
654 */
|
|
|
655 enum ValueType {
|
|
|
656 nullValue = 0, ///< 'null' value
|
|
|
657 intValue, ///< signed integer value
|
|
|
658 uintValue, ///< unsigned integer value
|
|
|
659 realValue, ///< double value
|
|
|
660 stringValue, ///< UTF-8 string value
|
|
|
661 booleanValue, ///< bool value
|
|
|
662 arrayValue, ///< array value (ordered list)
|
|
|
663 objectValue ///< object value (collection of name/value pairs).
|
|
|
664 };
|
|
|
665
|
|
|
666 enum CommentPlacement {
|
|
|
667 commentBefore = 0, ///< a comment placed on the line before a value
|
|
|
668 commentAfterOnSameLine, ///< a comment just after a value on the same line
|
|
|
669 commentAfter, ///< a comment on the line after a value (only make sense for
|
|
|
670 /// root value)
|
|
|
671 numberOfCommentPlacement
|
|
|
672 };
|
|
|
673
|
|
|
674 /** \brief Type of precision for formatting of real values.
|
|
|
675 */
|
|
|
676 enum PrecisionType {
|
|
|
677 significantDigits = 0, ///< we set max number of significant digits in string
|
|
|
678 decimalPlaces ///< we set max number of digits after "." in string
|
|
|
679 };
|
|
|
680
|
|
|
681 //# ifdef JSON_USE_CPPTL
|
|
|
682 // typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
|
|
|
683 // typedef CppTL::AnyEnumerator<const Value &> EnumValues;
|
|
|
684 //# endif
|
|
|
685
|
|
|
686 /** \brief Lightweight wrapper to tag static string.
|
|
|
687 *
|
|
|
688 * Value constructor and objectValue member assignment takes advantage of the
|
|
|
689 * StaticString and avoid the cost of string duplication when storing the
|
|
|
690 * string or the member name.
|
|
|
691 *
|
|
|
692 * Example of usage:
|
|
|
693 * \code
|
|
|
694 * Json::Value aValue( StaticString("some text") );
|
|
|
695 * Json::Value object;
|
|
|
696 * static const StaticString code("code");
|
|
|
697 * object[code] = 1234;
|
|
|
698 * \endcode
|
|
|
699 */
|
|
|
700 class JSON_API StaticString {
|
|
|
701 public:
|
|
|
702 explicit StaticString(const char* czstring) : c_str_(czstring) {}
|
|
|
703
|
|
|
704 operator const char*() const { return c_str_; }
|
|
|
705
|
|
|
706 const char* c_str() const { return c_str_; }
|
|
|
707
|
|
|
708 private:
|
|
|
709 const char* c_str_;
|
|
|
710 };
|
|
|
711
|
|
|
712 /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
|
|
|
713 *
|
|
|
714 * This class is a discriminated union wrapper that can represents a:
|
|
|
715 * - signed integer [range: Value::minInt - Value::maxInt]
|
|
|
716 * - unsigned integer (range: 0 - Value::maxUInt)
|
|
|
717 * - double
|
|
|
718 * - UTF-8 string
|
|
|
719 * - boolean
|
|
|
720 * - 'null'
|
|
|
721 * - an ordered list of Value
|
|
|
722 * - collection of name/value pairs (javascript object)
|
|
|
723 *
|
|
|
724 * The type of the held value is represented by a #ValueType and
|
|
|
725 * can be obtained using type().
|
|
|
726 *
|
|
|
727 * Values of an #objectValue or #arrayValue can be accessed using operator[]()
|
|
|
728 * methods.
|
|
|
729 * Non-const methods will automatically create the a #nullValue element
|
|
|
730 * if it does not exist.
|
|
|
731 * The sequence of an #arrayValue will be automatically resized and initialized
|
|
|
732 * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
|
|
|
733 *
|
|
|
734 * The get() methods can be used to obtain default value in the case the
|
|
|
735 * required element does not exist.
|
|
|
736 *
|
|
|
737 * It is possible to iterate over the list of member keys of an object using
|
|
|
738 * the getMemberNames() method.
|
|
|
739 *
|
|
|
740 * \note #Value string-length fit in size_t, but keys must be < 2^30.
|
|
|
741 * (The reason is an implementation detail.) A #CharReader will raise an
|
|
|
742 * exception if a bound is exceeded to avoid security holes in your app,
|
|
|
743 * but the Value API does *not* check bounds. That is the responsibility
|
|
|
744 * of the caller.
|
|
|
745 */
|
|
|
746 class JSON_API Value {
|
|
|
747 friend class ValueIteratorBase;
|
|
|
748
|
|
|
749 public:
|
|
|
750 typedef std::vector<String> Members;
|
|
|
751 typedef ValueIterator iterator;
|
|
|
752 typedef ValueConstIterator const_iterator;
|
|
|
753 typedef Json::UInt UInt;
|
|
|
754 typedef Json::Int Int;
|
|
|
755 #if defined(JSON_HAS_INT64)
|
|
|
756 typedef Json::UInt64 UInt64;
|
|
|
757 typedef Json::Int64 Int64;
|
|
|
758 #endif // defined(JSON_HAS_INT64)
|
|
|
759 typedef Json::LargestInt LargestInt;
|
|
|
760 typedef Json::LargestUInt LargestUInt;
|
|
|
761 typedef Json::ArrayIndex ArrayIndex;
|
|
|
762
|
|
|
763 // Required for boost integration, e. g. BOOST_TEST
|
|
|
764 typedef std::string value_type;
|
|
|
765
|
|
|
766 static const Value& null; ///< We regret this reference to a global instance;
|
|
|
767 ///< prefer the simpler Value().
|
|
|
768 static const Value& nullRef; ///< just a kludge for binary-compatibility; same
|
|
|
769 ///< as null
|
|
|
770 static Value const& nullSingleton(); ///< Prefer this to null or nullRef.
|
|
|
771
|
|
|
772 /// Minimum signed integer value that can be stored in a Json::Value.
|
|
|
773 static const LargestInt minLargestInt;
|
|
|
774 /// Maximum signed integer value that can be stored in a Json::Value.
|
|
|
775 static const LargestInt maxLargestInt;
|
|
|
776 /// Maximum unsigned integer value that can be stored in a Json::Value.
|
|
|
777 static const LargestUInt maxLargestUInt;
|
|
|
778
|
|
|
779 /// Minimum signed int value that can be stored in a Json::Value.
|
|
|
780 static const Int minInt;
|
|
|
781 /// Maximum signed int value that can be stored in a Json::Value.
|
|
|
782 static const Int maxInt;
|
|
|
783 /// Maximum unsigned int value that can be stored in a Json::Value.
|
|
|
784 static const UInt maxUInt;
|
|
|
785
|
|
|
786 #if defined(JSON_HAS_INT64)
|
|
|
787 /// Minimum signed 64 bits int value that can be stored in a Json::Value.
|
|
|
788 static const Int64 minInt64;
|
|
|
789 /// Maximum signed 64 bits int value that can be stored in a Json::Value.
|
|
|
790 static const Int64 maxInt64;
|
|
|
791 /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
|
|
|
792 static const UInt64 maxUInt64;
|
|
|
793 #endif // defined(JSON_HAS_INT64)
|
|
|
794
|
|
|
795 /// Default precision for real value for string representation.
|
|
|
796 static const UInt defaultRealPrecision;
|
|
|
797
|
|
|
798 // Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
|
|
|
799 // when using gcc and clang backend compilers. CZString
|
|
|
800 // cannot be defined as private. See issue #486
|
|
|
801 #ifdef __NVCC__
|
|
|
802 public:
|
|
|
803 #else
|
|
|
804 private:
|
|
|
805 #endif
|
|
|
806 #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
|
|
|
807 class CZString {
|
|
|
808 public:
|
|
|
809 enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
|
|
|
810 CZString(ArrayIndex index);
|
|
|
811 CZString(char const* str, unsigned length, DuplicationPolicy allocate);
|
|
|
812 CZString(CZString const& other);
|
|
|
813 #if JSON_HAS_RVALUE_REFERENCES
|
|
|
814 CZString(CZString&& other);
|
|
|
815 #endif
|
|
|
816 ~CZString();
|
|
|
817 CZString& operator=(const CZString& other);
|
|
|
818
|
|
|
819 #if JSON_HAS_RVALUE_REFERENCES
|
|
|
820 CZString& operator=(CZString&& other);
|
|
|
821 #endif
|
|
|
822
|
|
|
823 bool operator<(CZString const& other) const;
|
|
|
824 bool operator==(CZString const& other) const;
|
|
|
825 ArrayIndex index() const;
|
|
|
826 // const char* c_str() const; ///< \deprecated
|
|
|
827 char const* data() const;
|
|
|
828 unsigned length() const;
|
|
|
829 bool isStaticString() const;
|
|
|
830
|
|
|
831 private:
|
|
|
832 void swap(CZString& other);
|
|
|
833
|
|
|
834 struct StringStorage {
|
|
|
835 unsigned policy_ : 2;
|
|
|
836 unsigned length_ : 30; // 1GB max
|
|
|
837 };
|
|
|
838
|
|
|
839 char const* cstr_; // actually, a prefixed string, unless policy is noDup
|
|
|
840 union {
|
|
|
841 ArrayIndex index_;
|
|
|
842 StringStorage storage_;
|
|
|
843 };
|
|
|
844 };
|
|
|
845
|
|
|
846 public:
|
|
|
847 #ifndef JSON_USE_CPPTL_SMALLMAP
|
|
|
848 typedef std::map<CZString, Value> ObjectValues;
|
|
|
849 #else
|
|
|
850 typedef CppTL::SmallMap<CZString, Value> ObjectValues;
|
|
|
851 #endif // ifndef JSON_USE_CPPTL_SMALLMAP
|
|
|
852 #endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
|
|
|
853
|
|
|
854 public:
|
|
|
855 /** \brief Create a default Value of the given type.
|
|
|
856
|
|
|
857 This is a very useful constructor.
|
|
|
858 To create an empty array, pass arrayValue.
|
|
|
859 To create an empty object, pass objectValue.
|
|
|
860 Another Value can then be set to this one by assignment.
|
|
|
861 This is useful since clear() and resize() will not alter types.
|
|
|
862
|
|
|
863 Examples:
|
|
|
864 \code
|
|
|
865 Json::Value null_value; // null
|
|
|
866 Json::Value arr_value(Json::arrayValue); // []
|
|
|
867 Json::Value obj_value(Json::objectValue); // {}
|
|
|
868 \endcode
|
|
|
869 */
|
|
|
870 Value(ValueType type = nullValue);
|
|
|
871 Value(Int value);
|
|
|
872 Value(UInt value);
|
|
|
873 #if defined(JSON_HAS_INT64)
|
|
|
874 Value(Int64 value);
|
|
|
875 Value(UInt64 value);
|
|
|
876 #endif // if defined(JSON_HAS_INT64)
|
|
|
877 Value(double value);
|
|
|
878 Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
|
|
|
879 Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
|
|
|
880 /** \brief Constructs a value from a static string.
|
|
|
881
|
|
|
882 * Like other value string constructor but do not duplicate the string for
|
|
|
883 * internal storage. The given string must remain alive after the call to this
|
|
|
884 * constructor.
|
|
|
885 * \note This works only for null-terminated strings. (We cannot change the
|
|
|
886 * size of this class, so we have nowhere to store the length,
|
|
|
887 * which might be computed later for various operations.)
|
|
|
888 *
|
|
|
889 * Example of usage:
|
|
|
890 * \code
|
|
|
891 * static StaticString foo("some text");
|
|
|
892 * Json::Value aValue(foo);
|
|
|
893 * \endcode
|
|
|
894 */
|
|
|
895 Value(const StaticString& value);
|
|
|
896 Value(const String& value); ///< Copy data() til size(). Embedded
|
|
|
897 ///< zeroes too.
|
|
|
898 #ifdef JSON_USE_CPPTL
|
|
|
899 Value(const CppTL::ConstString& value);
|
|
|
900 #endif
|
|
|
901 Value(bool value);
|
|
|
902 Value(const Value& other);
|
|
|
903 Value(Value&& other);
|
|
|
904 ~Value();
|
|
|
905
|
|
|
906 /// \note Overwrite existing comments. To preserve comments, use
|
|
|
907 /// #swapPayload().
|
|
|
908 Value& operator=(const Value& other);
|
|
|
909 Value& operator=(Value&& other);
|
|
|
910
|
|
|
911 /// Swap everything.
|
|
|
912 void swap(Value& other);
|
|
|
913 /// Swap values but leave comments and source offsets in place.
|
|
|
914 void swapPayload(Value& other);
|
|
|
915
|
|
|
916 /// copy everything.
|
|
|
917 void copy(const Value& other);
|
|
|
918 /// copy values but leave comments and source offsets in place.
|
|
|
919 void copyPayload(const Value& other);
|
|
|
920
|
|
|
921 ValueType type() const;
|
|
|
922
|
|
|
923 /// Compare payload only, not comments etc.
|
|
|
924 bool operator<(const Value& other) const;
|
|
|
925 bool operator<=(const Value& other) const;
|
|
|
926 bool operator>=(const Value& other) const;
|
|
|
927 bool operator>(const Value& other) const;
|
|
|
928 bool operator==(const Value& other) const;
|
|
|
929 bool operator!=(const Value& other) const;
|
|
|
930 int compare(const Value& other) const;
|
|
|
931
|
|
|
932 const char* asCString() const; ///< Embedded zeroes could cause you trouble!
|
|
|
933 #if JSONCPP_USING_SECURE_MEMORY
|
|
|
934 unsigned getCStringLength() const; // Allows you to understand the length of
|
|
|
935 // the CString
|
|
|
936 #endif
|
|
|
937 String asString() const; ///< Embedded zeroes are possible.
|
|
|
938 /** Get raw char* of string-value.
|
|
|
939 * \return false if !string. (Seg-fault if str or end are NULL.)
|
|
|
940 */
|
|
|
941 bool getString(char const** begin, char const** end) const;
|
|
|
942 #ifdef JSON_USE_CPPTL
|
|
|
943 CppTL::ConstString asConstString() const;
|
|
|
944 #endif
|
|
|
945 Int asInt() const;
|
|
|
946 UInt asUInt() const;
|
|
|
947 #if defined(JSON_HAS_INT64)
|
|
|
948 Int64 asInt64() const;
|
|
|
949 UInt64 asUInt64() const;
|
|
|
950 #endif // if defined(JSON_HAS_INT64)
|
|
|
951 LargestInt asLargestInt() const;
|
|
|
952 LargestUInt asLargestUInt() const;
|
|
|
953 float asFloat() const;
|
|
|
954 double asDouble() const;
|
|
|
955 bool asBool() const;
|
|
|
956
|
|
|
957 bool isNull() const;
|
|
|
958 bool isBool() const;
|
|
|
959 bool isInt() const;
|
|
|
960 bool isInt64() const;
|
|
|
961 bool isUInt() const;
|
|
|
962 bool isUInt64() const;
|
|
|
963 bool isIntegral() const;
|
|
|
964 bool isDouble() const;
|
|
|
965 bool isNumeric() const;
|
|
|
966 bool isString() const;
|
|
|
967 bool isArray() const;
|
|
|
968 bool isObject() const;
|
|
|
969
|
|
|
970 bool isConvertibleTo(ValueType other) const;
|
|
|
971
|
|
|
972 /// Number of values in array or object
|
|
|
973 ArrayIndex size() const;
|
|
|
974
|
|
|
975 /// \brief Return true if empty array, empty object, or null;
|
|
|
976 /// otherwise, false.
|
|
|
977 bool empty() const;
|
|
|
978
|
|
|
979 /// Return !isNull()
|
|
|
980 JSONCPP_OP_EXPLICIT operator bool() const;
|
|
|
981
|
|
|
982 /// Remove all object members and array elements.
|
|
|
983 /// \pre type() is arrayValue, objectValue, or nullValue
|
|
|
984 /// \post type() is unchanged
|
|
|
985 void clear();
|
|
|
986
|
|
|
987 /// Resize the array to newSize elements.
|
|
|
988 /// New elements are initialized to null.
|
|
|
989 /// May only be called on nullValue or arrayValue.
|
|
|
990 /// \pre type() is arrayValue or nullValue
|
|
|
991 /// \post type() is arrayValue
|
|
|
992 void resize(ArrayIndex newSize);
|
|
|
993
|
|
|
994 /// Access an array element (zero based index ).
|
|
|
995 /// If the array contains less than index element, then null value are
|
|
|
996 /// inserted
|
|
|
997 /// in the array so that its size is index+1.
|
|
|
998 /// (You may need to say 'value[0u]' to get your compiler to distinguish
|
|
|
999 /// this from the operator[] which takes a string.)
|
|
|
1000 Value& operator[](ArrayIndex index);
|
|
|
1001
|
|
|
1002 /// Access an array element (zero based index ).
|
|
|
1003 /// If the array contains less than index element, then null value are
|
|
|
1004 /// inserted
|
|
|
1005 /// in the array so that its size is index+1.
|
|
|
1006 /// (You may need to say 'value[0u]' to get your compiler to distinguish
|
|
|
1007 /// this from the operator[] which takes a string.)
|
|
|
1008 Value& operator[](int index);
|
|
|
1009
|
|
|
1010 /// Access an array element (zero based index )
|
|
|
1011 /// (You may need to say 'value[0u]' to get your compiler to distinguish
|
|
|
1012 /// this from the operator[] which takes a string.)
|
|
|
1013 const Value& operator[](ArrayIndex index) const;
|
|
|
1014
|
|
|
1015 /// Access an array element (zero based index )
|
|
|
1016 /// (You may need to say 'value[0u]' to get your compiler to distinguish
|
|
|
1017 /// this from the operator[] which takes a string.)
|
|
|
1018 const Value& operator[](int index) const;
|
|
|
1019
|
|
|
1020 /// If the array contains at least index+1 elements, returns the element
|
|
|
1021 /// value,
|
|
|
1022 /// otherwise returns defaultValue.
|
|
|
1023 Value get(ArrayIndex index, const Value& defaultValue) const;
|
|
|
1024 /// Return true if index < size().
|
|
|
1025 bool isValidIndex(ArrayIndex index) const;
|
|
|
1026 /// \brief Append value to array at the end.
|
|
|
1027 ///
|
|
|
1028 /// Equivalent to jsonvalue[jsonvalue.size()] = value;
|
|
|
1029 Value& append(const Value& value);
|
|
|
1030
|
|
|
1031 #if JSON_HAS_RVALUE_REFERENCES
|
|
|
1032 Value& append(Value&& value);
|
|
|
1033 #endif
|
|
|
1034
|
|
|
1035 /// Access an object value by name, create a null member if it does not exist.
|
|
|
1036 /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
|
|
|
1037 /// Exceeding that will cause an exception.
|
|
|
1038 Value& operator[](const char* key);
|
|
|
1039 /// Access an object value by name, returns null if there is no member with
|
|
|
1040 /// that name.
|
|
|
1041 const Value& operator[](const char* key) const;
|
|
|
1042 /// Access an object value by name, create a null member if it does not exist.
|
|
|
1043 /// \param key may contain embedded nulls.
|
|
|
1044 Value& operator[](const String& key);
|
|
|
1045 /// Access an object value by name, returns null if there is no member with
|
|
|
1046 /// that name.
|
|
|
1047 /// \param key may contain embedded nulls.
|
|
|
1048 const Value& operator[](const String& key) const;
|
|
|
1049 /** \brief Access an object value by name, create a null member if it does not
|
|
|
1050 exist.
|
|
|
1051
|
|
|
1052 * If the object has no entry for that name, then the member name used to
|
|
|
1053 store
|
|
|
1054 * the new entry is not duplicated.
|
|
|
1055 * Example of use:
|
|
|
1056 * \code
|
|
|
1057 * Json::Value object;
|
|
|
1058 * static const StaticString code("code");
|
|
|
1059 * object[code] = 1234;
|
|
|
1060 * \endcode
|
|
|
1061 */
|
|
|
1062 Value& operator[](const StaticString& key);
|
|
|
1063 #ifdef JSON_USE_CPPTL
|
|
|
1064 /// Access an object value by name, create a null member if it does not exist.
|
|
|
1065 Value& operator[](const CppTL::ConstString& key);
|
|
|
1066 /// Access an object value by name, returns null if there is no member with
|
|
|
1067 /// that name.
|
|
|
1068 const Value& operator[](const CppTL::ConstString& key) const;
|
|
|
1069 #endif
|
|
|
1070 /// Return the member named key if it exist, defaultValue otherwise.
|
|
|
1071 /// \note deep copy
|
|
|
1072 Value get(const char* key, const Value& defaultValue) const;
|
|
|
1073 /// Return the member named key if it exist, defaultValue otherwise.
|
|
|
1074 /// \note deep copy
|
|
|
1075 /// \note key may contain embedded nulls.
|
|
|
1076 Value
|
|
|
1077 get(const char* begin, const char* end, const Value& defaultValue) const;
|
|
|
1078 /// Return the member named key if it exist, defaultValue otherwise.
|
|
|
1079 /// \note deep copy
|
|
|
1080 /// \param key may contain embedded nulls.
|
|
|
1081 Value get(const String& key, const Value& defaultValue) const;
|
|
|
1082 #ifdef JSON_USE_CPPTL
|
|
|
1083 /// Return the member named key if it exist, defaultValue otherwise.
|
|
|
1084 /// \note deep copy
|
|
|
1085 Value get(const CppTL::ConstString& key, const Value& defaultValue) const;
|
|
|
1086 #endif
|
|
|
1087 /// Most general and efficient version of isMember()const, get()const,
|
|
|
1088 /// and operator[]const
|
|
|
1089 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
|
|
|
1090 Value const* find(char const* begin, char const* end) const;
|
|
|
1091 /// Most general and efficient version of object-mutators.
|
|
|
1092 /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
|
|
|
1093 /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
|
|
|
1094 Value const* demand(char const* begin, char const* end);
|
|
|
1095 /// \brief Remove and return the named member.
|
|
|
1096 ///
|
|
|
1097 /// Do nothing if it did not exist.
|
|
|
1098 /// \pre type() is objectValue or nullValue
|
|
|
1099 /// \post type() is unchanged
|
|
|
1100 void removeMember(const char* key);
|
|
|
1101 /// Same as removeMember(const char*)
|
|
|
1102 /// \param key may contain embedded nulls.
|
|
|
1103 void removeMember(const String& key);
|
|
|
1104 /// Same as removeMember(const char* begin, const char* end, Value* removed),
|
|
|
1105 /// but 'key' is null-terminated.
|
|
|
1106 bool removeMember(const char* key, Value* removed);
|
|
|
1107 /** \brief Remove the named map member.
|
|
|
1108
|
|
|
1109 Update 'removed' iff removed.
|
|
|
1110 \param key may contain embedded nulls.
|
|
|
1111 \return true iff removed (no exceptions)
|
|
|
1112 */
|
|
|
1113 bool removeMember(String const& key, Value* removed);
|
|
|
1114 /// Same as removeMember(String const& key, Value* removed)
|
|
|
1115 bool removeMember(const char* begin, const char* end, Value* removed);
|
|
|
1116 /** \brief Remove the indexed array element.
|
|
|
1117
|
|
|
1118 O(n) expensive operations.
|
|
|
1119 Update 'removed' iff removed.
|
|
|
1120 \return true if removed (no exceptions)
|
|
|
1121 */
|
|
|
1122 bool removeIndex(ArrayIndex index, Value* removed);
|
|
|
1123
|
|
|
1124 /// Return true if the object has a member named key.
|
|
|
1125 /// \note 'key' must be null-terminated.
|
|
|
1126 bool isMember(const char* key) const;
|
|
|
1127 /// Return true if the object has a member named key.
|
|
|
1128 /// \param key may contain embedded nulls.
|
|
|
1129 bool isMember(const String& key) const;
|
|
|
1130 /// Same as isMember(String const& key)const
|
|
|
1131 bool isMember(const char* begin, const char* end) const;
|
|
|
1132 #ifdef JSON_USE_CPPTL
|
|
|
1133 /// Return true if the object has a member named key.
|
|
|
1134 bool isMember(const CppTL::ConstString& key) const;
|
|
|
1135 #endif
|
|
|
1136
|
|
|
1137 /// \brief Return a list of the member names.
|
|
|
1138 ///
|
|
|
1139 /// If null, return an empty list.
|
|
|
1140 /// \pre type() is objectValue or nullValue
|
|
|
1141 /// \post if type() was nullValue, it remains nullValue
|
|
|
1142 Members getMemberNames() const;
|
|
|
1143
|
|
|
1144 //# ifdef JSON_USE_CPPTL
|
|
|
1145 // EnumMemberNames enumMemberNames() const;
|
|
|
1146 // EnumValues enumValues() const;
|
|
|
1147 //# endif
|
|
|
1148
|
|
|
1149 /// \deprecated Always pass len.
|
|
|
1150 JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
|
|
|
1151 void setComment(const char* comment, CommentPlacement placement);
|
|
|
1152 /// Comments must be //... or /* ... */
|
|
|
1153 void setComment(const char* comment, size_t len, CommentPlacement placement);
|
|
|
1154 /// Comments must be //... or /* ... */
|
|
|
1155 void setComment(const String& comment, CommentPlacement placement);
|
|
|
1156 bool hasComment(CommentPlacement placement) const;
|
|
|
1157 /// Include delimiters and embedded newlines.
|
|
|
1158 String getComment(CommentPlacement placement) const;
|
|
|
1159
|
|
|
1160 String toStyledString() const;
|
|
|
1161
|
|
|
1162 const_iterator begin() const;
|
|
|
1163 const_iterator end() const;
|
|
|
1164
|
|
|
1165 iterator begin();
|
|
|
1166 iterator end();
|
|
|
1167
|
|
|
1168 // Accessors for the [start, limit) range of bytes within the JSON text from
|
|
|
1169 // which this value was parsed, if any.
|
|
|
1170 void setOffsetStart(ptrdiff_t start);
|
|
|
1171 void setOffsetLimit(ptrdiff_t limit);
|
|
|
1172 ptrdiff_t getOffsetStart() const;
|
|
|
1173 ptrdiff_t getOffsetLimit() const;
|
|
|
1174
|
|
|
1175 private:
|
|
|
1176 void setType(ValueType v) { bits_.value_type_ = v; }
|
|
|
1177 bool isAllocated() const { return bits_.allocated_; }
|
|
|
1178 void setIsAllocated(bool v) { bits_.allocated_ = v; }
|
|
|
1179
|
|
|
1180 void initBasic(ValueType type, bool allocated = false);
|
|
|
1181 void dupPayload(const Value& other);
|
|
|
1182 void releasePayload();
|
|
|
1183 void dupMeta(const Value& other);
|
|
|
1184
|
|
|
1185 Value& resolveReference(const char* key);
|
|
|
1186 Value& resolveReference(const char* key, const char* end);
|
|
|
1187
|
|
|
1188 struct CommentInfo {
|
|
|
1189 CommentInfo();
|
|
|
1190 ~CommentInfo();
|
|
|
1191
|
|
|
1192 void setComment(const char* text, size_t len);
|
|
|
1193
|
|
|
1194 char* comment_{nullptr};
|
|
|
1195 };
|
|
|
1196
|
|
|
1197 // struct MemberNamesTransform
|
|
|
1198 //{
|
|
|
1199 // typedef const char *result_type;
|
|
|
1200 // const char *operator()( const CZString &name ) const
|
|
|
1201 // {
|
|
|
1202 // return name.c_str();
|
|
|
1203 // }
|
|
|
1204 //};
|
|
|
1205
|
|
|
1206 union ValueHolder {
|
|
|
1207 LargestInt int_;
|
|
|
1208 LargestUInt uint_;
|
|
|
1209 double real_;
|
|
|
1210 bool bool_;
|
|
|
1211 char* string_; // if allocated_, ptr to { unsigned, char[] }.
|
|
|
1212 ObjectValues* map_;
|
|
|
1213 } value_;
|
|
|
1214
|
|
|
1215 struct {
|
|
|
1216 // Really a ValueType, but types should agree for bitfield packing.
|
|
|
1217 unsigned int value_type_ : 8;
|
|
|
1218 // Unless allocated_, string_ must be null-terminated.
|
|
|
1219 unsigned int allocated_ : 1;
|
|
|
1220 } bits_;
|
|
|
1221
|
|
|
1222 CommentInfo* comments_;
|
|
|
1223
|
|
|
1224 // [start, limit) byte offsets in the source JSON text from which this Value
|
|
|
1225 // was extracted.
|
|
|
1226 ptrdiff_t start_;
|
|
|
1227 ptrdiff_t limit_;
|
|
|
1228 };
|
|
|
1229
|
|
|
1230 /** \brief Experimental and untested: represents an element of the "path" to
|
|
|
1231 * access a node.
|
|
|
1232 */
|
|
|
1233 class JSON_API PathArgument {
|
|
|
1234 public:
|
|
|
1235 friend class Path;
|
|
|
1236
|
|
|
1237 PathArgument();
|
|
|
1238 PathArgument(ArrayIndex index);
|
|
|
1239 PathArgument(const char* key);
|
|
|
1240 PathArgument(const String& key);
|
|
|
1241
|
|
|
1242 private:
|
|
|
1243 enum Kind { kindNone = 0, kindIndex, kindKey };
|
|
|
1244 String key_;
|
|
|
1245 ArrayIndex index_{};
|
|
|
1246 Kind kind_{kindNone};
|
|
|
1247 };
|
|
|
1248
|
|
|
1249 /** \brief Experimental and untested: represents a "path" to access a node.
|
|
|
1250 *
|
|
|
1251 * Syntax:
|
|
|
1252 * - "." => root node
|
|
|
1253 * - ".[n]" => elements at index 'n' of root node (an array value)
|
|
|
1254 * - ".name" => member named 'name' of root node (an object value)
|
|
|
1255 * - ".name1.name2.name3"
|
|
|
1256 * - ".[0][1][2].name1[3]"
|
|
|
1257 * - ".%" => member name is provided as parameter
|
|
|
1258 * - ".[%]" => index is provied as parameter
|
|
|
1259 */
|
|
|
1260 class JSON_API Path {
|
|
|
1261 public:
|
|
|
1262 Path(const String& path,
|
|
|
1263 const PathArgument& a1 = PathArgument(),
|
|
|
1264 const PathArgument& a2 = PathArgument(),
|
|
|
1265 const PathArgument& a3 = PathArgument(),
|
|
|
1266 const PathArgument& a4 = PathArgument(),
|
|
|
1267 const PathArgument& a5 = PathArgument());
|
|
|
1268
|
|
|
1269 const Value& resolve(const Value& root) const;
|
|
|
1270 Value resolve(const Value& root, const Value& defaultValue) const;
|
|
|
1271 /// Creates the "path" to access the specified node and returns a reference on
|
|
|
1272 /// the node.
|
|
|
1273 Value& make(Value& root) const;
|
|
|
1274
|
|
|
1275 private:
|
|
|
1276 typedef std::vector<const PathArgument*> InArgs;
|
|
|
1277 typedef std::vector<PathArgument> Args;
|
|
|
1278
|
|
|
1279 void makePath(const String& path, const InArgs& in);
|
|
|
1280 void addPathInArg(const String& path,
|
|
|
1281 const InArgs& in,
|
|
|
1282 InArgs::const_iterator& itInArg,
|
|
|
1283 PathArgument::Kind kind);
|
|
|
1284 static void invalidPath(const String& path, int location);
|
|
|
1285
|
|
|
1286 Args args_;
|
|
|
1287 };
|
|
|
1288
|
|
|
1289 /** \brief base class for Value iterators.
|
|
|
1290 *
|
|
|
1291 */
|
|
|
1292 class JSON_API ValueIteratorBase {
|
|
|
1293 public:
|
|
|
1294 typedef std::bidirectional_iterator_tag iterator_category;
|
|
|
1295 typedef unsigned int size_t;
|
|
|
1296 typedef int difference_type;
|
|
|
1297 typedef ValueIteratorBase SelfType;
|
|
|
1298
|
|
|
1299 bool operator==(const SelfType& other) const { return isEqual(other); }
|
|
|
1300
|
|
|
1301 bool operator!=(const SelfType& other) const { return !isEqual(other); }
|
|
|
1302
|
|
|
1303 difference_type operator-(const SelfType& other) const {
|
|
|
1304 return other.computeDistance(*this);
|
|
|
1305 }
|
|
|
1306
|
|
|
1307 /// Return either the index or the member name of the referenced value as a
|
|
|
1308 /// Value.
|
|
|
1309 Value key() const;
|
|
|
1310
|
|
|
1311 /// Return the index of the referenced Value, or -1 if it is not an
|
|
|
1312 /// arrayValue.
|
|
|
1313 UInt index() const;
|
|
|
1314
|
|
|
1315 /// Return the member name of the referenced Value, or "" if it is not an
|
|
|
1316 /// objectValue.
|
|
|
1317 /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
|
|
|
1318 String name() const;
|
|
|
1319
|
|
|
1320 /// Return the member name of the referenced Value. "" if it is not an
|
|
|
1321 /// objectValue.
|
|
|
1322 /// \deprecated This cannot be used for UTF-8 strings, since there can be
|
|
|
1323 /// embedded nulls.
|
|
|
1324 JSONCPP_DEPRECATED("Use `key = name();` instead.")
|
|
|
1325 char const* memberName() const;
|
|
|
1326 /// Return the member name of the referenced Value, or NULL if it is not an
|
|
|
1327 /// objectValue.
|
|
|
1328 /// \note Better version than memberName(). Allows embedded nulls.
|
|
|
1329 char const* memberName(char const** end) const;
|
|
|
1330
|
|
|
1331 protected:
|
|
|
1332 Value& deref() const;
|
|
|
1333
|
|
|
1334 void increment();
|
|
|
1335
|
|
|
1336 void decrement();
|
|
|
1337
|
|
|
1338 difference_type computeDistance(const SelfType& other) const;
|
|
|
1339
|
|
|
1340 bool isEqual(const SelfType& other) const;
|
|
|
1341
|
|
|
1342 void copy(const SelfType& other);
|
|
|
1343
|
|
|
1344 private:
|
|
|
1345 Value::ObjectValues::iterator current_;
|
|
|
1346 // Indicates that iterator is for a null value.
|
|
|
1347 bool isNull_{true};
|
|
|
1348
|
|
|
1349 public:
|
|
|
1350 // For some reason, BORLAND needs these at the end, rather
|
|
|
1351 // than earlier. No idea why.
|
|
|
1352 ValueIteratorBase();
|
|
|
1353 explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
|
|
|
1354 };
|
|
|
1355
|
|
|
1356 /** \brief const iterator for object and array value.
|
|
|
1357 *
|
|
|
1358 */
|
|
|
1359 class JSON_API ValueConstIterator : public ValueIteratorBase {
|
|
|
1360 friend class Value;
|
|
|
1361
|
|
|
1362 public:
|
|
|
1363 typedef const Value value_type;
|
|
|
1364 // typedef unsigned int size_t;
|
|
|
1365 // typedef int difference_type;
|
|
|
1366 typedef const Value& reference;
|
|
|
1367 typedef const Value* pointer;
|
|
|
1368 typedef ValueConstIterator SelfType;
|
|
|
1369
|
|
|
1370 ValueConstIterator();
|
|
|
1371 ValueConstIterator(ValueIterator const& other);
|
|
|
1372
|
|
|
1373 private:
|
|
|
1374 /*! \internal Use by Value to create an iterator.
|
|
|
1375 */
|
|
|
1376 explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
|
|
|
1377
|
|
|
1378 public:
|
|
|
1379 SelfType& operator=(const ValueIteratorBase& other);
|
|
|
1380
|
|
|
1381 SelfType operator++(int) {
|
|
|
1382 SelfType temp(*this);
|
|
|
1383 ++*this;
|
|
|
1384 return temp;
|
|
|
1385 }
|
|
|
1386
|
|
|
1387 SelfType operator--(int) {
|
|
|
1388 SelfType temp(*this);
|
|
|
1389 --*this;
|
|
|
1390 return temp;
|
|
|
1391 }
|
|
|
1392
|
|
|
1393 SelfType& operator--() {
|
|
|
1394 decrement();
|
|
|
1395 return *this;
|
|
|
1396 }
|
|
|
1397
|
|
|
1398 SelfType& operator++() {
|
|
|
1399 increment();
|
|
|
1400 return *this;
|
|
|
1401 }
|
|
|
1402
|
|
|
1403 reference operator*() const { return deref(); }
|
|
|
1404
|
|
|
1405 pointer operator->() const { return &deref(); }
|
|
|
1406 };
|
|
|
1407
|
|
|
1408 /** \brief Iterator for object and array value.
|
|
|
1409 */
|
|
|
1410 class JSON_API ValueIterator : public ValueIteratorBase {
|
|
|
1411 friend class Value;
|
|
|
1412
|
|
|
1413 public:
|
|
|
1414 typedef Value value_type;
|
|
|
1415 typedef unsigned int size_t;
|
|
|
1416 typedef int difference_type;
|
|
|
1417 typedef Value& reference;
|
|
|
1418 typedef Value* pointer;
|
|
|
1419 typedef ValueIterator SelfType;
|
|
|
1420
|
|
|
1421 ValueIterator();
|
|
|
1422 explicit ValueIterator(const ValueConstIterator& other);
|
|
|
1423 ValueIterator(const ValueIterator& other);
|
|
|
1424
|
|
|
1425 private:
|
|
|
1426 /*! \internal Use by Value to create an iterator.
|
|
|
1427 */
|
|
|
1428 explicit ValueIterator(const Value::ObjectValues::iterator& current);
|
|
|
1429
|
|
|
1430 public:
|
|
|
1431 SelfType& operator=(const SelfType& other);
|
|
|
1432
|
|
|
1433 SelfType operator++(int) {
|
|
|
1434 SelfType temp(*this);
|
|
|
1435 ++*this;
|
|
|
1436 return temp;
|
|
|
1437 }
|
|
|
1438
|
|
|
1439 SelfType operator--(int) {
|
|
|
1440 SelfType temp(*this);
|
|
|
1441 --*this;
|
|
|
1442 return temp;
|
|
|
1443 }
|
|
|
1444
|
|
|
1445 SelfType& operator--() {
|
|
|
1446 decrement();
|
|
|
1447 return *this;
|
|
|
1448 }
|
|
|
1449
|
|
|
1450 SelfType& operator++() {
|
|
|
1451 increment();
|
|
|
1452 return *this;
|
|
|
1453 }
|
|
|
1454
|
|
|
1455 reference operator*() const { return deref(); }
|
|
|
1456
|
|
|
1457 pointer operator->() const { return &deref(); }
|
|
|
1458 };
|
|
|
1459
|
|
|
1460 inline void swap(Value& a, Value& b) { a.swap(b); }
|
|
|
1461
|
|
|
1462 } // namespace Json
|
|
|
1463
|
|
|
1464 #pragma pack(pop)
|
|
|
1465
|
|
|
1466 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1467 #pragma warning(pop)
|
|
|
1468 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1469
|
|
|
1470 #endif // CPPTL_JSON_H_INCLUDED
|
|
|
1471
|
|
|
1472 // //////////////////////////////////////////////////////////////////////
|
|
|
1473 // End of content of file: include/json/value.h
|
|
|
1474 // //////////////////////////////////////////////////////////////////////
|
|
|
1475
|
|
|
1476
|
|
|
1477
|
|
|
1478
|
|
|
1479
|
|
|
1480
|
|
|
1481 // //////////////////////////////////////////////////////////////////////
|
|
|
1482 // Beginning of content of file: include/json/reader.h
|
|
|
1483 // //////////////////////////////////////////////////////////////////////
|
|
|
1484
|
|
|
1485 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
1486 // Distributed under MIT license, or public domain if desired and
|
|
|
1487 // recognized in your jurisdiction.
|
|
|
1488 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
1489
|
|
|
1490 #ifndef CPPTL_JSON_READER_H_INCLUDED
|
|
|
1491 #define CPPTL_JSON_READER_H_INCLUDED
|
|
|
1492
|
|
|
1493 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
1494 #include "features.h"
|
|
|
1495 #include "value.h"
|
|
|
1496 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
1497 #include <deque>
|
|
|
1498 #include <iosfwd>
|
|
|
1499 #include <istream>
|
|
|
1500 #include <stack>
|
|
|
1501 #include <string>
|
|
|
1502
|
|
|
1503 // Disable warning C4251: <data member>: <type> needs to have dll-interface to
|
|
|
1504 // be used by...
|
|
|
1505 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1506 #pragma warning(push)
|
|
|
1507 #pragma warning(disable : 4251)
|
|
|
1508 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1509
|
|
|
1510 #pragma pack(push, 8)
|
|
|
1511
|
|
|
1512 namespace Json {
|
|
|
1513
|
|
|
1514 /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
|
|
|
1515 *Value.
|
|
|
1516 *
|
|
|
1517 * \deprecated Use CharReader and CharReaderBuilder.
|
|
|
1518 */
|
|
|
1519 class JSON_API Reader {
|
|
|
1520 public:
|
|
|
1521 typedef char Char;
|
|
|
1522 typedef const Char* Location;
|
|
|
1523
|
|
|
1524 /** \brief An error tagged with where in the JSON text it was encountered.
|
|
|
1525 *
|
|
|
1526 * The offsets give the [start, limit) range of bytes within the text. Note
|
|
|
1527 * that this is bytes, not codepoints.
|
|
|
1528 *
|
|
|
1529 */
|
|
|
1530 struct StructuredError {
|
|
|
1531 ptrdiff_t offset_start;
|
|
|
1532 ptrdiff_t offset_limit;
|
|
|
1533 String message;
|
|
|
1534 };
|
|
|
1535
|
|
|
1536 /** \brief Constructs a Reader allowing all features
|
|
|
1537 * for parsing.
|
|
|
1538 */
|
|
|
1539 JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead")
|
|
|
1540 Reader();
|
|
|
1541
|
|
|
1542 /** \brief Constructs a Reader allowing the specified feature set
|
|
|
1543 * for parsing.
|
|
|
1544 */
|
|
|
1545 JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead")
|
|
|
1546 Reader(const Features& features);
|
|
|
1547
|
|
|
1548 /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
|
|
|
1549 * document.
|
|
|
1550 * \param document UTF-8 encoded string containing the document to read.
|
|
|
1551 * \param root [out] Contains the root value of the document if it was
|
|
|
1552 * successfully parsed.
|
|
|
1553 * \param collectComments \c true to collect comment and allow writing them
|
|
|
1554 * back during
|
|
|
1555 * serialization, \c false to discard comments.
|
|
|
1556 * This parameter is ignored if
|
|
|
1557 * Features::allowComments_
|
|
|
1558 * is \c false.
|
|
|
1559 * \return \c true if the document was successfully parsed, \c false if an
|
|
|
1560 * error occurred.
|
|
|
1561 */
|
|
|
1562 bool
|
|
|
1563 parse(const std::string& document, Value& root, bool collectComments = true);
|
|
|
1564
|
|
|
1565 /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
|
|
|
1566 document.
|
|
|
1567 * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
|
|
|
1568 document to read.
|
|
|
1569 * \param endDoc Pointer on the end of the UTF-8 encoded string of the
|
|
|
1570 document to read.
|
|
|
1571 * Must be >= beginDoc.
|
|
|
1572 * \param root [out] Contains the root value of the document if it was
|
|
|
1573 * successfully parsed.
|
|
|
1574 * \param collectComments \c true to collect comment and allow writing them
|
|
|
1575 back during
|
|
|
1576 * serialization, \c false to discard comments.
|
|
|
1577 * This parameter is ignored if
|
|
|
1578 Features::allowComments_
|
|
|
1579 * is \c false.
|
|
|
1580 * \return \c true if the document was successfully parsed, \c false if an
|
|
|
1581 error occurred.
|
|
|
1582 */
|
|
|
1583 bool parse(const char* beginDoc,
|
|
|
1584 const char* endDoc,
|
|
|
1585 Value& root,
|
|
|
1586 bool collectComments = true);
|
|
|
1587
|
|
|
1588 /// \brief Parse from input stream.
|
|
|
1589 /// \see Json::operator>>(std::istream&, Json::Value&).
|
|
|
1590 bool parse(IStream& is, Value& root, bool collectComments = true);
|
|
|
1591
|
|
|
1592 /** \brief Returns a user friendly string that list errors in the parsed
|
|
|
1593 * document.
|
|
|
1594 * \return Formatted error message with the list of errors with their location
|
|
|
1595 * in
|
|
|
1596 * the parsed document. An empty string is returned if no error
|
|
|
1597 * occurred
|
|
|
1598 * during parsing.
|
|
|
1599 * \deprecated Use getFormattedErrorMessages() instead (typo fix).
|
|
|
1600 */
|
|
|
1601 JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
|
|
|
1602 String getFormatedErrorMessages() const;
|
|
|
1603
|
|
|
1604 /** \brief Returns a user friendly string that list errors in the parsed
|
|
|
1605 * document.
|
|
|
1606 * \return Formatted error message with the list of errors with their location
|
|
|
1607 * in
|
|
|
1608 * the parsed document. An empty string is returned if no error
|
|
|
1609 * occurred
|
|
|
1610 * during parsing.
|
|
|
1611 */
|
|
|
1612 String getFormattedErrorMessages() const;
|
|
|
1613
|
|
|
1614 /** \brief Returns a vector of structured erros encounted while parsing.
|
|
|
1615 * \return A (possibly empty) vector of StructuredError objects. Currently
|
|
|
1616 * only one error can be returned, but the caller should tolerate
|
|
|
1617 * multiple
|
|
|
1618 * errors. This can occur if the parser recovers from a non-fatal
|
|
|
1619 * parse error and then encounters additional errors.
|
|
|
1620 */
|
|
|
1621 std::vector<StructuredError> getStructuredErrors() const;
|
|
|
1622
|
|
|
1623 /** \brief Add a semantic error message.
|
|
|
1624 * \param value JSON Value location associated with the error
|
|
|
1625 * \param message The error message.
|
|
|
1626 * \return \c true if the error was successfully added, \c false if the
|
|
|
1627 * Value offset exceeds the document size.
|
|
|
1628 */
|
|
|
1629 bool pushError(const Value& value, const String& message);
|
|
|
1630
|
|
|
1631 /** \brief Add a semantic error message with extra context.
|
|
|
1632 * \param value JSON Value location associated with the error
|
|
|
1633 * \param message The error message.
|
|
|
1634 * \param extra Additional JSON Value location to contextualize the error
|
|
|
1635 * \return \c true if the error was successfully added, \c false if either
|
|
|
1636 * Value offset exceeds the document size.
|
|
|
1637 */
|
|
|
1638 bool pushError(const Value& value, const String& message, const Value& extra);
|
|
|
1639
|
|
|
1640 /** \brief Return whether there are any errors.
|
|
|
1641 * \return \c true if there are no errors to report \c false if
|
|
|
1642 * errors have occurred.
|
|
|
1643 */
|
|
|
1644 bool good() const;
|
|
|
1645
|
|
|
1646 private:
|
|
|
1647 enum TokenType {
|
|
|
1648 tokenEndOfStream = 0,
|
|
|
1649 tokenObjectBegin,
|
|
|
1650 tokenObjectEnd,
|
|
|
1651 tokenArrayBegin,
|
|
|
1652 tokenArrayEnd,
|
|
|
1653 tokenString,
|
|
|
1654 tokenNumber,
|
|
|
1655 tokenTrue,
|
|
|
1656 tokenFalse,
|
|
|
1657 tokenNull,
|
|
|
1658 tokenArraySeparator,
|
|
|
1659 tokenMemberSeparator,
|
|
|
1660 tokenComment,
|
|
|
1661 tokenError
|
|
|
1662 };
|
|
|
1663
|
|
|
1664 class Token {
|
|
|
1665 public:
|
|
|
1666 TokenType type_;
|
|
|
1667 Location start_;
|
|
|
1668 Location end_;
|
|
|
1669 };
|
|
|
1670
|
|
|
1671 class ErrorInfo {
|
|
|
1672 public:
|
|
|
1673 Token token_;
|
|
|
1674 String message_;
|
|
|
1675 Location extra_;
|
|
|
1676 };
|
|
|
1677
|
|
|
1678 typedef std::deque<ErrorInfo> Errors;
|
|
|
1679
|
|
|
1680 bool readToken(Token& token);
|
|
|
1681 void skipSpaces();
|
|
|
1682 bool match(Location pattern, int patternLength);
|
|
|
1683 bool readComment();
|
|
|
1684 bool readCStyleComment();
|
|
|
1685 bool readCppStyleComment();
|
|
|
1686 bool readString();
|
|
|
1687 void readNumber();
|
|
|
1688 bool readValue();
|
|
|
1689 bool readObject(Token& token);
|
|
|
1690 bool readArray(Token& token);
|
|
|
1691 bool decodeNumber(Token& token);
|
|
|
1692 bool decodeNumber(Token& token, Value& decoded);
|
|
|
1693 bool decodeString(Token& token);
|
|
|
1694 bool decodeString(Token& token, String& decoded);
|
|
|
1695 bool decodeDouble(Token& token);
|
|
|
1696 bool decodeDouble(Token& token, Value& decoded);
|
|
|
1697 bool decodeUnicodeCodePoint(Token& token,
|
|
|
1698 Location& current,
|
|
|
1699 Location end,
|
|
|
1700 unsigned int& unicode);
|
|
|
1701 bool decodeUnicodeEscapeSequence(Token& token,
|
|
|
1702 Location& current,
|
|
|
1703 Location end,
|
|
|
1704 unsigned int& unicode);
|
|
|
1705 bool addError(const String& message, Token& token, Location extra = nullptr);
|
|
|
1706 bool recoverFromError(TokenType skipUntilToken);
|
|
|
1707 bool addErrorAndRecover(const String& message,
|
|
|
1708 Token& token,
|
|
|
1709 TokenType skipUntilToken);
|
|
|
1710 void skipUntilSpace();
|
|
|
1711 Value& currentValue();
|
|
|
1712 Char getNextChar();
|
|
|
1713 void
|
|
|
1714 getLocationLineAndColumn(Location location, int& line, int& column) const;
|
|
|
1715 String getLocationLineAndColumn(Location location) const;
|
|
|
1716 void addComment(Location begin, Location end, CommentPlacement placement);
|
|
|
1717 void skipCommentTokens(Token& token);
|
|
|
1718
|
|
|
1719 static bool containsNewLine(Location begin, Location end);
|
|
|
1720 static String normalizeEOL(Location begin, Location end);
|
|
|
1721
|
|
|
1722 typedef std::stack<Value*> Nodes;
|
|
|
1723 Nodes nodes_;
|
|
|
1724 Errors errors_;
|
|
|
1725 String document_;
|
|
|
1726 Location begin_{};
|
|
|
1727 Location end_{};
|
|
|
1728 Location current_{};
|
|
|
1729 Location lastValueEnd_{};
|
|
|
1730 Value* lastValue_{};
|
|
|
1731 String commentsBefore_;
|
|
|
1732 Features features_;
|
|
|
1733 bool collectComments_{};
|
|
|
1734 }; // Reader
|
|
|
1735
|
|
|
1736 /** Interface for reading JSON from a char array.
|
|
|
1737 */
|
|
|
1738 class JSON_API CharReader {
|
|
|
1739 public:
|
|
|
1740 virtual ~CharReader() = default;
|
|
|
1741 /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
|
|
|
1742 document.
|
|
|
1743 * The document must be a UTF-8 encoded string containing the document to
|
|
|
1744 read.
|
|
|
1745 *
|
|
|
1746 * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
|
|
|
1747 document to read.
|
|
|
1748 * \param endDoc Pointer on the end of the UTF-8 encoded string of the
|
|
|
1749 document to read.
|
|
|
1750 * Must be >= beginDoc.
|
|
|
1751 * \param root [out] Contains the root value of the document if it was
|
|
|
1752 * successfully parsed.
|
|
|
1753 * \param errs [out] Formatted error messages (if not NULL)
|
|
|
1754 * a user friendly string that lists errors in the parsed
|
|
|
1755 * document.
|
|
|
1756 * \return \c true if the document was successfully parsed, \c false if an
|
|
|
1757 error occurred.
|
|
|
1758 */
|
|
|
1759 virtual bool parse(char const* beginDoc,
|
|
|
1760 char const* endDoc,
|
|
|
1761 Value* root,
|
|
|
1762 String* errs) = 0;
|
|
|
1763
|
|
|
1764 class JSON_API Factory {
|
|
|
1765 public:
|
|
|
1766 virtual ~Factory() = default;
|
|
|
1767 /** \brief Allocate a CharReader via operator new().
|
|
|
1768 * \throw std::exception if something goes wrong (e.g. invalid settings)
|
|
|
1769 */
|
|
|
1770 virtual CharReader* newCharReader() const = 0;
|
|
|
1771 }; // Factory
|
|
|
1772 }; // CharReader
|
|
|
1773
|
|
|
1774 /** \brief Build a CharReader implementation.
|
|
|
1775
|
|
|
1776 Usage:
|
|
|
1777 \code
|
|
|
1778 using namespace Json;
|
|
|
1779 CharReaderBuilder builder;
|
|
|
1780 builder["collectComments"] = false;
|
|
|
1781 Value value;
|
|
|
1782 String errs;
|
|
|
1783 bool ok = parseFromStream(builder, std::cin, &value, &errs);
|
|
|
1784 \endcode
|
|
|
1785 */
|
|
|
1786 class JSON_API CharReaderBuilder : public CharReader::Factory {
|
|
|
1787 public:
|
|
|
1788 // Note: We use a Json::Value so that we can add data-members to this class
|
|
|
1789 // without a major version bump.
|
|
|
1790 /** Configuration of this builder.
|
|
|
1791 These are case-sensitive.
|
|
|
1792 Available settings (case-sensitive):
|
|
|
1793 - `"collectComments": false or true`
|
|
|
1794 - true to collect comment and allow writing them
|
|
|
1795 back during serialization, false to discard comments.
|
|
|
1796 This parameter is ignored if allowComments is false.
|
|
|
1797 - `"allowComments": false or true`
|
|
|
1798 - true if comments are allowed.
|
|
|
1799 - `"strictRoot": false or true`
|
|
|
1800 - true if root must be either an array or an object value
|
|
|
1801 - `"allowDroppedNullPlaceholders": false or true`
|
|
|
1802 - true if dropped null placeholders are allowed. (See
|
|
|
1803 StreamWriterBuilder.)
|
|
|
1804 - `"allowNumericKeys": false or true`
|
|
|
1805 - true if numeric object keys are allowed.
|
|
|
1806 - `"allowSingleQuotes": false or true`
|
|
|
1807 - true if '' are allowed for strings (both keys and values)
|
|
|
1808 - `"stackLimit": integer`
|
|
|
1809 - Exceeding stackLimit (recursive depth of `readValue()`) will
|
|
|
1810 cause an exception.
|
|
|
1811 - This is a security issue (seg-faults caused by deeply nested JSON),
|
|
|
1812 so the default is low.
|
|
|
1813 - `"failIfExtra": false or true`
|
|
|
1814 - If true, `parse()` returns false when extra non-whitespace trails
|
|
|
1815 the JSON value in the input string.
|
|
|
1816 - `"rejectDupKeys": false or true`
|
|
|
1817 - If true, `parse()` returns false when a key is duplicated within an
|
|
|
1818 object.
|
|
|
1819 - `"allowSpecialFloats": false or true`
|
|
|
1820 - If true, special float values (NaNs and infinities) are allowed
|
|
|
1821 and their values are lossfree restorable.
|
|
|
1822
|
|
|
1823 You can examine 'settings_` yourself
|
|
|
1824 to see the defaults. You can also write and read them just like any
|
|
|
1825 JSON Value.
|
|
|
1826 \sa setDefaults()
|
|
|
1827 */
|
|
|
1828 Json::Value settings_;
|
|
|
1829
|
|
|
1830 CharReaderBuilder();
|
|
|
1831 ~CharReaderBuilder() override;
|
|
|
1832
|
|
|
1833 CharReader* newCharReader() const override;
|
|
|
1834
|
|
|
1835 /** \return true if 'settings' are legal and consistent;
|
|
|
1836 * otherwise, indicate bad settings via 'invalid'.
|
|
|
1837 */
|
|
|
1838 bool validate(Json::Value* invalid) const;
|
|
|
1839
|
|
|
1840 /** A simple way to update a specific setting.
|
|
|
1841 */
|
|
|
1842 Value& operator[](const String& key);
|
|
|
1843
|
|
|
1844 /** Called by ctor, but you can use this to reset settings_.
|
|
|
1845 * \pre 'settings' != NULL (but Json::null is fine)
|
|
|
1846 * \remark Defaults:
|
|
|
1847 * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
|
|
|
1848 */
|
|
|
1849 static void setDefaults(Json::Value* settings);
|
|
|
1850 /** Same as old Features::strictMode().
|
|
|
1851 * \pre 'settings' != NULL (but Json::null is fine)
|
|
|
1852 * \remark Defaults:
|
|
|
1853 * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
|
|
|
1854 */
|
|
|
1855 static void strictMode(Json::Value* settings);
|
|
|
1856 };
|
|
|
1857
|
|
|
1858 /** Consume entire stream and use its begin/end.
|
|
|
1859 * Someday we might have a real StreamReader, but for now this
|
|
|
1860 * is convenient.
|
|
|
1861 */
|
|
|
1862 bool JSON_API parseFromStream(CharReader::Factory const&,
|
|
|
1863 IStream&,
|
|
|
1864 Value* root,
|
|
|
1865 std::string* errs);
|
|
|
1866
|
|
|
1867 /** \brief Read from 'sin' into 'root'.
|
|
|
1868
|
|
|
1869 Always keep comments from the input JSON.
|
|
|
1870
|
|
|
1871 This can be used to read a file into a particular sub-object.
|
|
|
1872 For example:
|
|
|
1873 \code
|
|
|
1874 Json::Value root;
|
|
|
1875 cin >> root["dir"]["file"];
|
|
|
1876 cout << root;
|
|
|
1877 \endcode
|
|
|
1878 Result:
|
|
|
1879 \verbatim
|
|
|
1880 {
|
|
|
1881 "dir": {
|
|
|
1882 "file": {
|
|
|
1883 // The input stream JSON would be nested here.
|
|
|
1884 }
|
|
|
1885 }
|
|
|
1886 }
|
|
|
1887 \endverbatim
|
|
|
1888 \throw std::exception on parse error.
|
|
|
1889 \see Json::operator<<()
|
|
|
1890 */
|
|
|
1891 JSON_API IStream& operator>>(IStream&, Value&);
|
|
|
1892
|
|
|
1893 } // namespace Json
|
|
|
1894
|
|
|
1895 #pragma pack(pop)
|
|
|
1896
|
|
|
1897 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1898 #pragma warning(pop)
|
|
|
1899 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1900
|
|
|
1901 #endif // CPPTL_JSON_READER_H_INCLUDED
|
|
|
1902
|
|
|
1903 // //////////////////////////////////////////////////////////////////////
|
|
|
1904 // End of content of file: include/json/reader.h
|
|
|
1905 // //////////////////////////////////////////////////////////////////////
|
|
|
1906
|
|
|
1907
|
|
|
1908
|
|
|
1909
|
|
|
1910
|
|
|
1911
|
|
|
1912 // //////////////////////////////////////////////////////////////////////
|
|
|
1913 // Beginning of content of file: include/json/writer.h
|
|
|
1914 // //////////////////////////////////////////////////////////////////////
|
|
|
1915
|
|
|
1916 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
1917 // Distributed under MIT license, or public domain if desired and
|
|
|
1918 // recognized in your jurisdiction.
|
|
|
1919 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
1920
|
|
|
1921 #ifndef JSON_WRITER_H_INCLUDED
|
|
|
1922 #define JSON_WRITER_H_INCLUDED
|
|
|
1923
|
|
|
1924 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
1925 #include "value.h"
|
|
|
1926 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
1927 #include <ostream>
|
|
|
1928 #include <string>
|
|
|
1929 #include <vector>
|
|
|
1930
|
|
|
1931 // Disable warning C4251: <data member>: <type> needs to have dll-interface to
|
|
|
1932 // be used by...
|
|
|
1933 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) && defined(_MSC_VER)
|
|
|
1934 #pragma warning(push)
|
|
|
1935 #pragma warning(disable : 4251)
|
|
|
1936 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
1937
|
|
|
1938 #pragma pack(push, 8)
|
|
|
1939
|
|
|
1940 namespace Json {
|
|
|
1941
|
|
|
1942 class Value;
|
|
|
1943
|
|
|
1944 /**
|
|
|
1945
|
|
|
1946 Usage:
|
|
|
1947 \code
|
|
|
1948 using namespace Json;
|
|
|
1949 void writeToStdout(StreamWriter::Factory const& factory, Value const& value) {
|
|
|
1950 std::unique_ptr<StreamWriter> const writer(
|
|
|
1951 factory.newStreamWriter());
|
|
|
1952 writer->write(value, &std::cout);
|
|
|
1953 std::cout << std::endl; // add lf and flush
|
|
|
1954 }
|
|
|
1955 \endcode
|
|
|
1956 */
|
|
|
1957 class JSON_API StreamWriter {
|
|
|
1958 protected:
|
|
|
1959 OStream* sout_; // not owned; will not delete
|
|
|
1960 public:
|
|
|
1961 StreamWriter();
|
|
|
1962 virtual ~StreamWriter();
|
|
|
1963 /** Write Value into document as configured in sub-class.
|
|
|
1964 Do not take ownership of sout, but maintain a reference during function.
|
|
|
1965 \pre sout != NULL
|
|
|
1966 \return zero on success (For now, we always return zero, so check the
|
|
|
1967 stream instead.) \throw std::exception possibly, depending on configuration
|
|
|
1968 */
|
|
|
1969 virtual int write(Value const& root, OStream* sout) = 0;
|
|
|
1970
|
|
|
1971 /** \brief A simple abstract factory.
|
|
|
1972 */
|
|
|
1973 class JSON_API Factory {
|
|
|
1974 public:
|
|
|
1975 virtual ~Factory();
|
|
|
1976 /** \brief Allocate a CharReader via operator new().
|
|
|
1977 * \throw std::exception if something goes wrong (e.g. invalid settings)
|
|
|
1978 */
|
|
|
1979 virtual StreamWriter* newStreamWriter() const = 0;
|
|
|
1980 }; // Factory
|
|
|
1981 }; // StreamWriter
|
|
|
1982
|
|
|
1983 /** \brief Write into stringstream, then return string, for convenience.
|
|
|
1984 * A StreamWriter will be created from the factory, used, and then deleted.
|
|
|
1985 */
|
|
|
1986 String JSON_API writeString(StreamWriter::Factory const& factory,
|
|
|
1987 Value const& root);
|
|
|
1988
|
|
|
1989 /** \brief Build a StreamWriter implementation.
|
|
|
1990
|
|
|
1991 Usage:
|
|
|
1992 \code
|
|
|
1993 using namespace Json;
|
|
|
1994 Value value = ...;
|
|
|
1995 StreamWriterBuilder builder;
|
|
|
1996 builder["commentStyle"] = "None";
|
|
|
1997 builder["indentation"] = " "; // or whatever you like
|
|
|
1998 std::unique_ptr<Json::StreamWriter> writer(
|
|
|
1999 builder.newStreamWriter());
|
|
|
2000 writer->write(value, &std::cout);
|
|
|
2001 std::cout << std::endl; // add lf and flush
|
|
|
2002 \endcode
|
|
|
2003 */
|
|
|
2004 class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
|
|
|
2005 public:
|
|
|
2006 // Note: We use a Json::Value so that we can add data-members to this class
|
|
|
2007 // without a major version bump.
|
|
|
2008 /** Configuration of this builder.
|
|
|
2009 Available settings (case-sensitive):
|
|
|
2010 - "commentStyle": "None" or "All"
|
|
|
2011 - "indentation": "<anything>".
|
|
|
2012 - Setting this to an empty string also omits newline characters.
|
|
|
2013 - "enableYAMLCompatibility": false or true
|
|
|
2014 - slightly change the whitespace around colons
|
|
|
2015 - "dropNullPlaceholders": false or true
|
|
|
2016 - Drop the "null" string from the writer's output for nullValues.
|
|
|
2017 Strictly speaking, this is not valid JSON. But when the output is being
|
|
|
2018 fed to a browser's JavaScript, it makes for smaller output and the
|
|
|
2019 browser can handle the output just fine.
|
|
|
2020 - "useSpecialFloats": false or true
|
|
|
2021 - If true, outputs non-finite floating point values in the following way:
|
|
|
2022 NaN values as "NaN", positive infinity as "Infinity", and negative
|
|
|
2023 infinity as "-Infinity".
|
|
|
2024 - "precision": int
|
|
|
2025 - Number of precision digits for formatting of real values.
|
|
|
2026 - "precisionType": "significant"(default) or "decimal"
|
|
|
2027 - Type of precision for formatting of real values.
|
|
|
2028
|
|
|
2029 You can examine 'settings_` yourself
|
|
|
2030 to see the defaults. You can also write and read them just like any
|
|
|
2031 JSON Value.
|
|
|
2032 \sa setDefaults()
|
|
|
2033 */
|
|
|
2034 Json::Value settings_;
|
|
|
2035
|
|
|
2036 StreamWriterBuilder();
|
|
|
2037 ~StreamWriterBuilder() override;
|
|
|
2038
|
|
|
2039 /**
|
|
|
2040 * \throw std::exception if something goes wrong (e.g. invalid settings)
|
|
|
2041 */
|
|
|
2042 StreamWriter* newStreamWriter() const override;
|
|
|
2043
|
|
|
2044 /** \return true if 'settings' are legal and consistent;
|
|
|
2045 * otherwise, indicate bad settings via 'invalid'.
|
|
|
2046 */
|
|
|
2047 bool validate(Json::Value* invalid) const;
|
|
|
2048 /** A simple way to update a specific setting.
|
|
|
2049 */
|
|
|
2050 Value& operator[](const String& key);
|
|
|
2051
|
|
|
2052 /** Called by ctor, but you can use this to reset settings_.
|
|
|
2053 * \pre 'settings' != NULL (but Json::null is fine)
|
|
|
2054 * \remark Defaults:
|
|
|
2055 * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
|
|
|
2056 */
|
|
|
2057 static void setDefaults(Json::Value* settings);
|
|
|
2058 };
|
|
|
2059
|
|
|
2060 /** \brief Abstract class for writers.
|
|
|
2061 * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
|
|
|
2062 */
|
|
|
2063 class JSONCPP_DEPRECATED("Use StreamWriter instead") JSON_API Writer {
|
|
|
2064 public:
|
|
|
2065 virtual ~Writer();
|
|
|
2066
|
|
|
2067 virtual String write(const Value& root) = 0;
|
|
|
2068 };
|
|
|
2069
|
|
|
2070 /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
|
|
|
2071 *without formatting (not human friendly).
|
|
|
2072 *
|
|
|
2073 * The JSON document is written in a single line. It is not intended for 'human'
|
|
|
2074 *consumption,
|
|
|
2075 * but may be useful to support feature such as RPC where bandwidth is limited.
|
|
|
2076 * \sa Reader, Value
|
|
|
2077 * \deprecated Use StreamWriterBuilder.
|
|
|
2078 */
|
|
|
2079 #if defined(_MSC_VER)
|
|
|
2080 #pragma warning(push)
|
|
|
2081 #pragma warning(disable : 4996) // Deriving from deprecated class
|
|
|
2082 #endif
|
|
|
2083 class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API FastWriter
|
|
|
2084 : public Writer {
|
|
|
2085 public:
|
|
|
2086 FastWriter();
|
|
|
2087 ~FastWriter() override = default;
|
|
|
2088
|
|
|
2089 void enableYAMLCompatibility();
|
|
|
2090
|
|
|
2091 /** \brief Drop the "null" string from the writer's output for nullValues.
|
|
|
2092 * Strictly speaking, this is not valid JSON. But when the output is being
|
|
|
2093 * fed to a browser's JavaScript, it makes for smaller output and the
|
|
|
2094 * browser can handle the output just fine.
|
|
|
2095 */
|
|
|
2096 void dropNullPlaceholders();
|
|
|
2097
|
|
|
2098 void omitEndingLineFeed();
|
|
|
2099
|
|
|
2100 public: // overridden from Writer
|
|
|
2101 String write(const Value& root) override;
|
|
|
2102
|
|
|
2103 private:
|
|
|
2104 void writeValue(const Value& value);
|
|
|
2105
|
|
|
2106 String document_;
|
|
|
2107 bool yamlCompatibilityEnabled_{false};
|
|
|
2108 bool dropNullPlaceholders_{false};
|
|
|
2109 bool omitEndingLineFeed_{false};
|
|
|
2110 };
|
|
|
2111 #if defined(_MSC_VER)
|
|
|
2112 #pragma warning(pop)
|
|
|
2113 #endif
|
|
|
2114
|
|
|
2115 /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
|
|
|
2116 *human friendly way.
|
|
|
2117 *
|
|
|
2118 * The rules for line break and indent are as follow:
|
|
|
2119 * - Object value:
|
|
|
2120 * - if empty then print {} without indent and line break
|
|
|
2121 * - if not empty the print '{', line break & indent, print one value per
|
|
|
2122 *line
|
|
|
2123 * and then unindent and line break and print '}'.
|
|
|
2124 * - Array value:
|
|
|
2125 * - if empty then print [] without indent and line break
|
|
|
2126 * - if the array contains no object value, empty array or some other value
|
|
|
2127 *types,
|
|
|
2128 * and all the values fit on one lines, then print the array on a single
|
|
|
2129 *line.
|
|
|
2130 * - otherwise, it the values do not fit on one line, or the array contains
|
|
|
2131 * object or non empty array, then print one value per line.
|
|
|
2132 *
|
|
|
2133 * If the Value have comments then they are outputed according to their
|
|
|
2134 *#CommentPlacement.
|
|
|
2135 *
|
|
|
2136 * \sa Reader, Value, Value::setComment()
|
|
|
2137 * \deprecated Use StreamWriterBuilder.
|
|
|
2138 */
|
|
|
2139 #if defined(_MSC_VER)
|
|
|
2140 #pragma warning(push)
|
|
|
2141 #pragma warning(disable : 4996) // Deriving from deprecated class
|
|
|
2142 #endif
|
|
|
2143 class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API
|
|
|
2144 StyledWriter : public Writer {
|
|
|
2145 public:
|
|
|
2146 StyledWriter();
|
|
|
2147 ~StyledWriter() override = default;
|
|
|
2148
|
|
|
2149 public: // overridden from Writer
|
|
|
2150 /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
|
|
|
2151 * \param root Value to serialize.
|
|
|
2152 * \return String containing the JSON document that represents the root value.
|
|
|
2153 */
|
|
|
2154 String write(const Value& root) override;
|
|
|
2155
|
|
|
2156 private:
|
|
|
2157 void writeValue(const Value& value);
|
|
|
2158 void writeArrayValue(const Value& value);
|
|
|
2159 bool isMultilineArray(const Value& value);
|
|
|
2160 void pushValue(const String& value);
|
|
|
2161 void writeIndent();
|
|
|
2162 void writeWithIndent(const String& value);
|
|
|
2163 void indent();
|
|
|
2164 void unindent();
|
|
|
2165 void writeCommentBeforeValue(const Value& root);
|
|
|
2166 void writeCommentAfterValueOnSameLine(const Value& root);
|
|
|
2167 static bool hasCommentForValue(const Value& value);
|
|
|
2168 static String normalizeEOL(const String& text);
|
|
|
2169
|
|
|
2170 typedef std::vector<String> ChildValues;
|
|
|
2171
|
|
|
2172 ChildValues childValues_;
|
|
|
2173 String document_;
|
|
|
2174 String indentString_;
|
|
|
2175 unsigned int rightMargin_{74};
|
|
|
2176 unsigned int indentSize_{3};
|
|
|
2177 bool addChildValues_{false};
|
|
|
2178 };
|
|
|
2179 #if defined(_MSC_VER)
|
|
|
2180 #pragma warning(pop)
|
|
|
2181 #endif
|
|
|
2182
|
|
|
2183 /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
|
|
|
2184 human friendly way,
|
|
|
2185 to a stream rather than to a string.
|
|
|
2186 *
|
|
|
2187 * The rules for line break and indent are as follow:
|
|
|
2188 * - Object value:
|
|
|
2189 * - if empty then print {} without indent and line break
|
|
|
2190 * - if not empty the print '{', line break & indent, print one value per
|
|
|
2191 line
|
|
|
2192 * and then unindent and line break and print '}'.
|
|
|
2193 * - Array value:
|
|
|
2194 * - if empty then print [] without indent and line break
|
|
|
2195 * - if the array contains no object value, empty array or some other value
|
|
|
2196 types,
|
|
|
2197 * and all the values fit on one lines, then print the array on a single
|
|
|
2198 line.
|
|
|
2199 * - otherwise, it the values do not fit on one line, or the array contains
|
|
|
2200 * object or non empty array, then print one value per line.
|
|
|
2201 *
|
|
|
2202 * If the Value have comments then they are outputed according to their
|
|
|
2203 #CommentPlacement.
|
|
|
2204 *
|
|
|
2205 * \sa Reader, Value, Value::setComment()
|
|
|
2206 * \deprecated Use StreamWriterBuilder.
|
|
|
2207 */
|
|
|
2208 #if defined(_MSC_VER)
|
|
|
2209 #pragma warning(push)
|
|
|
2210 #pragma warning(disable : 4996) // Deriving from deprecated class
|
|
|
2211 #endif
|
|
|
2212 class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API
|
|
|
2213 StyledStreamWriter {
|
|
|
2214 public:
|
|
|
2215 /**
|
|
|
2216 * \param indentation Each level will be indented by this amount extra.
|
|
|
2217 */
|
|
|
2218 StyledStreamWriter(String indentation = "\t");
|
|
|
2219 ~StyledStreamWriter() = default;
|
|
|
2220
|
|
|
2221 public:
|
|
|
2222 /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
|
|
|
2223 * \param out Stream to write to. (Can be ostringstream, e.g.)
|
|
|
2224 * \param root Value to serialize.
|
|
|
2225 * \note There is no point in deriving from Writer, since write() should not
|
|
|
2226 * return a value.
|
|
|
2227 */
|
|
|
2228 void write(OStream& out, const Value& root);
|
|
|
2229
|
|
|
2230 private:
|
|
|
2231 void writeValue(const Value& value);
|
|
|
2232 void writeArrayValue(const Value& value);
|
|
|
2233 bool isMultilineArray(const Value& value);
|
|
|
2234 void pushValue(const String& value);
|
|
|
2235 void writeIndent();
|
|
|
2236 void writeWithIndent(const String& value);
|
|
|
2237 void indent();
|
|
|
2238 void unindent();
|
|
|
2239 void writeCommentBeforeValue(const Value& root);
|
|
|
2240 void writeCommentAfterValueOnSameLine(const Value& root);
|
|
|
2241 static bool hasCommentForValue(const Value& value);
|
|
|
2242 static String normalizeEOL(const String& text);
|
|
|
2243
|
|
|
2244 typedef std::vector<String> ChildValues;
|
|
|
2245
|
|
|
2246 ChildValues childValues_;
|
|
|
2247 OStream* document_;
|
|
|
2248 String indentString_;
|
|
|
2249 unsigned int rightMargin_{74};
|
|
|
2250 String indentation_;
|
|
|
2251 bool addChildValues_ : 1;
|
|
|
2252 bool indented_ : 1;
|
|
|
2253 };
|
|
|
2254 #if defined(_MSC_VER)
|
|
|
2255 #pragma warning(pop)
|
|
|
2256 #endif
|
|
|
2257
|
|
|
2258 #if defined(JSON_HAS_INT64)
|
|
|
2259 String JSON_API valueToString(Int value);
|
|
|
2260 String JSON_API valueToString(UInt value);
|
|
|
2261 #endif // if defined(JSON_HAS_INT64)
|
|
|
2262 String JSON_API valueToString(LargestInt value);
|
|
|
2263 String JSON_API valueToString(LargestUInt value);
|
|
|
2264 String JSON_API
|
|
|
2265 valueToString(double value,
|
|
|
2266 unsigned int precision = Value::defaultRealPrecision,
|
|
|
2267 PrecisionType precisionType = PrecisionType::significantDigits);
|
|
|
2268 String JSON_API valueToString(bool value);
|
|
|
2269 String JSON_API valueToQuotedString(const char* value);
|
|
|
2270
|
|
|
2271 /// \brief Output using the StyledStreamWriter.
|
|
|
2272 /// \see Json::operator>>()
|
|
|
2273 JSON_API OStream& operator<<(OStream&, const Value& root);
|
|
|
2274
|
|
|
2275 } // namespace Json
|
|
|
2276
|
|
|
2277 #pragma pack(pop)
|
|
|
2278
|
|
|
2279 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
2280 #pragma warning(pop)
|
|
|
2281 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
2282
|
|
|
2283 #endif // JSON_WRITER_H_INCLUDED
|
|
|
2284
|
|
|
2285 // //////////////////////////////////////////////////////////////////////
|
|
|
2286 // End of content of file: include/json/writer.h
|
|
|
2287 // //////////////////////////////////////////////////////////////////////
|
|
|
2288
|
|
|
2289
|
|
|
2290
|
|
|
2291
|
|
|
2292
|
|
|
2293
|
|
|
2294 // //////////////////////////////////////////////////////////////////////
|
|
|
2295 // Beginning of content of file: include/json/assertions.h
|
|
|
2296 // //////////////////////////////////////////////////////////////////////
|
|
|
2297
|
|
|
2298 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
|
|
|
2299 // Distributed under MIT license, or public domain if desired and
|
|
|
2300 // recognized in your jurisdiction.
|
|
|
2301 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
2302
|
|
|
2303 #ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
|
|
|
2304 #define CPPTL_JSON_ASSERTIONS_H_INCLUDED
|
|
|
2305
|
|
|
2306 #include <cstdlib>
|
|
|
2307 #include <sstream>
|
|
|
2308
|
|
|
2309 #if !defined(JSON_IS_AMALGAMATION)
|
|
|
2310 #include "config.h"
|
|
|
2311 #endif // if !defined(JSON_IS_AMALGAMATION)
|
|
|
2312
|
|
|
2313 /** It should not be possible for a maliciously designed file to
|
|
|
2314 * cause an abort() or seg-fault, so these macros are used only
|
|
|
2315 * for pre-condition violations and internal logic errors.
|
|
|
2316 */
|
|
|
2317 #if JSON_USE_EXCEPTION
|
|
|
2318
|
|
|
2319 // @todo <= add detail about condition in exception
|
|
|
2320 #define JSON_ASSERT(condition) \
|
|
|
2321 { \
|
|
|
2322 if (!(condition)) { \
|
|
|
2323 Json::throwLogicError("assert json failed"); \
|
|
|
2324 } \
|
|
|
2325 }
|
|
|
2326
|
|
|
2327 #define JSON_FAIL_MESSAGE(message) \
|
|
|
2328 { \
|
|
|
2329 OStringStream oss; \
|
|
|
2330 oss << message; \
|
|
|
2331 Json::throwLogicError(oss.str()); \
|
|
|
2332 abort(); \
|
|
|
2333 }
|
|
|
2334
|
|
|
2335 #else // JSON_USE_EXCEPTION
|
|
|
2336
|
|
|
2337 #define JSON_ASSERT(condition) assert(condition)
|
|
|
2338
|
|
|
2339 // The call to assert() will show the failure message in debug builds. In
|
|
|
2340 // release builds we abort, for a core-dump or debugger.
|
|
|
2341 #define JSON_FAIL_MESSAGE(message) \
|
|
|
2342 { \
|
|
|
2343 OStringStream oss; \
|
|
|
2344 oss << message; \
|
|
|
2345 assert(false && oss.str().c_str()); \
|
|
|
2346 abort(); \
|
|
|
2347 }
|
|
|
2348
|
|
|
2349 #endif
|
|
|
2350
|
|
|
2351 #define JSON_ASSERT_MESSAGE(condition, message) \
|
|
|
2352 if (!(condition)) { \
|
|
|
2353 JSON_FAIL_MESSAGE(message); \
|
|
|
2354 }
|
|
|
2355
|
|
|
2356 #endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED
|
|
|
2357
|
|
|
2358 // //////////////////////////////////////////////////////////////////////
|
|
|
2359 // End of content of file: include/json/assertions.h
|
|
|
2360 // //////////////////////////////////////////////////////////////////////
|
|
|
2361
|
|
|
2362
|
|
|
2363
|
|
|
2364
|
|
|
2365
|
|
|
2366 #endif //ifndef JSON_AMALGAMATED_H_INCLUDED
|
