JsonCpp project page | Classes | Namespace | JsonCpp home page

value.h
Go to the documentation of this file.
1// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
2// Distributed under MIT license, or public domain if desired and
3// recognized in your jurisdiction.
4// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
5
6#ifndef JSON_VALUE_H_INCLUDED
7#define JSON_VALUE_H_INCLUDED
8
9#if !defined(JSON_IS_AMALGAMATION)
10#include "forwards.h"
11#endif // if !defined(JSON_IS_AMALGAMATION)
12
13// Conditional NORETURN attribute on the throw functions would:
14// a) suppress false positives from static code analysis
15// b) possibly improve optimization opportunities.
16#if !defined(JSONCPP_NORETURN)
17#if defined(_MSC_VER) && _MSC_VER == 1800
18#define JSONCPP_NORETURN __declspec(noreturn)
19#else
20#define JSONCPP_NORETURN [[noreturn]]
21#endif
22#endif
23
24// Support for '= delete' with template declarations was a late addition
25// to the c++11 standard and is rejected by clang 3.8 and Apple clang 8.2
26// even though these declare themselves to be c++11 compilers.
27#if !defined(JSONCPP_TEMPLATE_DELETE)
28#if defined(__clang__) && defined(__apple_build_version__)
29#if __apple_build_version__ <= 8000042
30#define JSONCPP_TEMPLATE_DELETE
31#endif
32#elif defined(__clang__)
33#if __clang_major__ == 3 && __clang_minor__ <= 8
34#define JSONCPP_TEMPLATE_DELETE
35#endif
36#endif
37#if !defined(JSONCPP_TEMPLATE_DELETE)
38#define JSONCPP_TEMPLATE_DELETE = delete
39#endif
40#endif
41
42#include <array>
43#include <exception>
44#include <map>
45#include <memory>
46#include <string>
47#include <vector>
48
49// Disable warning C4251: <data member>: <type> needs to have dll-interface to
50// be used by...
51#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
52#pragma warning(push)
53#pragma warning(disable : 4251 4275)
54#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
55
56#pragma pack(push)
57#pragma pack()
58
61namespace Json {
62
63#if JSON_USE_EXCEPTION
68 class JSON_API Exception : public std::exception {
69public:
70 Exception(String msg);
71 ~Exception() noexcept override;
72 char const* what() const noexcept override;
73
74protected:
75 String msg_;
76};
77
84class JSON_API RuntimeError : public Exception {
85public:
86 RuntimeError(String const& msg);
87};
88
95 class JSON_API LogicError : public Exception {
96public:
97 LogicError(String const& msg);
98};
99#endif
100
102 JSONCPP_NORETURN void throwRuntimeError(String const& msg);
104 JSONCPP_NORETURN void throwLogicError(String const& msg);
105
108 enum ValueType {
109 nullValue = 0,
110 intValue,
111 uintValue,
112 realValue,
113 stringValue,
114 booleanValue,
115 arrayValue,
116 objectValue
117};
118
119 enum CommentPlacement {
120 commentBefore = 0,
121 commentAfterOnSameLine,
122 commentAfter,
124 numberOfCommentPlacement
125};
126
129 enum PrecisionType {
130 significantDigits = 0,
131 decimalPlaces
132};
133
148 class JSON_API StaticString {
149public:
150 explicit StaticString(const char* czstring) : c_str_(czstring) {}
151
152 operator const char*() const { return c_str_; }
153
154 const char* c_str() const { return c_str_; }
155
156private:
157 const char* c_str_;
158};
159
194 class JSON_API Value {
195 friend class ValueIteratorBase;
196
197public:
198 using Members = std::vector<String>;
199 using iterator = ValueIterator;
200 using const_iterator = ValueConstIterator;
201 using UInt = Json::UInt;
202 using Int = Json::Int;
203#if defined(JSON_HAS_INT64)
204 using UInt64 = Json::UInt64;
205 using Int64 = Json::Int64;
206#endif // defined(JSON_HAS_INT64)
207 using LargestInt = Json::LargestInt;
208 using LargestUInt = Json::LargestUInt;
209 using ArrayIndex = Json::ArrayIndex;
210
211 // Required for boost integration, e. g. BOOST_TEST
212 using value_type = std::string;
213
214#if JSON_USE_NULLREF
215 // Binary compatibility kludges, do not use.
216 static const Value& null;
217 static const Value& nullRef;
218#endif
219
220 // null and nullRef are deprecated, use this instead.
221 static Value const& nullSingleton();
222
224 static constexpr LargestInt minLargestInt =
225 LargestInt(~(LargestUInt(-1) / 2));
227 static constexpr LargestInt maxLargestInt = LargestInt(LargestUInt(-1) / 2);
229 static constexpr LargestUInt maxLargestUInt = LargestUInt(-1);
230
232 static constexpr Int minInt = Int(~(UInt(-1) / 2));
234 static constexpr Int maxInt = Int(UInt(-1) / 2);
236 static constexpr UInt maxUInt = UInt(-1);
237
238#if defined(JSON_HAS_INT64)
240 static constexpr Int64 minInt64 = Int64(~(UInt64(-1) / 2));
242 static constexpr Int64 maxInt64 = Int64(UInt64(-1) / 2);
244 static constexpr UInt64 maxUInt64 = UInt64(-1);
245#endif // defined(JSON_HAS_INT64)
247 static constexpr UInt defaultRealPrecision = 17;
248 // The constant is hard-coded because some compiler have trouble
249 // converting Value::maxUInt64 to a double correctly (AIX/xlC).
250 // Assumes that UInt64 is a 64 bits integer.
251 static constexpr double maxUInt64AsDouble = 18446744073709551615.0;
252// Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
253// when using gcc and clang backend compilers. CZString
254// cannot be defined as private. See issue #486
255#ifdef __NVCC__
256public:
257#else
258private:
259#endif
260#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
261 class CZString {
262 public:
263 enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
264 CZString(ArrayIndex index);
265 CZString(char const* str, unsigned length, DuplicationPolicy allocate);
266 CZString(CZString const& other);
267 CZString(CZString&& other) noexcept;
268 ~CZString();
269 CZString& operator=(const CZString& other);
270 CZString& operator=(CZString&& other) noexcept;
271
272 bool operator<(CZString const& other) const;
273 bool operator==(CZString const& other) const;
274 ArrayIndex index() const;
275 // const char* c_str() const; ///< \deprecated
276 char const* data() const;
277 unsigned length() const;
278 bool isStaticString() const;
279
280 private:
281 void swap(CZString& other);
282
283 struct StringStorage {
284 unsigned policy_ : 2;
285 unsigned length_ : 30; // 1GB max
286 };
287
288 char const* cstr_; // actually, a prefixed string, unless policy is noDup
289 union {
290 ArrayIndex index_;
291 StringStorage storage_;
292 };
293 };
294
295public:
296 typedef std::map<CZString, Value> ObjectValues;
297#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
298
299public:
316 Value(ValueType type = nullValue);
317 Value(Int value);
318 Value(UInt value);
319#if defined(JSON_HAS_INT64)
320 Value(Int64 value);
321 Value(UInt64 value);
322#endif // if defined(JSON_HAS_INT64)
323 Value(double value);
324 Value(const char* value);
325 Value(const char* begin, const char* end);
343 Value(const StaticString& value);
344 Value(const String& value);
345 Value(bool value);
346 Value(std::nullptr_t ptr) = delete;
347 Value(const Value& other);
348 Value(Value&& other) noexcept;
349 ~Value();
350
353 Value& operator=(const Value& other);
354 Value& operator=(Value&& other) noexcept;
355
357 void swap(Value& other);
359 void swapPayload(Value& other);
360
362 void copy(const Value& other);
364 void copyPayload(const Value& other);
365
366 ValueType type() const;
367
369 bool operator<(const Value& other) const;
370 bool operator<=(const Value& other) const;
371 bool operator>=(const Value& other) const;
372 bool operator>(const Value& other) const;
373 bool operator==(const Value& other) const;
374 bool operator!=(const Value& other) const;
375 int compare(const Value& other) const;
376
377 const char* asCString() const;
378#if JSONCPP_USING_SECURE_MEMORY
379 unsigned getCStringLength() const; // Allows you to understand the length of
380 // the CString
381#endif
382 String asString() const;
386 bool getString(char const** begin, char const** end) const;
387 Int asInt() const;
388 UInt asUInt() const;
389#if defined(JSON_HAS_INT64)
390 Int64 asInt64() const;
391 UInt64 asUInt64() const;
392#endif // if defined(JSON_HAS_INT64)
393 LargestInt asLargestInt() const;
394 LargestUInt asLargestUInt() const;
395 float asFloat() const;
396 double asDouble() const;
397 bool asBool() const;
398
399 bool isNull() const;
400 bool isBool() const;
401 bool isInt() const;
402 bool isInt64() const;
403 bool isUInt() const;
404 bool isUInt64() const;
405 bool isIntegral() const;
406 bool isDouble() const;
407 bool isNumeric() const;
408 bool isString() const;
409 bool isArray() const;
410 bool isObject() const;
411
413 template <typename T> T as() const JSONCPP_TEMPLATE_DELETE;
414 template <typename T> bool is() const JSONCPP_TEMPLATE_DELETE;
415
416 bool isConvertibleTo(ValueType other) const;
417
419 ArrayIndex size() const;
420
423 bool empty() const;
424
426 explicit operator bool() const;
427
431 void clear();
432
438 void resize(ArrayIndex newSize);
439
446 Value& operator[](ArrayIndex index);
447 Value& operator[](int index);
449
454 const Value& operator[](ArrayIndex index) const;
455 const Value& operator[](int index) const;
457
460 Value get(ArrayIndex index, const Value& defaultValue) const;
462 bool isValidIndex(ArrayIndex index) const;
466 Value& append(const Value& value);
467 Value& append(Value&& value);
468
470 bool insert(ArrayIndex index, const Value& newValue);
471 bool insert(ArrayIndex index, Value&& newValue);
472
476 Value& operator[](const char* key);
479 const Value& operator[](const char* key) const;
482 Value& operator[](const String& key);
486 const Value& operator[](const String& key) const;
499 Value& operator[](const StaticString& key);
502 Value get(const char* key, const Value& defaultValue) const;
506 Value get(const char* begin, const char* end,
507 const Value& defaultValue) const;
511 Value get(const String& key, const Value& defaultValue) const;
515 Value const* find(char const* begin, char const* end) const;
518 Value const* find(const String& key) const;
522 Value* demand(char const* begin, char const* end);
528 void removeMember(const char* key);
531 void removeMember(const String& key);
534 bool removeMember(const char* key, Value* removed);
541 bool removeMember(String const& key, Value* removed);
543 bool removeMember(const char* begin, const char* end, Value* removed);
550 bool removeIndex(ArrayIndex index, Value* removed);
551
554 bool isMember(const char* key) const;
557 bool isMember(const String& key) const;
559 bool isMember(const char* begin, const char* end) const;
560
566 Members getMemberNames() const;
567
569 JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
570 void setComment(const char* comment, CommentPlacement placement) {
571 setComment(String(comment, strlen(comment)), placement);
572 }
574 void setComment(const char* comment, size_t len, CommentPlacement placement) {
575 setComment(String(comment, len), placement);
576 }
578 void setComment(String comment, CommentPlacement placement);
579 bool hasComment(CommentPlacement placement) const;
581 String getComment(CommentPlacement placement) const;
582
583 String toStyledString() const;
584
585 const_iterator begin() const;
586 const_iterator end() const;
587
588 iterator begin();
589 iterator end();
590
594 const Value& front() const;
595
599 Value& front();
600
604 const Value& back() const;
605
609 Value& back();
610
611 // Accessors for the [start, limit) range of bytes within the JSON text from
612 // which this value was parsed, if any.
613 void setOffsetStart(ptrdiff_t start);
614 void setOffsetLimit(ptrdiff_t limit);
615 ptrdiff_t getOffsetStart() const;
616 ptrdiff_t getOffsetLimit() const;
617
618private:
619 void setType(ValueType v) {
620 bits_.value_type_ = static_cast<unsigned char>(v);
621 }
622 bool isAllocated() const { return bits_.allocated_; }
623 void setIsAllocated(bool v) { bits_.allocated_ = v; }
624
625 void initBasic(ValueType type, bool allocated = false);
626 void dupPayload(const Value& other);
627 void releasePayload();
628 void dupMeta(const Value& other);
629
630 Value& resolveReference(const char* key);
631 Value& resolveReference(const char* key, const char* end);
632
633 // struct MemberNamesTransform
634 //{
635 // typedef const char *result_type;
636 // const char *operator()( const CZString &name ) const
637 // {
638 // return name.c_str();
639 // }
640 //};
641
642 union ValueHolder {
643 LargestInt int_;
644 LargestUInt uint_;
645 double real_;
646 bool bool_;
647 char* string_; // if allocated_, ptr to { unsigned, char[] }.
648 ObjectValues* map_;
649 } value_;
650
651 struct {
652 // Really a ValueType, but types should agree for bitfield packing.
653 unsigned int value_type_ : 8;
654 // Unless allocated_, string_ must be null-terminated.
655 unsigned int allocated_ : 1;
656 } bits_;
657
658 class Comments {
659 public:
660 Comments() = default;
661 Comments(const Comments& that);
662 Comments(Comments&& that) noexcept;
663 Comments& operator=(const Comments& that);
664 Comments& operator=(Comments&& that) noexcept;
665 bool has(CommentPlacement slot) const;
666 String get(CommentPlacement slot) const;
667 void set(CommentPlacement slot, String comment);
668
669 private:
670 using Array = std::array<String, numberOfCommentPlacement>;
671 std::unique_ptr<Array> ptr_;
672 };
673 Comments comments_;
674
675 // [start, limit) byte offsets in the source JSON text from which this Value
676 // was extracted.
677 ptrdiff_t start_;
678 ptrdiff_t limit_;
679};
680
681 template <> inline bool Value::as<bool>() const { return asBool(); }
682 template <> inline bool Value::is<bool>() const { return isBool(); }
683
684 template <> inline Int Value::as<Int>() const { return asInt(); }
685 template <> inline bool Value::is<Int>() const { return isInt(); }
686
687 template <> inline UInt Value::as<UInt>() const { return asUInt(); }
688 template <> inline bool Value::is<UInt>() const { return isUInt(); }
689
690#if defined(JSON_HAS_INT64)
691 template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
692 template <> inline bool Value::is<Int64>() const { return isInt64(); }
693
694 template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
695 template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
696#endif
697
698 template <> inline double Value::as<double>() const { return asDouble(); }
699 template <> inline bool Value::is<double>() const { return isDouble(); }
700
701 template <> inline String Value::as<String>() const { return asString(); }
702 template <> inline bool Value::is<String>() const { return isString(); }
703
706 template <> inline float Value::as<float>() const { return asFloat(); }
707 template <> inline const char* Value::as<const char*>() const {
708 return asCString();
709}
710
714 class JSON_API PathArgument {
715public:
716 friend class Path;
717
718 PathArgument();
719 PathArgument(ArrayIndex index);
720 PathArgument(const char* key);
721 PathArgument(String key);
722
723private:
724 enum Kind { kindNone = 0, kindIndex, kindKey };
725 String key_;
726 ArrayIndex index_{};
727 Kind kind_{kindNone};
728};
729
741 class JSON_API Path {
742public:
743 Path(const String& path, const PathArgument& a1 = PathArgument(),
744 const PathArgument& a2 = PathArgument(),
745 const PathArgument& a3 = PathArgument(),
746 const PathArgument& a4 = PathArgument(),
747 const PathArgument& a5 = PathArgument());
748
749 const Value& resolve(const Value& root) const;
750 Value resolve(const Value& root, const Value& defaultValue) const;
753 Value& make(Value& root) const;
754
755private:
756 using InArgs = std::vector<const PathArgument*>;
757 using Args = std::vector<PathArgument>;
758
759 void makePath(const String& path, const InArgs& in);
760 void addPathInArg(const String& path, const InArgs& in,
761 InArgs::const_iterator& itInArg, PathArgument::Kind kind);
762 static void invalidPath(const String& path, int location);
763
764 Args args_;
765};
766
770 class JSON_API ValueIteratorBase {
771public:
772 using iterator_category = std::bidirectional_iterator_tag;
773 using size_t = unsigned int;
774 using difference_type = int;
775 using SelfType = ValueIteratorBase;
776
777 bool operator==(const SelfType& other) const { return isEqual(other); }
778
779 bool operator!=(const SelfType& other) const { return !isEqual(other); }
780
781 difference_type operator-(const SelfType& other) const {
782 return other.computeDistance(*this);
783 }
784
787 Value key() const;
788
791 UInt index() const;
792
796 String name() const;
797
802 JSONCPP_DEPRECATED("Use `key = name();` instead.")
803 char const* memberName() const;
807 char const* memberName(char const** end) const;
808
809protected:
816 const Value& deref() const;
817 Value& deref();
818
819 void increment();
820
821 void decrement();
822
823 difference_type computeDistance(const SelfType& other) const;
824
825 bool isEqual(const SelfType& other) const;
826
827 void copy(const SelfType& other);
828
829private:
830 Value::ObjectValues::iterator current_;
831 // Indicates that iterator is for a null value.
832 bool isNull_{true};
833
834public:
835 // For some reason, BORLAND needs these at the end, rather
836 // than earlier. No idea why.
837 ValueIteratorBase();
838 explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
839};
840
844 class JSON_API ValueConstIterator : public ValueIteratorBase {
845 friend class Value;
846
847public:
848 using value_type = const Value;
849 // typedef unsigned int size_t;
850 // typedef int difference_type;
851 using reference = const Value&;
852 using pointer = const Value*;
853 using SelfType = ValueConstIterator;
854
855 ValueConstIterator();
856 ValueConstIterator(ValueIterator const& other);
857
858private:
861 explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
862
863public:
864 SelfType& operator=(const ValueIteratorBase& other);
865
866 SelfType operator++(int) {
867 SelfType temp(*this);
868 ++*this;
869 return temp;
870 }
871
872 SelfType operator--(int) {
873 SelfType temp(*this);
874 --*this;
875 return temp;
876 }
877
878 SelfType& operator--() {
879 decrement();
880 return *this;
881 }
882
883 SelfType& operator++() {
884 increment();
885 return *this;
886 }
887
888 reference operator*() const { return deref(); }
889
890 pointer operator->() const { return &deref(); }
891};
892
895 class JSON_API ValueIterator : public ValueIteratorBase {
896 friend class Value;
897
898public:
899 using value_type = Value;
900 using size_t = unsigned int;
901 using difference_type = int;
902 using reference = Value&;
903 using pointer = Value*;
904 using SelfType = ValueIterator;
905
906 ValueIterator();
907 explicit ValueIterator(const ValueConstIterator& other);
908 ValueIterator(const ValueIterator& other);
909
910private:
913 explicit ValueIterator(const Value::ObjectValues::iterator& current);
914
915public:
916 SelfType& operator=(const SelfType& other);
917
918 SelfType operator++(int) {
919 SelfType temp(*this);
920 ++*this;
921 return temp;
922 }
923
924 SelfType operator--(int) {
925 SelfType temp(*this);
926 --*this;
927 return temp;
928 }
929
930 SelfType& operator--() {
931 decrement();
932 return *this;
933 }
934
935 SelfType& operator++() {
936 increment();
937 return *this;
938 }
939
945 reference operator*() const { return const_cast<reference>(deref()); }
946 pointer operator->() const { return const_cast<pointer>(&deref()); }
947};
948
949 inline void swap(Value& a, Value& b) { a.swap(b); }
950
951 inline const Value& Value::front() const { return *begin(); }
952
953 inline Value& Value::front() { return *begin(); }
954
955 inline const Value& Value::back() const { return *(--end()); }
956
957 inline Value& Value::back() { return *(--end()); }
958
959} // namespace Json
960
961#pragma pack(pop)
962
963#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
964#pragma warning(pop)
965#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
966
967#endif // JSON_H_INCLUDED
Json::Exception
Base class for all exceptions we throw.
Definition value.h:68
Json::Exception::~Exception
~Exception() noexcept override
Json::LogicError
Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
Definition value.h:95
Json::PathArgument
Experimental and untested: represents an element of the "path" to access a node.
Definition value.h:714
Json::PathArgument::PathArgument
PathArgument()
Json::Path
Experimental and untested: represents a "path" to access a node.
Definition value.h:741
Json::RuntimeError
Exceptions which the user cannot easily avoid.
Definition value.h:84
Json::StaticString
Lightweight wrapper to tag static string.
Definition value.h:148
Json::StaticString::c_str
const char * c_str() const
Definition value.h:154
Json::StaticString::StaticString
StaticString(const char *czstring)
Definition value.h:150
Json::ValueConstIterator
const iterator for object and array value.
Definition value.h:844
Json::ValueConstIterator::ValueConstIterator
ValueConstIterator()
Json::ValueConstIterator::operator--
SelfType & operator--()
Definition value.h:878
Json::ValueConstIterator::operator->
pointer operator->() const
Definition value.h:890
Json::ValueConstIterator::operator--
SelfType operator--(int)
Definition value.h:872
Json::ValueConstIterator::operator++
SelfType & operator++()
Definition value.h:883
Json::ValueConstIterator::operator++
SelfType operator++(int)
Definition value.h:866
Json::ValueConstIterator::operator*
reference operator*() const
Definition value.h:888
Json::Value
Represents a JSON value.
Definition value.h:194
Json::Value::Value
Value(std::nullptr_t ptr)=delete
Json::Value::ArrayIndex
Json::ArrayIndex ArrayIndex
Definition value.h:209
Json::Value::UInt
Json::UInt UInt
Definition value.h:201
Json::Value::null
static const Value & null
Definition value.h:216
Json::Value::setComment
void setComment(const char *comment, size_t len, CommentPlacement placement)
Comments must be //... or /* ... *‍/.
Definition value.h:574
Json::Value::as
T as() const =delete
The as<T> and is<T> member function templates and specializations.
Json::Value::Members
std::vector< String > Members
Definition value.h:198
Json::Value::LargestInt
Json::LargestInt LargestInt
Definition value.h:207
Json::Value::LargestUInt
Json::LargestUInt LargestUInt
Definition value.h:208
Json::Value::UInt64
Json::UInt64 UInt64
Definition value.h:204
Json::Value::swap
void swap(Value &other)
Swap everything.
Definition json_value.cpp:466
Json::Value::Int
Json::Int Int
Definition value.h:202
Json::Value::nullRef
static const Value & nullRef
Definition value.h:217
Json::Value::value_type_
unsigned int value_type_
Definition value.h:653
Json::Value::Int64
Json::Int64 Int64
Definition value.h:205
Json::Value::allocated_
unsigned int allocated_
Definition value.h:655
Json::Value::value_type
std::string value_type
Definition value.h:212
Json::ValueIteratorBase
base class for Value iterators.
Definition value.h:770
Json::ValueIteratorBase::operator==
bool operator==(const SelfType &other) const
Definition value.h:777
Json::ValueIteratorBase::size_t
unsigned int size_t
Definition value.h:773
Json::ValueIteratorBase::iterator_category
std::bidirectional_iterator_tag iterator_category
Definition value.h:772
Json::ValueIteratorBase::operator-
difference_type operator-(const SelfType &other) const
Definition value.h:781
Json::ValueIteratorBase::operator!=
bool operator!=(const SelfType &other) const
Definition value.h:779
Json::ValueIteratorBase::computeDistance
difference_type computeDistance(const SelfType &other) const
Definition json_valueiterator.inl:32
Json::ValueIteratorBase::difference_type
int difference_type
Definition value.h:774
Json::ValueIterator
Iterator for object and array value.
Definition value.h:895
Json::ValueIterator::operator--
SelfType operator--(int)
Definition value.h:924
Json::ValueIterator::ValueIterator
ValueIterator()
Json::ValueIterator::operator--
SelfType & operator--()
Definition value.h:930
Json::ValueIterator::operator*
reference operator*() const
Definition value.h:945
Json::ValueIterator::operator++
SelfType & operator++()
Definition value.h:935
Json::ValueIterator::size_t
unsigned int size_t
Definition value.h:900
Json::ValueIterator::difference_type
int difference_type
Definition value.h:901
Json::ValueIterator::ValueIterator
ValueIterator(const ValueIterator &other)
Json::ValueIterator::operator->
pointer operator->() const
Definition value.h:946
Json::ValueIterator::operator++
SelfType operator++(int)
Definition value.h:918
JSON_API
#define JSON_API
If defined, indicates that the source file is amalgamated to prevent private header inclusion.
Definition config.h:50
JSONCPP_DEPRECATED
#define JSONCPP_DEPRECATED(message)
Definition config.h:89
forwards.h
Json
JSON (JavaScript Object Notation).
Definition allocator.h:15
Json::UInt64
unsigned __int64 UInt64
Definition config.h:118
Json::ArrayIndex
unsigned int ArrayIndex
Definition forwards.h:32
Json::Int64
__int64 Int64
Definition config.h:117
Json::LargestInt
Int64 LargestInt
Definition config.h:123
Json::CommentPlacement
CommentPlacement
Definition value.h:119
Json::commentAfterOnSameLine
@ commentAfterOnSameLine
a comment just after a value on the same line
Definition value.h:121
Json::commentBefore
@ commentBefore
a comment placed on the line before a value
Definition value.h:120
Json::numberOfCommentPlacement
@ numberOfCommentPlacement
root value)
Definition value.h:124
Json::commentAfter
@ commentAfter
a comment on the line after a value (only make sense for
Definition value.h:122
Json::UInt
unsigned int UInt
Definition config.h:109
Json::ValueType
ValueType
Type of the value held by a Value object.
Definition value.h:108
Json::booleanValue
@ booleanValue
bool value
Definition value.h:114
Json::nullValue
@ nullValue
'null' value
Definition value.h:109
Json::stringValue
@ stringValue
UTF-8 string value.
Definition value.h:113
Json::realValue
@ realValue
double value
Definition value.h:112
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition value.h:115
Json::intValue
@ intValue
signed integer value
Definition value.h:110
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition value.h:116
Json::uintValue
@ uintValue
unsigned integer value
Definition value.h:111
Json::operator==
bool operator==(const SecureAllocator< T > &, const SecureAllocator< U > &)
Definition allocator.h:78
Json::operator!=
bool operator!=(const SecureAllocator< T > &, const SecureAllocator< U > &)
Definition allocator.h:83
Json::Int
int Int
Definition config.h:108
Json::String
std::basic_string< char, std::char_traits< char >, Allocator< char > > String
Definition config.h:132
Json::LargestUInt
UInt64 LargestUInt
Definition config.h:124
Json::PrecisionType
PrecisionType
Type of precision for formatting of real values.
Definition value.h:129
Json::decimalPlaces
@ decimalPlaces
we set max number of digits after "." in string
Definition value.h:131
Json::significantDigits
@ significantDigits
we set max number of significant digits in string
Definition value.h:130
Json::swap
void swap(Value &a, Value &b)
Definition value.h:949
JSONCPP_TEMPLATE_DELETE
#define JSONCPP_TEMPLATE_DELETE
Definition value.h:38
JSONCPP_NORETURN
#define JSONCPP_NORETURN
Definition value.h:18