Line data Source code
1 : /// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).
2 : /// It is intented 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 : The author (Baptiste Lepilleur) explicitly disclaims 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 is
19 : 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
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_AMALGATED_H_INCLUDED
76 : # define JSON_AMALGATED_H_INCLUDED
77 : /// If defined, indicates that the source file is amalgated
78 : /// to prevent private header inclusion.
79 : #define JSON_IS_AMALGAMATION
80 :
81 : // //////////////////////////////////////////////////////////////////////
82 : // Beginning of content of file: include/json/config.h
83 : // //////////////////////////////////////////////////////////////////////
84 :
85 : // Copyright 2007-2010 Baptiste Lepilleur
86 : // Distributed under MIT license, or public domain if desired and
87 : // recognized in your jurisdiction.
88 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
89 :
90 : #ifndef JSON_CONFIG_H_INCLUDED
91 : # define JSON_CONFIG_H_INCLUDED
92 :
93 : /// If defined, indicates that json library is embedded in CppTL library.
94 : //# define JSON_IN_CPPTL 1
95 :
96 : /// If defined, indicates that json may leverage CppTL library
97 : //# define JSON_USE_CPPTL 1
98 : /// If defined, indicates that cpptl vector based map should be used instead of std::map
99 : /// as Value container.
100 : //# define JSON_USE_CPPTL_SMALLMAP 1
101 : /// If defined, indicates that Json specific container should be used
102 : /// (hash table & simple deque container with customizable allocator).
103 : /// THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332
104 : //# define JSON_VALUE_USE_INTERNAL_MAP 1
105 : /// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
106 : /// The memory pools allocator used optimization (initializing Value and ValueInternalLink
107 : /// as if it was a POD) that may cause some validation tool to report errors.
108 : /// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
109 : //# define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
110 :
111 : // If non-zero, the library uses exceptions to report bad input instead of C
112 : // assertion macros. The default is to use exceptions.
113 : # ifndef JSON_USE_EXCEPTION
114 : # define JSON_USE_EXCEPTION 1
115 : # endif
116 :
117 : /// If defined, indicates that the source file is amalgated
118 : /// to prevent private header inclusion.
119 : /// Remarks: it is automatically defined in the generated amalgated header.
120 : // #define JSON_IS_AMALGAMATION
121 :
122 :
123 : # ifdef JSON_IN_CPPTL
124 : # include <cpptl/config.h>
125 : # ifndef JSON_USE_CPPTL
126 : # define JSON_USE_CPPTL 1
127 : # endif
128 : # endif
129 :
130 : # ifdef JSON_IN_CPPTL
131 : # define JSON_API CPPTL_API
132 : # elif defined(JSON_DLL_BUILD)
133 : # define JSON_API __declspec(dllexport)
134 : # elif defined(JSON_DLL)
135 : # define JSON_API __declspec(dllimport)
136 : # else
137 : # define JSON_API
138 : # endif
139 :
140 : // If JSON_NO_INT64 is defined, then Json only support C++ "int" type for integer
141 : // Storages, and 64 bits integer support is disabled.
142 : // #define JSON_NO_INT64 1
143 :
144 : #if defined(_MSC_VER) && _MSC_VER <= 1200 // MSVC 6
145 : // Microsoft Visual Studio 6 only support conversion from __int64 to double
146 : // (no conversion from unsigned __int64).
147 : #define JSON_USE_INT64_DOUBLE_CONVERSION 1
148 : #endif // if defined(_MSC_VER) && _MSC_VER < 1200 // MSVC 6
149 :
150 : #if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
151 : /// Indicates that the following function is deprecated.
152 : # define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
153 : #endif
154 :
155 : #if !defined(JSONCPP_DEPRECATED)
156 : # define JSONCPP_DEPRECATED(message)
157 : #endif // if !defined(JSONCPP_DEPRECATED)
158 :
159 : namespace Json {
160 : typedef int Int;
161 : typedef unsigned int UInt;
162 : # if defined(JSON_NO_INT64)
163 : typedef int LargestInt;
164 : typedef unsigned int LargestUInt;
165 : # undef JSON_HAS_INT64
166 : # else // if defined(JSON_NO_INT64)
167 : // For Microsoft Visual use specific types as long long is not supported
168 : # if defined(_MSC_VER) // Microsoft Visual Studio
169 : typedef __int64 Int64;
170 : typedef unsigned __int64 UInt64;
171 : # else // if defined(_MSC_VER) // Other platforms, use long long
172 : typedef long long int Int64;
173 : typedef unsigned long long int UInt64;
174 : # endif // if defined(_MSC_VER)
175 : typedef Int64 LargestInt;
176 : typedef UInt64 LargestUInt;
177 : # define JSON_HAS_INT64
178 : # endif // if defined(JSON_NO_INT64)
179 : } // end namespace Json
180 :
181 :
182 : #endif // JSON_CONFIG_H_INCLUDED
183 :
184 : // //////////////////////////////////////////////////////////////////////
185 : // End of content of file: include/json/config.h
186 : // //////////////////////////////////////////////////////////////////////
187 :
188 :
189 :
190 :
191 :
192 :
193 : // //////////////////////////////////////////////////////////////////////
194 : // Beginning of content of file: include/json/forwards.h
195 : // //////////////////////////////////////////////////////////////////////
196 :
197 : // Copyright 2007-2010 Baptiste Lepilleur
198 : // Distributed under MIT license, or public domain if desired and
199 : // recognized in your jurisdiction.
200 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
201 :
202 : #ifndef JSON_FORWARDS_H_INCLUDED
203 : # define JSON_FORWARDS_H_INCLUDED
204 :
205 : #if !defined(JSON_IS_AMALGAMATION)
206 : # include "config.h"
207 : #endif // if !defined(JSON_IS_AMALGAMATION)
208 :
209 : namespace Json {
210 :
211 : // writer.h
212 : class FastWriter;
213 : class StyledWriter;
214 :
215 : // reader.h
216 : class Reader;
217 :
218 : // features.h
219 : class Features;
220 :
221 : // value.h
222 : typedef unsigned int ArrayIndex;
223 : class StaticString;
224 : class Path;
225 : class PathArgument;
226 : class Value;
227 : class ValueIteratorBase;
228 : class ValueIterator;
229 : class ValueConstIterator;
230 : #ifdef JSON_VALUE_USE_INTERNAL_MAP
231 : class ValueMapAllocator;
232 : class ValueInternalLink;
233 : class ValueInternalArray;
234 : class ValueInternalMap;
235 : #endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
236 :
237 : } // namespace Json
238 :
239 :
240 : #endif // JSON_FORWARDS_H_INCLUDED
241 :
242 : // //////////////////////////////////////////////////////////////////////
243 : // End of content of file: include/json/forwards.h
244 : // //////////////////////////////////////////////////////////////////////
245 :
246 :
247 :
248 :
249 :
250 :
251 : // //////////////////////////////////////////////////////////////////////
252 : // Beginning of content of file: include/json/features.h
253 : // //////////////////////////////////////////////////////////////////////
254 :
255 : // Copyright 2007-2010 Baptiste Lepilleur
256 : // Distributed under MIT license, or public domain if desired and
257 : // recognized in your jurisdiction.
258 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
259 :
260 : #ifndef CPPTL_JSON_FEATURES_H_INCLUDED
261 : # define CPPTL_JSON_FEATURES_H_INCLUDED
262 :
263 : #if !defined(JSON_IS_AMALGAMATION)
264 : # include "forwards.h"
265 : #endif // if !defined(JSON_IS_AMALGAMATION)
266 :
267 : namespace Json {
268 :
269 : /** \brief Configuration passed to reader and writer.
270 : * This configuration object can be used to force the Reader or Writer
271 : * to behave in a standard conforming way.
272 : */
273 : class JSON_API Features
274 : {
275 : public:
276 : /** \brief A configuration that allows all features and assumes all strings are UTF-8.
277 : * - C & C++ comments are allowed
278 : * - Root object can be any JSON value
279 : * - Assumes Value strings are encoded in UTF-8
280 : */
281 : static Features all();
282 :
283 : /** \brief A configuration that is strictly compatible with the JSON specification.
284 : * - Comments are forbidden.
285 : * - Root object must be either an array or an object value.
286 : * - Assumes Value strings are encoded in UTF-8
287 : */
288 : static Features strictMode();
289 :
290 : /** \brief Initialize the configuration like JsonConfig::allFeatures;
291 : */
292 : Features();
293 :
294 : /// \c true if comments are allowed. Default: \c true.
295 : bool allowComments_;
296 :
297 : /// \c true if root must be either an array or an object value. Default: \c false.
298 : bool strictRoot_;
299 : };
300 :
301 : } // namespace Json
302 :
303 : #endif // CPPTL_JSON_FEATURES_H_INCLUDED
304 :
305 : // //////////////////////////////////////////////////////////////////////
306 : // End of content of file: include/json/features.h
307 : // //////////////////////////////////////////////////////////////////////
308 :
309 :
310 :
311 :
312 :
313 :
314 : // //////////////////////////////////////////////////////////////////////
315 : // Beginning of content of file: include/json/value.h
316 : // //////////////////////////////////////////////////////////////////////
317 :
318 : // Copyright 2007-2010 Baptiste Lepilleur
319 : // Distributed under MIT license, or public domain if desired and
320 : // recognized in your jurisdiction.
321 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
322 :
323 : #ifndef CPPTL_JSON_H_INCLUDED
324 : # define CPPTL_JSON_H_INCLUDED
325 :
326 : #if !defined(JSON_IS_AMALGAMATION)
327 : # include "forwards.h"
328 : #endif // if !defined(JSON_IS_AMALGAMATION)
329 : # include <string>
330 : # include <vector>
331 :
332 : # ifndef JSON_USE_CPPTL_SMALLMAP
333 : # include <map>
334 : # else
335 : # include <cpptl/smallmap.h>
336 : # endif
337 : # ifdef JSON_USE_CPPTL
338 : # include <cpptl/forwards.h>
339 : # endif
340 :
341 : /** \brief JSON (JavaScript Object Notation).
342 : */
343 : namespace Json {
344 :
345 : /** \brief Type of the value held by a Value object.
346 : */
347 : enum ValueType
348 : {
349 : nullValue = 0, ///< 'null' value
350 : intValue, ///< signed integer value
351 : uintValue, ///< unsigned integer value
352 : realValue, ///< double value
353 : stringValue, ///< UTF-8 string value
354 : booleanValue, ///< bool value
355 : arrayValue, ///< array value (ordered list)
356 : objectValue ///< object value (collection of name/value pairs).
357 : };
358 :
359 : enum CommentPlacement
360 : {
361 : commentBefore = 0, ///< a comment placed on the line before a value
362 : commentAfterOnSameLine, ///< a comment just after a value on the same line
363 : commentAfter, ///< a comment on the line after a value (only make sense for root value)
364 : numberOfCommentPlacement
365 : };
366 :
367 : //# ifdef JSON_USE_CPPTL
368 : // typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
369 : // typedef CppTL::AnyEnumerator<const Value &> EnumValues;
370 : //# endif
371 :
372 : /** \brief Lightweight wrapper to tag static string.
373 : *
374 : * Value constructor and objectValue member assignement takes advantage of the
375 : * StaticString and avoid the cost of string duplication when storing the
376 : * string or the member name.
377 : *
378 : * Example of usage:
379 : * \code
380 : * Json::Value aValue( StaticString("some text") );
381 : * Json::Value object;
382 : * static const StaticString code("code");
383 : * object[code] = 1234;
384 : * \endcode
385 : */
386 : class JSON_API StaticString
387 : {
388 : public:
389 : explicit StaticString( const char *czstring )
390 : : str_( czstring )
391 : {
392 : }
393 :
394 : operator const char *() const
395 : {
396 : return str_;
397 : }
398 :
399 : const char *c_str() const
400 : {
401 : return str_;
402 : }
403 :
404 : private:
405 : const char *str_;
406 : };
407 :
408 : /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
409 : *
410 : * This class is a discriminated union wrapper that can represents a:
411 : * - signed integer [range: Value::minInt - Value::maxInt]
412 : * - unsigned integer (range: 0 - Value::maxUInt)
413 : * - double
414 : * - UTF-8 string
415 : * - boolean
416 : * - 'null'
417 : * - an ordered list of Value
418 : * - collection of name/value pairs (javascript object)
419 : *
420 : * The type of the held value is represented by a #ValueType and
421 : * can be obtained using type().
422 : *
423 : * values of an #objectValue or #arrayValue can be accessed using operator[]() methods.
424 : * Non const methods will automatically create the a #nullValue element
425 : * if it does not exist.
426 : * The sequence of an #arrayValue will be automatically resize and initialized
427 : * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
428 : *
429 : * The get() methods can be used to obtanis default value in the case the required element
430 : * does not exist.
431 : *
432 : * It is possible to iterate over the list of a #objectValue values using
433 : * the getMemberNames() method.
434 : */
435 : class JSON_API Value
436 : {
437 : friend class ValueIteratorBase;
438 : # ifdef JSON_VALUE_USE_INTERNAL_MAP
439 : friend class ValueInternalLink;
440 : friend class ValueInternalMap;
441 : # endif
442 : public:
443 : typedef std::vector<std::string> Members;
444 : typedef ValueIterator iterator;
445 : typedef ValueConstIterator const_iterator;
446 : typedef Json::UInt UInt;
447 : typedef Json::Int Int;
448 : # if defined(JSON_HAS_INT64)
449 : typedef Json::UInt64 UInt64;
450 : typedef Json::Int64 Int64;
451 : #endif // defined(JSON_HAS_INT64)
452 : typedef Json::LargestInt LargestInt;
453 : typedef Json::LargestUInt LargestUInt;
454 : typedef Json::ArrayIndex ArrayIndex;
455 :
456 : static const Value null;
457 : /// Minimum signed integer value that can be stored in a Json::Value.
458 : static const LargestInt minLargestInt;
459 : /// Maximum signed integer value that can be stored in a Json::Value.
460 : static const LargestInt maxLargestInt;
461 : /// Maximum unsigned integer value that can be stored in a Json::Value.
462 : static const LargestUInt maxLargestUInt;
463 :
464 : /// Minimum signed int value that can be stored in a Json::Value.
465 : static const Int minInt;
466 : /// Maximum signed int value that can be stored in a Json::Value.
467 : static const Int maxInt;
468 : /// Maximum unsigned int value that can be stored in a Json::Value.
469 : static const UInt maxUInt;
470 :
471 : # if defined(JSON_HAS_INT64)
472 : /// Minimum signed 64 bits int value that can be stored in a Json::Value.
473 : static const Int64 minInt64;
474 : /// Maximum signed 64 bits int value that can be stored in a Json::Value.
475 : static const Int64 maxInt64;
476 : /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
477 : static const UInt64 maxUInt64;
478 : #endif // defined(JSON_HAS_INT64)
479 :
480 : private:
481 : #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
482 : # ifndef JSON_VALUE_USE_INTERNAL_MAP
483 : class CZString
484 : {
485 : public:
486 : enum DuplicationPolicy
487 : {
488 : noDuplication = 0,
489 : duplicate,
490 : duplicateOnCopy
491 : };
492 : CZString( ArrayIndex index );
493 : CZString( const char *cstr, DuplicationPolicy allocate );
494 : CZString( const CZString &other );
495 : ~CZString();
496 : CZString &operator =( const CZString &other );
497 : bool operator<( const CZString &other ) const;
498 : bool operator==( const CZString &other ) const;
499 : ArrayIndex index() const;
500 : const char *c_str() const;
501 : bool isStaticString() const;
502 : private:
503 : void swap( CZString &other );
504 : const char *cstr_;
505 : ArrayIndex index_;
506 : };
507 :
508 : public:
509 : # ifndef JSON_USE_CPPTL_SMALLMAP
510 : typedef std::map<CZString, Value> ObjectValues;
511 : # else
512 : typedef CppTL::SmallMap<CZString, Value> ObjectValues;
513 : # endif // ifndef JSON_USE_CPPTL_SMALLMAP
514 : # endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
515 : #endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
516 :
517 : public:
518 : /** \brief Create a default Value of the given type.
519 :
520 : This is a very useful constructor.
521 : To create an empty array, pass arrayValue.
522 : To create an empty object, pass objectValue.
523 : Another Value can then be set to this one by assignment.
524 : This is useful since clear() and resize() will not alter types.
525 :
526 : Examples:
527 : \code
528 : Json::Value null_value; // null
529 : Json::Value arr_value(Json::arrayValue); // []
530 : Json::Value obj_value(Json::objectValue); // {}
531 : \endcode
532 : */
533 : Value( ValueType type = nullValue );
534 : Value( Int value );
535 : Value( UInt value );
536 : #if defined(JSON_HAS_INT64)
537 : Value( Int64 value );
538 : Value( UInt64 value );
539 : #endif // if defined(JSON_HAS_INT64)
540 : Value( double value );
541 : Value( const char *value );
542 : Value( const char *beginValue, const char *endValue );
543 : /** \brief Constructs a value from a static string.
544 :
545 : * Like other value string constructor but do not duplicate the string for
546 : * internal storage. The given string must remain alive after the call to this
547 : * constructor.
548 : * Example of usage:
549 : * \code
550 : * Json::Value aValue( StaticString("some text") );
551 : * \endcode
552 : */
553 : Value( const StaticString &value );
554 : Value( const std::string &value );
555 : # ifdef JSON_USE_CPPTL
556 : Value( const CppTL::ConstString &value );
557 : # endif
558 : Value( bool value );
559 : Value( const Value &other );
560 : ~Value();
561 :
562 : Value &operator=( const Value &other );
563 : /// Swap values.
564 : /// \note Currently, comments are intentionally not swapped, for
565 : /// both logic and efficiency.
566 : void swap( Value &other );
567 :
568 : ValueType type() const;
569 :
570 : bool operator <( const Value &other ) const;
571 : bool operator <=( const Value &other ) const;
572 : bool operator >=( const Value &other ) const;
573 : bool operator >( const Value &other ) const;
574 :
575 : bool operator ==( const Value &other ) const;
576 : bool operator !=( const Value &other ) const;
577 :
578 : int compare( const Value &other ) const;
579 :
580 : const char *asCString() const;
581 : std::string asString() const;
582 : # ifdef JSON_USE_CPPTL
583 : CppTL::ConstString asConstString() const;
584 : # endif
585 : Int asInt() const;
586 : UInt asUInt() const;
587 : #if defined(JSON_HAS_INT64)
588 : Int64 asInt64() const;
589 : UInt64 asUInt64() const;
590 : #endif // if defined(JSON_HAS_INT64)
591 : LargestInt asLargestInt() const;
592 : LargestUInt asLargestUInt() const;
593 : float asFloat() const;
594 : double asDouble() const;
595 : bool asBool() const;
596 :
597 : bool isNull() const;
598 : bool isBool() const;
599 : bool isInt() const;
600 : bool isInt64() const;
601 : bool isUInt() const;
602 : bool isUInt64() const;
603 : bool isIntegral() const;
604 : bool isDouble() const;
605 : bool isNumeric() const;
606 : bool isString() const;
607 : bool isArray() const;
608 : bool isObject() const;
609 :
610 : bool isConvertibleTo( ValueType other ) const;
611 :
612 : /// Number of values in array or object
613 : ArrayIndex size() const;
614 :
615 : /// \brief Return true if empty array, empty object, or null;
616 : /// otherwise, false.
617 : bool empty() const;
618 :
619 : /// Return isNull()
620 : bool operator!() const;
621 :
622 : /// Remove all object members and array elements.
623 : /// \pre type() is arrayValue, objectValue, or nullValue
624 : /// \post type() is unchanged
625 : void clear();
626 :
627 : /// Resize the array to size elements.
628 : /// New elements are initialized to null.
629 : /// May only be called on nullValue or arrayValue.
630 : /// \pre type() is arrayValue or nullValue
631 : /// \post type() is arrayValue
632 : void resize( ArrayIndex size );
633 :
634 : /// Access an array element (zero based index ).
635 : /// If the array contains less than index element, then null value are inserted
636 : /// in the array so that its size is index+1.
637 : /// (You may need to say 'value[0u]' to get your compiler to distinguish
638 : /// this from the operator[] which takes a string.)
639 : Value &operator[]( ArrayIndex index );
640 :
641 : /// Access an array element (zero based index ).
642 : /// If the array contains less than index element, then null value are inserted
643 : /// in the array so that its size is index+1.
644 : /// (You may need to say 'value[0u]' to get your compiler to distinguish
645 : /// this from the operator[] which takes a string.)
646 : Value &operator[]( int index );
647 :
648 : /// Access an array element (zero based index )
649 : /// (You may need to say 'value[0u]' to get your compiler to distinguish
650 : /// this from the operator[] which takes a string.)
651 : const Value &operator[]( ArrayIndex index ) const;
652 :
653 : /// Access an array element (zero based index )
654 : /// (You may need to say 'value[0u]' to get your compiler to distinguish
655 : /// this from the operator[] which takes a string.)
656 : const Value &operator[]( int index ) const;
657 :
658 : /// If the array contains at least index+1 elements, returns the element value,
659 : /// otherwise returns defaultValue.
660 : Value get( ArrayIndex index,
661 : const Value &defaultValue ) const;
662 : /// Return true if index < size().
663 : bool isValidIndex( ArrayIndex index ) const;
664 : /// \brief Append value to array at the end.
665 : ///
666 : /// Equivalent to jsonvalue[jsonvalue.size()] = value;
667 : Value &append( const Value &value );
668 :
669 : /// Access an object value by name, create a null member if it does not exist.
670 : Value &operator[]( const char *key );
671 : /// Access an object value by name, returns null if there is no member with that name.
672 : const Value &operator[]( const char *key ) const;
673 : /// Access an object value by name, create a null member if it does not exist.
674 : Value &operator[]( const std::string &key );
675 : /// Access an object value by name, returns null if there is no member with that name.
676 : const Value &operator[]( const std::string &key ) const;
677 : /** \brief Access an object value by name, create a null member if it does not exist.
678 :
679 : * If the object as no entry for that name, then the member name used to store
680 : * the new entry is not duplicated.
681 : * Example of use:
682 : * \code
683 : * Json::Value object;
684 : * static const StaticString code("code");
685 : * object[code] = 1234;
686 : * \endcode
687 : */
688 : Value &operator[]( const StaticString &key );
689 : # ifdef JSON_USE_CPPTL
690 : /// Access an object value by name, create a null member if it does not exist.
691 : Value &operator[]( const CppTL::ConstString &key );
692 : /// Access an object value by name, returns null if there is no member with that name.
693 : const Value &operator[]( const CppTL::ConstString &key ) const;
694 : # endif
695 : /// Return the member named key if it exist, defaultValue otherwise.
696 : Value get( const char *key,
697 : const Value &defaultValue ) const;
698 : /// Return the member named key if it exist, defaultValue otherwise.
699 : Value get( const std::string &key,
700 : const Value &defaultValue ) const;
701 : # ifdef JSON_USE_CPPTL
702 : /// Return the member named key if it exist, defaultValue otherwise.
703 : Value get( const CppTL::ConstString &key,
704 : const Value &defaultValue ) const;
705 : # endif
706 : /// \brief Remove and return the named member.
707 : ///
708 : /// Do nothing if it did not exist.
709 : /// \return the removed Value, or null.
710 : /// \pre type() is objectValue or nullValue
711 : /// \post type() is unchanged
712 : Value removeMember( const char* key );
713 : /// Same as removeMember(const char*)
714 : Value removeMember( const std::string &key );
715 :
716 : /// Return true if the object has a member named key.
717 : bool isMember( const char *key ) const;
718 : /// Return true if the object has a member named key.
719 : bool isMember( const std::string &key ) const;
720 : # ifdef JSON_USE_CPPTL
721 : /// Return true if the object has a member named key.
722 : bool isMember( const CppTL::ConstString &key ) const;
723 : # endif
724 :
725 : /// \brief Return a list of the member names.
726 : ///
727 : /// If null, return an empty list.
728 : /// \pre type() is objectValue or nullValue
729 : /// \post if type() was nullValue, it remains nullValue
730 : Members getMemberNames() const;
731 :
732 : //# ifdef JSON_USE_CPPTL
733 : // EnumMemberNames enumMemberNames() const;
734 : // EnumValues enumValues() const;
735 : //# endif
736 :
737 : /// Comments must be //... or /* ... */
738 : void setComment( const char *comment,
739 : CommentPlacement placement );
740 : /// Comments must be //... or /* ... */
741 : void setComment( const std::string &comment,
742 : CommentPlacement placement );
743 : bool hasComment( CommentPlacement placement ) const;
744 : /// Include delimiters and embedded newlines.
745 : std::string getComment( CommentPlacement placement ) const;
746 :
747 : std::string toStyledString() const;
748 :
749 : const_iterator begin() const;
750 : const_iterator end() const;
751 :
752 : iterator begin();
753 : iterator end();
754 :
755 : private:
756 : Value &resolveReference( const char *key,
757 : bool isStatic );
758 :
759 : # ifdef JSON_VALUE_USE_INTERNAL_MAP
760 : inline bool isItemAvailable() const
761 : {
762 : return itemIsUsed_ == 0;
763 : }
764 :
765 : inline void setItemUsed( bool isUsed = true )
766 : {
767 : itemIsUsed_ = isUsed ? 1 : 0;
768 : }
769 :
770 : inline bool isMemberNameStatic() const
771 : {
772 : return memberNameIsStatic_ == 0;
773 : }
774 :
775 : inline void setMemberNameIsStatic( bool isStatic )
776 : {
777 : memberNameIsStatic_ = isStatic ? 1 : 0;
778 : }
779 : # endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
780 :
781 : private:
782 : struct CommentInfo
783 : {
784 : CommentInfo();
785 : ~CommentInfo();
786 :
787 : void setComment( const char *text );
788 :
789 : char *comment_;
790 : };
791 :
792 : //struct MemberNamesTransform
793 : //{
794 : // typedef const char *result_type;
795 : // const char *operator()( const CZString &name ) const
796 : // {
797 : // return name.c_str();
798 : // }
799 : //};
800 :
801 : union ValueHolder
802 : {
803 : LargestInt int_;
804 : LargestUInt uint_;
805 : double real_;
806 : bool bool_;
807 : char *string_;
808 : # ifdef JSON_VALUE_USE_INTERNAL_MAP
809 : ValueInternalArray *array_;
810 : ValueInternalMap *map_;
811 : #else
812 : ObjectValues *map_;
813 : # endif
814 : } value_;
815 : ValueType type_ : 8;
816 : int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
817 : # ifdef JSON_VALUE_USE_INTERNAL_MAP
818 : unsigned int itemIsUsed_ : 1; // used by the ValueInternalMap container.
819 : int memberNameIsStatic_ : 1; // used by the ValueInternalMap container.
820 : # endif
821 : CommentInfo *comments_;
822 : };
823 :
824 :
825 : /** \brief Experimental and untested: represents an element of the "path" to access a node.
826 : */
827 : class PathArgument
828 : {
829 : public:
830 : friend class Path;
831 :
832 : PathArgument();
833 : PathArgument( ArrayIndex index );
834 : PathArgument( const char *key );
835 : PathArgument( const std::string &key );
836 :
837 : private:
838 : enum Kind
839 : {
840 : kindNone = 0,
841 : kindIndex,
842 : kindKey
843 : };
844 : std::string key_;
845 : ArrayIndex index_;
846 : Kind kind_;
847 : };
848 :
849 : /** \brief Experimental and untested: represents a "path" to access a node.
850 : *
851 : * Syntax:
852 : * - "." => root node
853 : * - ".[n]" => elements at index 'n' of root node (an array value)
854 : * - ".name" => member named 'name' of root node (an object value)
855 : * - ".name1.name2.name3"
856 : * - ".[0][1][2].name1[3]"
857 : * - ".%" => member name is provided as parameter
858 : * - ".[%]" => index is provied as parameter
859 : */
860 : class Path
861 : {
862 : public:
863 : Path( const std::string &path,
864 : const PathArgument &a1 = PathArgument(),
865 : const PathArgument &a2 = PathArgument(),
866 : const PathArgument &a3 = PathArgument(),
867 : const PathArgument &a4 = PathArgument(),
868 : const PathArgument &a5 = PathArgument() );
869 :
870 : const Value &resolve( const Value &root ) const;
871 : Value resolve( const Value &root,
872 : const Value &defaultValue ) const;
873 : /// Creates the "path" to access the specified node and returns a reference on the node.
874 : Value &make( Value &root ) const;
875 :
876 : private:
877 : typedef std::vector<const PathArgument *> InArgs;
878 : typedef std::vector<PathArgument> Args;
879 :
880 : void makePath( const std::string &path,
881 : const InArgs &in );
882 : void addPathInArg( const std::string &path,
883 : const InArgs &in,
884 : InArgs::const_iterator &itInArg,
885 : PathArgument::Kind kind );
886 : void invalidPath( const std::string &path,
887 : int location );
888 :
889 : Args args_;
890 : };
891 :
892 :
893 :
894 : #ifdef JSON_VALUE_USE_INTERNAL_MAP
895 : /** \brief Allocator to customize Value internal map.
896 : * Below is an example of a simple implementation (default implementation actually
897 : * use memory pool for speed).
898 : * \code
899 : class DefaultValueMapAllocator : public ValueMapAllocator
900 : {
901 : public: // overridden from ValueMapAllocator
902 : virtual ValueInternalMap *newMap()
903 : {
904 : return new ValueInternalMap();
905 : }
906 :
907 : virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
908 : {
909 : return new ValueInternalMap( other );
910 : }
911 :
912 : virtual void destructMap( ValueInternalMap *map )
913 : {
914 : delete map;
915 : }
916 :
917 : virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
918 : {
919 : return new ValueInternalLink[size];
920 : }
921 :
922 : virtual void releaseMapBuckets( ValueInternalLink *links )
923 : {
924 : delete [] links;
925 : }
926 :
927 : virtual ValueInternalLink *allocateMapLink()
928 : {
929 : return new ValueInternalLink();
930 : }
931 :
932 : virtual void releaseMapLink( ValueInternalLink *link )
933 : {
934 : delete link;
935 : }
936 : };
937 : * \endcode
938 : */
939 : class JSON_API ValueMapAllocator
940 : {
941 : public:
942 : virtual ~ValueMapAllocator();
943 : virtual ValueInternalMap *newMap() = 0;
944 : virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
945 : virtual void destructMap( ValueInternalMap *map ) = 0;
946 : virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
947 : virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
948 : virtual ValueInternalLink *allocateMapLink() = 0;
949 : virtual void releaseMapLink( ValueInternalLink *link ) = 0;
950 : };
951 :
952 : /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
953 : * \internal previous_ & next_ allows for bidirectional traversal.
954 : */
955 : class JSON_API ValueInternalLink
956 : {
957 : public:
958 : enum { itemPerLink = 6 }; // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
959 : enum InternalFlags {
960 : flagAvailable = 0,
961 : flagUsed = 1
962 : };
963 :
964 : ValueInternalLink();
965 :
966 : ~ValueInternalLink();
967 :
968 : Value items_[itemPerLink];
969 : char *keys_[itemPerLink];
970 : ValueInternalLink *previous_;
971 : ValueInternalLink *next_;
972 : };
973 :
974 :
975 : /** \brief A linked page based hash-table implementation used internally by Value.
976 : * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
977 : * list in each bucket to handle collision. There is an addional twist in that
978 : * each node of the collision linked list is a page containing a fixed amount of
979 : * value. This provides a better compromise between memory usage and speed.
980 : *
981 : * Each bucket is made up of a chained list of ValueInternalLink. The last
982 : * link of a given bucket can be found in the 'previous_' field of the following bucket.
983 : * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
984 : * Only the last link of a bucket may contains 'available' item. The last link always
985 : * contains at least one element unless is it the bucket one very first link.
986 : */
987 : class JSON_API ValueInternalMap
988 : {
989 : friend class ValueIteratorBase;
990 : friend class Value;
991 : public:
992 : typedef unsigned int HashKey;
993 : typedef unsigned int BucketIndex;
994 :
995 : # ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
996 : struct IteratorState
997 : {
998 : IteratorState()
999 : : map_(0)
1000 : , link_(0)
1001 : , itemIndex_(0)
1002 : , bucketIndex_(0)
1003 : {
1004 : }
1005 : ValueInternalMap *map_;
1006 : ValueInternalLink *link_;
1007 : BucketIndex itemIndex_;
1008 : BucketIndex bucketIndex_;
1009 : };
1010 : # endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
1011 :
1012 : ValueInternalMap();
1013 : ValueInternalMap( const ValueInternalMap &other );
1014 : ValueInternalMap &operator =( const ValueInternalMap &other );
1015 : ~ValueInternalMap();
1016 :
1017 : void swap( ValueInternalMap &other );
1018 :
1019 : BucketIndex size() const;
1020 :
1021 : void clear();
1022 :
1023 : bool reserveDelta( BucketIndex growth );
1024 :
1025 : bool reserve( BucketIndex newItemCount );
1026 :
1027 : const Value *find( const char *key ) const;
1028 :
1029 : Value *find( const char *key );
1030 :
1031 : Value &resolveReference( const char *key,
1032 : bool isStatic );
1033 :
1034 : void remove( const char *key );
1035 :
1036 : void doActualRemove( ValueInternalLink *link,
1037 : BucketIndex index,
1038 : BucketIndex bucketIndex );
1039 :
1040 : ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );
1041 :
1042 : Value &setNewItem( const char *key,
1043 : bool isStatic,
1044 : ValueInternalLink *link,
1045 : BucketIndex index );
1046 :
1047 : Value &unsafeAdd( const char *key,
1048 : bool isStatic,
1049 : HashKey hashedKey );
1050 :
1051 : HashKey hash( const char *key ) const;
1052 :
1053 : int compare( const ValueInternalMap &other ) const;
1054 :
1055 : private:
1056 : void makeBeginIterator( IteratorState &it ) const;
1057 : void makeEndIterator( IteratorState &it ) const;
1058 : static bool equals( const IteratorState &x, const IteratorState &other );
1059 : static void increment( IteratorState &iterator );
1060 : static void incrementBucket( IteratorState &iterator );
1061 : static void decrement( IteratorState &iterator );
1062 : static const char *key( const IteratorState &iterator );
1063 : static const char *key( const IteratorState &iterator, bool &isStatic );
1064 : static Value &value( const IteratorState &iterator );
1065 : static int distance( const IteratorState &x, const IteratorState &y );
1066 :
1067 : private:
1068 : ValueInternalLink *buckets_;
1069 : ValueInternalLink *tailLink_;
1070 : BucketIndex bucketsSize_;
1071 : BucketIndex itemCount_;
1072 : };
1073 :
1074 : /** \brief A simplified deque implementation used internally by Value.
1075 : * \internal
1076 : * It is based on a list of fixed "page", each page contains a fixed number of items.
1077 : * Instead of using a linked-list, a array of pointer is used for fast item look-up.
1078 : * Look-up for an element is as follow:
1079 : * - compute page index: pageIndex = itemIndex / itemsPerPage
1080 : * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
1081 : *
1082 : * Insertion is amortized constant time (only the array containing the index of pointers
1083 : * need to be reallocated when items are appended).
1084 : */
1085 : class JSON_API ValueInternalArray
1086 : {
1087 : friend class Value;
1088 : friend class ValueIteratorBase;
1089 : public:
1090 : enum { itemsPerPage = 8 }; // should be a power of 2 for fast divide and modulo.
1091 : typedef Value::ArrayIndex ArrayIndex;
1092 : typedef unsigned int PageIndex;
1093 :
1094 : # ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
1095 : struct IteratorState // Must be a POD
1096 : {
1097 : IteratorState()
1098 : : array_(0)
1099 : , currentPageIndex_(0)
1100 : , currentItemIndex_(0)
1101 : {
1102 : }
1103 : ValueInternalArray *array_;
1104 : Value **currentPageIndex_;
1105 : unsigned int currentItemIndex_;
1106 : };
1107 : # endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
1108 :
1109 : ValueInternalArray();
1110 : ValueInternalArray( const ValueInternalArray &other );
1111 : ValueInternalArray &operator =( const ValueInternalArray &other );
1112 : ~ValueInternalArray();
1113 : void swap( ValueInternalArray &other );
1114 :
1115 : void clear();
1116 : void resize( ArrayIndex newSize );
1117 :
1118 : Value &resolveReference( ArrayIndex index );
1119 :
1120 : Value *find( ArrayIndex index ) const;
1121 :
1122 : ArrayIndex size() const;
1123 :
1124 : int compare( const ValueInternalArray &other ) const;
1125 :
1126 : private:
1127 : static bool equals( const IteratorState &x, const IteratorState &other );
1128 : static void increment( IteratorState &iterator );
1129 : static void decrement( IteratorState &iterator );
1130 : static Value &dereference( const IteratorState &iterator );
1131 : static Value &unsafeDereference( const IteratorState &iterator );
1132 : static int distance( const IteratorState &x, const IteratorState &y );
1133 : static ArrayIndex indexOf( const IteratorState &iterator );
1134 : void makeBeginIterator( IteratorState &it ) const;
1135 : void makeEndIterator( IteratorState &it ) const;
1136 : void makeIterator( IteratorState &it, ArrayIndex index ) const;
1137 :
1138 : void makeIndexValid( ArrayIndex index );
1139 :
1140 : Value **pages_;
1141 : ArrayIndex size_;
1142 : PageIndex pageCount_;
1143 : };
1144 :
1145 : /** \brief Experimental: do not use. Allocator to customize Value internal array.
1146 : * Below is an example of a simple implementation (actual implementation use
1147 : * memory pool).
1148 : \code
1149 : class DefaultValueArrayAllocator : public ValueArrayAllocator
1150 : {
1151 : public: // overridden from ValueArrayAllocator
1152 : virtual ~DefaultValueArrayAllocator()
1153 : {
1154 : }
1155 :
1156 : virtual ValueInternalArray *newArray()
1157 : {
1158 : return new ValueInternalArray();
1159 : }
1160 :
1161 : virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
1162 : {
1163 : return new ValueInternalArray( other );
1164 : }
1165 :
1166 : virtual void destruct( ValueInternalArray *array )
1167 : {
1168 : delete array;
1169 : }
1170 :
1171 : virtual void reallocateArrayPageIndex( Value **&indexes,
1172 : ValueInternalArray::PageIndex &indexCount,
1173 : ValueInternalArray::PageIndex minNewIndexCount )
1174 : {
1175 : ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
1176 : if ( minNewIndexCount > newIndexCount )
1177 : newIndexCount = minNewIndexCount;
1178 : void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
1179 : if ( !newIndexes )
1180 : throw std::bad_alloc();
1181 : indexCount = newIndexCount;
1182 : indexes = static_cast<Value **>( newIndexes );
1183 : }
1184 : virtual void releaseArrayPageIndex( Value **indexes,
1185 : ValueInternalArray::PageIndex indexCount )
1186 : {
1187 : if ( indexes )
1188 : free( indexes );
1189 : }
1190 :
1191 : virtual Value *allocateArrayPage()
1192 : {
1193 : return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
1194 : }
1195 :
1196 : virtual void releaseArrayPage( Value *value )
1197 : {
1198 : if ( value )
1199 : free( value );
1200 : }
1201 : };
1202 : \endcode
1203 : */
1204 : class JSON_API ValueArrayAllocator
1205 : {
1206 : public:
1207 : virtual ~ValueArrayAllocator();
1208 : virtual ValueInternalArray *newArray() = 0;
1209 : virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
1210 : virtual void destructArray( ValueInternalArray *array ) = 0;
1211 : /** \brief Reallocate array page index.
1212 : * Reallocates an array of pointer on each page.
1213 : * \param indexes [input] pointer on the current index. May be \c NULL.
1214 : * [output] pointer on the new index of at least
1215 : * \a minNewIndexCount pages.
1216 : * \param indexCount [input] current number of pages in the index.
1217 : * [output] number of page the reallocated index can handle.
1218 : * \b MUST be >= \a minNewIndexCount.
1219 : * \param minNewIndexCount Minimum number of page the new index must be able to
1220 : * handle.
1221 : */
1222 : virtual void reallocateArrayPageIndex( Value **&indexes,
1223 : ValueInternalArray::PageIndex &indexCount,
1224 : ValueInternalArray::PageIndex minNewIndexCount ) = 0;
1225 : virtual void releaseArrayPageIndex( Value **indexes,
1226 : ValueInternalArray::PageIndex indexCount ) = 0;
1227 : virtual Value *allocateArrayPage() = 0;
1228 : virtual void releaseArrayPage( Value *value ) = 0;
1229 : };
1230 : #endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
1231 :
1232 :
1233 : /** \brief base class for Value iterators.
1234 : *
1235 : */
1236 : class ValueIteratorBase
1237 : {
1238 : public:
1239 : typedef unsigned int size_t;
1240 : typedef int difference_type;
1241 : typedef ValueIteratorBase SelfType;
1242 :
1243 : ValueIteratorBase();
1244 : #ifndef JSON_VALUE_USE_INTERNAL_MAP
1245 : explicit ValueIteratorBase( const Value::ObjectValues::iterator ¤t );
1246 : #else
1247 : ValueIteratorBase( const ValueInternalArray::IteratorState &state );
1248 : ValueIteratorBase( const ValueInternalMap::IteratorState &state );
1249 : #endif
1250 :
1251 : bool operator ==( const SelfType &other ) const
1252 : {
1253 : return isEqual( other );
1254 : }
1255 :
1256 0 : bool operator !=( const SelfType &other ) const
1257 : {
1258 0 : return !isEqual( other );
1259 : }
1260 :
1261 : difference_type operator -( const SelfType &other ) const
1262 : {
1263 : return computeDistance( other );
1264 : }
1265 :
1266 : /// Return either the index or the member name of the referenced value as a Value.
1267 : Value key() const;
1268 :
1269 : /// Return the index of the referenced Value. -1 if it is not an arrayValue.
1270 : UInt index() const;
1271 :
1272 : /// Return the member name of the referenced Value. "" if it is not an objectValue.
1273 : const char *memberName() const;
1274 :
1275 : protected:
1276 : Value &deref() const;
1277 :
1278 : void increment();
1279 :
1280 : void decrement();
1281 :
1282 : difference_type computeDistance( const SelfType &other ) const;
1283 :
1284 : bool isEqual( const SelfType &other ) const;
1285 :
1286 : void copy( const SelfType &other );
1287 :
1288 : private:
1289 : #ifndef JSON_VALUE_USE_INTERNAL_MAP
1290 : Value::ObjectValues::iterator current_;
1291 : // Indicates that iterator is for a null value.
1292 : bool isNull_;
1293 : #else
1294 : union
1295 : {
1296 : ValueInternalArray::IteratorState array_;
1297 : ValueInternalMap::IteratorState map_;
1298 : } iterator_;
1299 : bool isArray_;
1300 : #endif
1301 : };
1302 :
1303 : /** \brief const iterator for object and array value.
1304 : *
1305 : */
1306 : class ValueConstIterator : public ValueIteratorBase
1307 : {
1308 : friend class Value;
1309 : public:
1310 : typedef unsigned int size_t;
1311 : typedef int difference_type;
1312 : typedef const Value &reference;
1313 : typedef const Value *pointer;
1314 : typedef ValueConstIterator SelfType;
1315 :
1316 : ValueConstIterator();
1317 : private:
1318 : /*! \internal Use by Value to create an iterator.
1319 : */
1320 : #ifndef JSON_VALUE_USE_INTERNAL_MAP
1321 : explicit ValueConstIterator( const Value::ObjectValues::iterator ¤t );
1322 : #else
1323 : ValueConstIterator( const ValueInternalArray::IteratorState &state );
1324 : ValueConstIterator( const ValueInternalMap::IteratorState &state );
1325 : #endif
1326 : public:
1327 : SelfType &operator =( const ValueIteratorBase &other );
1328 :
1329 : SelfType operator++( int )
1330 : {
1331 : SelfType temp( *this );
1332 : ++*this;
1333 : return temp;
1334 : }
1335 :
1336 : SelfType operator--( int )
1337 : {
1338 : SelfType temp( *this );
1339 : --*this;
1340 : return temp;
1341 : }
1342 :
1343 : SelfType &operator--()
1344 : {
1345 : decrement();
1346 : return *this;
1347 : }
1348 :
1349 0 : SelfType &operator++()
1350 : {
1351 0 : increment();
1352 0 : return *this;
1353 : }
1354 :
1355 0 : reference operator *() const
1356 : {
1357 0 : return deref();
1358 : }
1359 : };
1360 :
1361 :
1362 : /** \brief Iterator for object and array value.
1363 : */
1364 : class ValueIterator : public ValueIteratorBase
1365 : {
1366 : friend class Value;
1367 : public:
1368 : typedef unsigned int size_t;
1369 : typedef int difference_type;
1370 : typedef Value &reference;
1371 : typedef Value *pointer;
1372 : typedef ValueIterator SelfType;
1373 :
1374 : ValueIterator();
1375 : ValueIterator( const ValueConstIterator &other );
1376 : ValueIterator( const ValueIterator &other );
1377 : private:
1378 : /*! \internal Use by Value to create an iterator.
1379 : */
1380 : #ifndef JSON_VALUE_USE_INTERNAL_MAP
1381 : explicit ValueIterator( const Value::ObjectValues::iterator ¤t );
1382 : #else
1383 : ValueIterator( const ValueInternalArray::IteratorState &state );
1384 : ValueIterator( const ValueInternalMap::IteratorState &state );
1385 : #endif
1386 : public:
1387 :
1388 : SelfType &operator =( const SelfType &other );
1389 :
1390 : SelfType operator++( int )
1391 : {
1392 : SelfType temp( *this );
1393 : ++*this;
1394 : return temp;
1395 : }
1396 :
1397 : SelfType operator--( int )
1398 : {
1399 : SelfType temp( *this );
1400 : --*this;
1401 : return temp;
1402 : }
1403 :
1404 : SelfType &operator--()
1405 : {
1406 : decrement();
1407 : return *this;
1408 : }
1409 :
1410 : SelfType &operator++()
1411 : {
1412 : increment();
1413 : return *this;
1414 : }
1415 :
1416 : reference operator *() const
1417 : {
1418 : return deref();
1419 : }
1420 : };
1421 :
1422 :
1423 : } // namespace Json
1424 :
1425 :
1426 : #endif // CPPTL_JSON_H_INCLUDED
1427 :
1428 : // //////////////////////////////////////////////////////////////////////
1429 : // End of content of file: include/json/value.h
1430 : // //////////////////////////////////////////////////////////////////////
1431 :
1432 :
1433 :
1434 :
1435 :
1436 :
1437 : // //////////////////////////////////////////////////////////////////////
1438 : // Beginning of content of file: include/json/reader.h
1439 : // //////////////////////////////////////////////////////////////////////
1440 :
1441 : // Copyright 2007-2010 Baptiste Lepilleur
1442 : // Distributed under MIT license, or public domain if desired and
1443 : // recognized in your jurisdiction.
1444 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
1445 :
1446 : #ifndef CPPTL_JSON_READER_H_INCLUDED
1447 : # define CPPTL_JSON_READER_H_INCLUDED
1448 :
1449 : #if !defined(JSON_IS_AMALGAMATION)
1450 : # include "features.h"
1451 : # include "value.h"
1452 : #endif // if !defined(JSON_IS_AMALGAMATION)
1453 : # include <deque>
1454 : # include <stack>
1455 : # include <string>
1456 :
1457 : namespace Json {
1458 :
1459 : /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a Value.
1460 : *
1461 : */
1462 0 : class JSON_API Reader
1463 : {
1464 : public:
1465 : typedef char Char;
1466 : typedef const Char *Location;
1467 :
1468 : /** \brief Constructs a Reader allowing all features
1469 : * for parsing.
1470 : */
1471 : Reader();
1472 :
1473 : /** \brief Constructs a Reader allowing the specified feature set
1474 : * for parsing.
1475 : */
1476 : Reader( const Features &features );
1477 :
1478 : /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
1479 : * \param document UTF-8 encoded string containing the document to read.
1480 : * \param root [out] Contains the root value of the document if it was
1481 : * successfully parsed.
1482 : * \param collectComments \c true to collect comment and allow writing them back during
1483 : * serialization, \c false to discard comments.
1484 : * This parameter is ignored if Features::allowComments_
1485 : * is \c false.
1486 : * \return \c true if the document was successfully parsed, \c false if an error occurred.
1487 : */
1488 : bool parse( const std::string &document,
1489 : Value &root,
1490 : bool collectComments = true );
1491 :
1492 : /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
1493 : * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the document to read.
1494 : * \param endDoc Pointer on the end of the UTF-8 encoded string of the document to read.
1495 : \ Must be >= beginDoc.
1496 : * \param root [out] Contains the root value of the document if it was
1497 : * successfully parsed.
1498 : * \param collectComments \c true to collect comment and allow writing them back during
1499 : * serialization, \c false to discard comments.
1500 : * This parameter is ignored if Features::allowComments_
1501 : * is \c false.
1502 : * \return \c true if the document was successfully parsed, \c false if an error occurred.
1503 : */
1504 : bool parse( const char *beginDoc, const char *endDoc,
1505 : Value &root,
1506 : bool collectComments = true );
1507 :
1508 : /// \brief Parse from input stream.
1509 : /// \see Json::operator>>(std::istream&, Json::Value&).
1510 : bool parse( std::istream &is,
1511 : Value &root,
1512 : bool collectComments = true );
1513 :
1514 : /** \brief Returns a user friendly string that list errors in the parsed document.
1515 : * \return Formatted error message with the list of errors with their location in
1516 : * the parsed document. An empty string is returned if no error occurred
1517 : * during parsing.
1518 : * \deprecated Use getFormattedErrorMessages() instead (typo fix).
1519 : */
1520 : JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead")
1521 : std::string getFormatedErrorMessages() const;
1522 :
1523 : /** \brief Returns a user friendly string that list errors in the parsed document.
1524 : * \return Formatted error message with the list of errors with their location in
1525 : * the parsed document. An empty string is returned if no error occurred
1526 : * during parsing.
1527 : */
1528 : std::string getFormattedErrorMessages() const;
1529 :
1530 : private:
1531 : enum TokenType
1532 : {
1533 : tokenEndOfStream = 0,
1534 : tokenObjectBegin,
1535 : tokenObjectEnd,
1536 : tokenArrayBegin,
1537 : tokenArrayEnd,
1538 : tokenString,
1539 : tokenNumber,
1540 : tokenTrue,
1541 : tokenFalse,
1542 : tokenNull,
1543 : tokenArraySeparator,
1544 : tokenMemberSeparator,
1545 : tokenComment,
1546 : tokenError
1547 : };
1548 :
1549 : class Token
1550 : {
1551 : public:
1552 : TokenType type_;
1553 : Location start_;
1554 : Location end_;
1555 : };
1556 :
1557 0 : class ErrorInfo
1558 : {
1559 : public:
1560 : Token token_;
1561 : std::string message_;
1562 : Location extra_;
1563 : };
1564 :
1565 : typedef std::deque<ErrorInfo> Errors;
1566 :
1567 : bool expectToken( TokenType type, Token &token, const char *message );
1568 : bool readToken( Token &token );
1569 : void skipSpaces();
1570 : bool match( Location pattern,
1571 : int patternLength );
1572 : bool readComment();
1573 : bool readCStyleComment();
1574 : bool readCppStyleComment();
1575 : bool readString();
1576 : void readNumber();
1577 : bool readValue();
1578 : bool readObject( Token &token );
1579 : bool readArray( Token &token );
1580 : bool decodeNumber( Token &token );
1581 : bool decodeString( Token &token );
1582 : bool decodeString( Token &token, std::string &decoded );
1583 : bool decodeDouble( Token &token );
1584 : bool decodeUnicodeCodePoint( Token &token,
1585 : Location ¤t,
1586 : Location end,
1587 : unsigned int &unicode );
1588 : bool decodeUnicodeEscapeSequence( Token &token,
1589 : Location ¤t,
1590 : Location end,
1591 : unsigned int &unicode );
1592 : bool addError( const std::string &message,
1593 : Token &token,
1594 : Location extra = 0 );
1595 : bool recoverFromError( TokenType skipUntilToken );
1596 : bool addErrorAndRecover( const std::string &message,
1597 : Token &token,
1598 : TokenType skipUntilToken );
1599 : void skipUntilSpace();
1600 : Value ¤tValue();
1601 : Char getNextChar();
1602 : void getLocationLineAndColumn( Location location,
1603 : int &line,
1604 : int &column ) const;
1605 : std::string getLocationLineAndColumn( Location location ) const;
1606 : void addComment( Location begin,
1607 : Location end,
1608 : CommentPlacement placement );
1609 : void skipCommentTokens( Token &token );
1610 :
1611 : typedef std::stack<Value *> Nodes;
1612 : Nodes nodes_;
1613 : Errors errors_;
1614 : std::string document_;
1615 : Location begin_;
1616 : Location end_;
1617 : Location current_;
1618 : Location lastValueEnd_;
1619 : Value *lastValue_;
1620 : std::string commentsBefore_;
1621 : Features features_;
1622 : bool collectComments_;
1623 : };
1624 :
1625 : /** \brief Read from 'sin' into 'root'.
1626 :
1627 : Always keep comments from the input JSON.
1628 :
1629 : This can be used to read a file into a particular sub-object.
1630 : For example:
1631 : \code
1632 : Json::Value root;
1633 : cin >> root["dir"]["file"];
1634 : cout << root;
1635 : \endcode
1636 : Result:
1637 : \verbatim
1638 : {
1639 : "dir": {
1640 : "file": {
1641 : // The input stream JSON would be nested here.
1642 : }
1643 : }
1644 : }
1645 : \endverbatim
1646 : \throw std::exception on parse error.
1647 : \see Json::operator<<()
1648 : */
1649 : std::istream& operator>>( std::istream&, Value& );
1650 :
1651 : } // namespace Json
1652 :
1653 : #endif // CPPTL_JSON_READER_H_INCLUDED
1654 :
1655 : // //////////////////////////////////////////////////////////////////////
1656 : // End of content of file: include/json/reader.h
1657 : // //////////////////////////////////////////////////////////////////////
1658 :
1659 :
1660 :
1661 :
1662 :
1663 :
1664 : // //////////////////////////////////////////////////////////////////////
1665 : // Beginning of content of file: include/json/writer.h
1666 : // //////////////////////////////////////////////////////////////////////
1667 :
1668 : // Copyright 2007-2010 Baptiste Lepilleur
1669 : // Distributed under MIT license, or public domain if desired and
1670 : // recognized in your jurisdiction.
1671 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
1672 :
1673 : #ifndef JSON_WRITER_H_INCLUDED
1674 : # define JSON_WRITER_H_INCLUDED
1675 :
1676 : #if !defined(JSON_IS_AMALGAMATION)
1677 : # include "value.h"
1678 : #endif // if !defined(JSON_IS_AMALGAMATION)
1679 : # include <vector>
1680 : # include <string>
1681 :
1682 : namespace Json {
1683 :
1684 : class Value;
1685 :
1686 : /** \brief Abstract class for writers.
1687 : */
1688 : class JSON_API Writer
1689 : {
1690 : public:
1691 : virtual ~Writer();
1692 :
1693 : virtual std::string write( const Value &root ) = 0;
1694 : };
1695 :
1696 : /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
1697 : *
1698 : * The JSON document is written in a single line. It is not intended for 'human' consumption,
1699 : * but may be usefull to support feature such as RPC where bandwith is limited.
1700 : * \sa Reader, Value
1701 : */
1702 : class JSON_API FastWriter : public Writer
1703 : {
1704 : public:
1705 : FastWriter();
1706 0 : virtual ~FastWriter(){}
1707 :
1708 : void enableYAMLCompatibility();
1709 :
1710 : /** \brief Drop the "null" string from the writer's output for nullValues.
1711 : * Strictly speaking, this is not valid JSON. But when the output is being
1712 : * fed to a browser's Javascript, it makes for smaller output and the
1713 : * browser can handle the output just fine.
1714 : */
1715 : void dropNullPlaceholders();
1716 :
1717 : public: // overridden from Writer
1718 : virtual std::string write( const Value &root );
1719 :
1720 : private:
1721 : void writeValue( const Value &value );
1722 :
1723 : std::string document_;
1724 : bool yamlCompatiblityEnabled_;
1725 : bool dropNullPlaceholders_;
1726 : };
1727 :
1728 : /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way.
1729 : *
1730 : * The rules for line break and indent are as follow:
1731 : * - Object value:
1732 : * - if empty then print {} without indent and line break
1733 : * - if not empty the print '{', line break & indent, print one value per line
1734 : * and then unindent and line break and print '}'.
1735 : * - Array value:
1736 : * - if empty then print [] without indent and line break
1737 : * - if the array contains no object value, empty array or some other value types,
1738 : * and all the values fit on one lines, then print the array on a single line.
1739 : * - otherwise, it the values do not fit on one line, or the array contains
1740 : * object or non empty array, then print one value per line.
1741 : *
1742 : * If the Value have comments then they are outputed according to their #CommentPlacement.
1743 : *
1744 : * \sa Reader, Value, Value::setComment()
1745 : */
1746 : class JSON_API StyledWriter: public Writer
1747 : {
1748 : public:
1749 : StyledWriter();
1750 0 : virtual ~StyledWriter(){}
1751 :
1752 : public: // overridden from Writer
1753 : /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
1754 : * \param root Value to serialize.
1755 : * \return String containing the JSON document that represents the root value.
1756 : */
1757 : virtual std::string write( const Value &root );
1758 :
1759 : private:
1760 : void writeValue( const Value &value );
1761 : void writeArrayValue( const Value &value );
1762 : bool isMultineArray( const Value &value );
1763 : void pushValue( const std::string &value );
1764 : void writeIndent();
1765 : void writeWithIndent( const std::string &value );
1766 : void indent();
1767 : void unindent();
1768 : void writeCommentBeforeValue( const Value &root );
1769 : void writeCommentAfterValueOnSameLine( const Value &root );
1770 : bool hasCommentForValue( const Value &value );
1771 : static std::string normalizeEOL( const std::string &text );
1772 :
1773 : typedef std::vector<std::string> ChildValues;
1774 :
1775 : ChildValues childValues_;
1776 : std::string document_;
1777 : std::string indentString_;
1778 : int rightMargin_;
1779 : int indentSize_;
1780 : bool addChildValues_;
1781 : };
1782 :
1783 : /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way,
1784 : to a stream rather than to a string.
1785 : *
1786 : * The rules for line break and indent are as follow:
1787 : * - Object value:
1788 : * - if empty then print {} without indent and line break
1789 : * - if not empty the print '{', line break & indent, print one value per line
1790 : * and then unindent and line break and print '}'.
1791 : * - Array value:
1792 : * - if empty then print [] without indent and line break
1793 : * - if the array contains no object value, empty array or some other value types,
1794 : * and all the values fit on one lines, then print the array on a single line.
1795 : * - otherwise, it the values do not fit on one line, or the array contains
1796 : * object or non empty array, then print one value per line.
1797 : *
1798 : * If the Value have comments then they are outputed according to their #CommentPlacement.
1799 : *
1800 : * \param indentation Each level will be indented by this amount extra.
1801 : * \sa Reader, Value, Value::setComment()
1802 : */
1803 : class JSON_API StyledStreamWriter
1804 : {
1805 : public:
1806 : StyledStreamWriter( std::string indentation="\t" );
1807 : ~StyledStreamWriter(){}
1808 :
1809 : public:
1810 : /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
1811 : * \param out Stream to write to. (Can be ostringstream, e.g.)
1812 : * \param root Value to serialize.
1813 : * \note There is no point in deriving from Writer, since write() should not return a value.
1814 : */
1815 : void write( std::ostream &out, const Value &root );
1816 :
1817 : private:
1818 : void writeValue( const Value &value );
1819 : void writeArrayValue( const Value &value );
1820 : bool isMultineArray( const Value &value );
1821 : void pushValue( const std::string &value );
1822 : void writeIndent();
1823 : void writeWithIndent( const std::string &value );
1824 : void indent();
1825 : void unindent();
1826 : void writeCommentBeforeValue( const Value &root );
1827 : void writeCommentAfterValueOnSameLine( const Value &root );
1828 : bool hasCommentForValue( const Value &value );
1829 : static std::string normalizeEOL( const std::string &text );
1830 :
1831 : typedef std::vector<std::string> ChildValues;
1832 :
1833 : ChildValues childValues_;
1834 : std::ostream* document_;
1835 : std::string indentString_;
1836 : int rightMargin_;
1837 : std::string indentation_;
1838 : bool addChildValues_;
1839 : };
1840 :
1841 : # if defined(JSON_HAS_INT64)
1842 : std::string JSON_API valueToString( Int value );
1843 : std::string JSON_API valueToString( UInt value );
1844 : # endif // if defined(JSON_HAS_INT64)
1845 : std::string JSON_API valueToString( LargestInt value );
1846 : std::string JSON_API valueToString( LargestUInt value );
1847 : std::string JSON_API valueToString( double value );
1848 : std::string JSON_API valueToString( bool value );
1849 : std::string JSON_API valueToQuotedString( const char *value );
1850 :
1851 : /// \brief Output using the StyledStreamWriter.
1852 : /// \see Json::operator>>()
1853 : std::ostream& operator<<( std::ostream&, const Value &root );
1854 :
1855 : } // namespace Json
1856 :
1857 :
1858 :
1859 : #endif // JSON_WRITER_H_INCLUDED
1860 :
1861 : // //////////////////////////////////////////////////////////////////////
1862 : // End of content of file: include/json/writer.h
1863 : // //////////////////////////////////////////////////////////////////////
1864 :
1865 :
1866 :
1867 :
1868 :
1869 :
1870 : // //////////////////////////////////////////////////////////////////////
1871 : // Beginning of content of file: include/json/assertions.h
1872 : // //////////////////////////////////////////////////////////////////////
1873 :
1874 : // Copyright 2007-2010 Baptiste Lepilleur
1875 : // Distributed under MIT license, or public domain if desired and
1876 : // recognized in your jurisdiction.
1877 : // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
1878 :
1879 : #ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
1880 : # define CPPTL_JSON_ASSERTIONS_H_INCLUDED
1881 :
1882 : #include <stdlib.h>
1883 :
1884 : #if !defined(JSON_IS_AMALGAMATION)
1885 : # include <json/config.h>
1886 : #endif // if !defined(JSON_IS_AMALGAMATION)
1887 :
1888 : #if JSON_USE_EXCEPTION
1889 : #define JSON_ASSERT( condition ) assert( condition ); // @todo <= change this into an exception throw
1890 : #define JSON_FAIL_MESSAGE( message ) throw std::runtime_error( message );
1891 : #else // JSON_USE_EXCEPTION
1892 : #define JSON_ASSERT( condition ) assert( condition );
1893 :
1894 : // The call to assert() will show the failure message in debug builds. In
1895 : // release bugs we write to invalid memory in order to crash hard, so that a
1896 : // debugger or crash reporter gets the chance to take over. We still call exit()
1897 : // afterward in order to tell the compiler that this macro doesn't return.
1898 : #define JSON_FAIL_MESSAGE( message ) { assert(false && message); strcpy(reinterpret_cast<char*>(666), message); exit(123); }
1899 :
1900 : #endif
1901 :
1902 : #define JSON_ASSERT_MESSAGE( condition, message ) if (!( condition )) { JSON_FAIL_MESSAGE( message ) }
1903 :
1904 : #endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED
1905 :
1906 : // //////////////////////////////////////////////////////////////////////
1907 : // End of content of file: include/json/assertions.h
1908 : // //////////////////////////////////////////////////////////////////////
1909 :
1910 :
1911 :
1912 :
1913 :
1914 : #endif //ifndef JSON_AMALGATED_H_INCLUDED
|
