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_H_INCLUDED
7#define JSON_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
68class 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
85public:
86 RuntimeError(String const& msg);
87};
88
96public:
97 LogicError(String const& msg);
98};
99#endif
100
102JSONCPP_NORETURN void throwRuntimeError(String const& msg);
104JSONCPP_NORETURN void throwLogicError(String const& msg);
105
118
126
133
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
195 friend class ValueIteratorBase;
196
197public:
198 using Members = std::vector<String>;
202 using Int = Json::Int;
203#if defined(JSON_HAS_INT64)
206#endif // defined(JSON_HAS_INT64)
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
441
446 Value& operator[](ArrayIndex index);
447 Value& operator[](int index);
449
451
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;
519 Value* demand(char const* begin, char const* end);
525 void removeMember(const char* key);
528 void removeMember(const String& key);
531 bool removeMember(const char* key, Value* removed);
538 bool removeMember(String const& key, Value* removed);
540 bool removeMember(const char* begin, const char* end, Value* removed);
547 bool removeIndex(ArrayIndex index, Value* removed);
548
551 bool isMember(const char* key) const;
554 bool isMember(const String& key) const;
556 bool isMember(const char* begin, const char* end) const;
557
563 Members getMemberNames() const;
564
566 JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
567 void setComment(const char* comment, CommentPlacement placement) {
568 setComment(String(comment, strlen(comment)), placement);
569 }
571 void setComment(const char* comment, size_t len, CommentPlacement placement) {
572 setComment(String(comment, len), placement);
573 }
575 void setComment(String comment, CommentPlacement placement);
576 bool hasComment(CommentPlacement placement) const;
578 String getComment(CommentPlacement placement) const;
579
580 String toStyledString() const;
581
582 const_iterator begin() const;
583 const_iterator end() const;
584
585 iterator begin();
586 iterator end();
587
588 // Accessors for the [start, limit) range of bytes within the JSON text from
589 // which this value was parsed, if any.
590 void setOffsetStart(ptrdiff_t start);
591 void setOffsetLimit(ptrdiff_t limit);
592 ptrdiff_t getOffsetStart() const;
593 ptrdiff_t getOffsetLimit() const;
594
595private:
596 void setType(ValueType v) {
597 bits_.value_type_ = static_cast<unsigned char>(v);
598 }
599 bool isAllocated() const { return bits_.allocated_; }
600 void setIsAllocated(bool v) { bits_.allocated_ = v; }
601
602 void initBasic(ValueType type, bool allocated = false);
603 void dupPayload(const Value& other);
604 void releasePayload();
605 void dupMeta(const Value& other);
606
607 Value& resolveReference(const char* key);
608 Value& resolveReference(const char* key, const char* end);
609
610 // struct MemberNamesTransform
611 //{
612 // typedef const char *result_type;
613 // const char *operator()( const CZString &name ) const
614 // {
615 // return name.c_str();
616 // }
617 //};
618
619 union ValueHolder {
620 LargestInt int_;
621 LargestUInt uint_;
622 double real_;
623 bool bool_;
624 char* string_; // if allocated_, ptr to { unsigned, char[] }.
625 ObjectValues* map_;
626 } value_;
627
628 struct {
629 // Really a ValueType, but types should agree for bitfield packing.
630 unsigned int value_type_ : 8;
631 // Unless allocated_, string_ must be null-terminated.
632 unsigned int allocated_ : 1;
633 } bits_;
634
635 class Comments {
636 public:
637 Comments() = default;
638 Comments(const Comments& that);
639 Comments(Comments&& that) noexcept;
640 Comments& operator=(const Comments& that);
641 Comments& operator=(Comments&& that) noexcept;
642 bool has(CommentPlacement slot) const;
643 String get(CommentPlacement slot) const;
644 void set(CommentPlacement slot, String comment);
645
646 private:
647 using Array = std::array<String, numberOfCommentPlacement>;
648 std::unique_ptr<Array> ptr_;
649 };
650 Comments comments_;
651
652 // [start, limit) byte offsets in the source JSON text from which this Value
653 // was extracted.
654 ptrdiff_t start_;
655 ptrdiff_t limit_;
656};
657
658template <> inline bool Value::as<bool>() const { return asBool(); }
659template <> inline bool Value::is<bool>() const { return isBool(); }
660
661template <> inline Int Value::as<Int>() const { return asInt(); }
662template <> inline bool Value::is<Int>() const { return isInt(); }
663
664template <> inline UInt Value::as<UInt>() const { return asUInt(); }
665template <> inline bool Value::is<UInt>() const { return isUInt(); }
666
667#if defined(JSON_HAS_INT64)
668template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
669template <> inline bool Value::is<Int64>() const { return isInt64(); }
670
671template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
672template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
673#endif
674
675template <> inline double Value::as<double>() const { return asDouble(); }
676template <> inline bool Value::is<double>() const { return isDouble(); }
677
678template <> inline String Value::as<String>() const { return asString(); }
679template <> inline bool Value::is<String>() const { return isString(); }
680
683template <> inline float Value::as<float>() const { return asFloat(); }
684template <> inline const char* Value::as<const char*>() const {
685 return asCString();
686}
687
692public:
693 friend class Path;
694
697 PathArgument(const char* key);
698 PathArgument(String key);
699
700private:
701 enum Kind { kindNone = 0, kindIndex, kindKey };
702 String key_;
703 ArrayIndex index_{};
704 Kind kind_{kindNone};
705};
706
719public:
720 Path(const String& path, const PathArgument& a1 = PathArgument(),
721 const PathArgument& a2 = PathArgument(),
722 const PathArgument& a3 = PathArgument(),
723 const PathArgument& a4 = PathArgument(),
724 const PathArgument& a5 = PathArgument());
725
726 const Value& resolve(const Value& root) const;
727 Value resolve(const Value& root, const Value& defaultValue) const;
730 Value& make(Value& root) const;
731
732private:
733 using InArgs = std::vector<const PathArgument*>;
734 using Args = std::vector<PathArgument>;
735
736 void makePath(const String& path, const InArgs& in);
737 void addPathInArg(const String& path, const InArgs& in,
738 InArgs::const_iterator& itInArg, PathArgument::Kind kind);
739 static void invalidPath(const String& path, int location);
740
741 Args args_;
742};
743
748public:
749 using iterator_category = std::bidirectional_iterator_tag;
750 using size_t = unsigned int;
751 using difference_type = int;
753
754 bool operator==(const SelfType& other) const { return isEqual(other); }
755
756 bool operator!=(const SelfType& other) const { return !isEqual(other); }
757
758 difference_type operator-(const SelfType& other) const {
759 return other.computeDistance(*this);
760 }
761
764 Value key() const;
765
768 UInt index() const;
769
773 String name() const;
774
779 JSONCPP_DEPRECATED("Use `key = name();` instead.")
780 char const* memberName() const;
784 char const* memberName(char const** end) const;
785
786protected:
793 const Value& deref() const;
794 Value& deref();
795
796 void increment();
797
798 void decrement();
799
800 difference_type computeDistance(const SelfType& other) const;
801
802 bool isEqual(const SelfType& other) const;
803
804 void copy(const SelfType& other);
805
806private:
807 Value::ObjectValues::iterator current_;
808 // Indicates that iterator is for a null value.
809 bool isNull_{true};
810
811public:
812 // For some reason, BORLAND needs these at the end, rather
813 // than earlier. No idea why.
815 explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
816};
817
822 friend class Value;
823
824public:
825 using value_type = const Value;
826 // typedef unsigned int size_t;
827 // typedef int difference_type;
828 using reference = const Value&;
829 using pointer = const Value*;
831
833 ValueConstIterator(ValueIterator const& other);
834
835private:
838 explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
839
840public:
841 SelfType& operator=(const ValueIteratorBase& other);
842
844 SelfType temp(*this);
845 ++*this;
846 return temp;
847 }
848
850 SelfType temp(*this);
851 --*this;
852 return temp;
853 }
854
856 decrement();
857 return *this;
858 }
859
861 increment();
862 return *this;
863 }
864
865 reference operator*() const { return deref(); }
866
867 pointer operator->() const { return &deref(); }
868};
869
873 friend class Value;
874
875public:
877 using size_t = unsigned int;
878 using difference_type = int;
879 using reference = Value&;
880 using pointer = Value*;
882
884 explicit ValueIterator(const ValueConstIterator& other);
886
887private:
890 explicit ValueIterator(const Value::ObjectValues::iterator& current);
891
892public:
893 SelfType& operator=(const SelfType& other);
894
896 SelfType temp(*this);
897 ++*this;
898 return temp;
899 }
900
902 SelfType temp(*this);
903 --*this;
904 return temp;
905 }
906
908 decrement();
909 return *this;
910 }
911
913 increment();
914 return *this;
915 }
916
922 reference operator*() const { return const_cast<reference>(deref()); }
923 pointer operator->() const { return const_cast<pointer>(&deref()); }
924};
925
926inline void swap(Value& a, Value& b) { a.swap(b); }
927
928} // namespace Json
929
930#pragma pack(pop)
931
932#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
933#pragma warning(pop)
934#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
935
936#endif // JSON_H_INCLUDED
Base class for all exceptions we throw.
Definition: value.h:68
~Exception() noexcept override
Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
Definition: value.h:95
Experimental and untested: represents an element of the "path" to access a node.
Definition: value.h:691
Experimental and untested: represents a "path" to access a node.
Definition: value.h:718
Exceptions which the user cannot easily avoid.
Definition: value.h:84
Lightweight wrapper to tag static string.
Definition: value.h:148
const char * c_str() const
Definition: value.h:154
StaticString(const char *czstring)
Definition: value.h:150
const iterator for object and array value.
Definition: value.h:821
SelfType & operator--()
Definition: value.h:855
pointer operator->() const
Definition: value.h:867
SelfType operator--(int)
Definition: value.h:849
SelfType & operator++()
Definition: value.h:860
SelfType operator++(int)
Definition: value.h:843
reference operator*() const
Definition: value.h:865
Represents a JSON value.
Definition: value.h:194
Value(std::nullptr_t ptr)=delete
Json::ArrayIndex ArrayIndex
Definition: value.h:209
Json::UInt UInt
Definition: value.h:201
static const Value & null
Definition: value.h:216
void setComment(const char *comment, size_t len, CommentPlacement placement)
Comments must be //... or /* ... *‍/.
Definition: value.h:571
T as() const =delete
The as<T> and is<T> member function templates and specializations.
std::vector< String > Members
Definition: value.h:198
Json::LargestInt LargestInt
Definition: value.h:207
Json::LargestUInt LargestUInt
Definition: value.h:208
Json::UInt64 UInt64
Definition: value.h:204
void swap(Value &other)
Swap everything.
Definition: json_value.cpp:466
Json::Int Int
Definition: value.h:202
static const Value & nullRef
Definition: value.h:217
unsigned int value_type_
Definition: value.h:630
Json::Int64 Int64
Definition: value.h:205
unsigned int allocated_
Definition: value.h:632
std::string value_type
Definition: value.h:212
base class for Value iterators.
Definition: value.h:747
bool operator==(const SelfType &other) const
Definition: value.h:754
std::bidirectional_iterator_tag iterator_category
Definition: value.h:749
difference_type operator-(const SelfType &other) const
Definition: value.h:758
bool operator!=(const SelfType &other) const
Definition: value.h:756
difference_type computeDistance(const SelfType &other) const
Iterator for object and array value.
Definition: value.h:872
SelfType operator--(int)
Definition: value.h:901
SelfType & operator--()
Definition: value.h:907
reference operator*() const
Definition: value.h:922
SelfType & operator++()
Definition: value.h:912
ValueIterator(const ValueIterator &other)
pointer operator->() const
Definition: value.h:923
SelfType operator++(int)
Definition: value.h:895
#define JSON_API
If defined, indicates that the source file is amalgamated to prevent private header inclusion.
Definition: config.h:50
#define JSONCPP_DEPRECATED(message)
Definition: config.h:89
JSON (JavaScript Object Notation).
Definition: allocator.h:15
unsigned int ArrayIndex
Definition: forwards.h:32
std::basic_string< char, std::char_traits< char >, Allocator< char > > String
Definition: config.h:132
CommentPlacement
Definition: value.h:119
@ commentAfterOnSameLine
a comment just after a value on the same line
Definition: value.h:121
@ commentBefore
a comment placed on the line before a value
Definition: value.h:120
@ numberOfCommentPlacement
root value)
Definition: value.h:124
@ commentAfter
a comment on the line after a value (only make sense for
Definition: value.h:122
Int64 LargestInt
Definition: config.h:123
ValueType
Type of the value held by a Value object.
Definition: value.h:108
@ booleanValue
bool value
Definition: value.h:114
@ nullValue
'null' value
Definition: value.h:109
@ stringValue
UTF-8 string value.
Definition: value.h:113
@ realValue
double value
Definition: value.h:112
@ arrayValue
array value (ordered list)
Definition: value.h:115
@ intValue
signed integer value
Definition: value.h:110
@ objectValue
object value (collection of name/value pairs).
Definition: value.h:116
@ uintValue
unsigned integer value
Definition: value.h:111
bool operator==(const SecureAllocator< T > &, const SecureAllocator< U > &)
Definition: allocator.h:76
bool operator!=(const SecureAllocator< T > &, const SecureAllocator< U > &)
Definition: allocator.h:81
int Int
Definition: config.h:108
UInt64 LargestUInt
Definition: config.h:124
unsigned __int64 UInt64
Definition: config.h:118
unsigned int UInt
Definition: config.h:109
__int64 Int64
Definition: config.h:117
PrecisionType
Type of precision for formatting of real values.
Definition: value.h:129
@ decimalPlaces
we set max number of digits after "." in string
Definition: value.h:131
@ significantDigits
we set max number of significant digits in string
Definition: value.h:130
void swap(Value &a, Value &b)
Definition: value.h:926
#define JSONCPP_TEMPLATE_DELETE
Definition: value.h:38
#define JSONCPP_NORETURN
Definition: value.h:18