JSON for Modern C++  3.1.2
json.hpp
1 /*
2  __ _____ _____ _____
3  __| | __| | | | JSON for Modern C++
4 | | |__ | | | | | | version 3.1.2
5 |_____|_____|_____|_|___| https://github.com/nlohmann/json
6 
7 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
8 Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.
9 
10 Permission is hereby granted, free of charge, to any person obtaining a copy
11 of this software and associated documentation files (the "Software"), to deal
12 in the Software without restriction, including without limitation the rights
13 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 copies of the Software, and to permit persons to whom the Software is
15 furnished to do so, subject to the following conditions:
16 
17 The above copyright notice and this permission notice shall be included in all
18 copies or substantial portions of the Software.
19 
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 SOFTWARE.
27 */
28 
29 #ifndef NLOHMANN_JSON_HPP
30 #define NLOHMANN_JSON_HPP
31 
32 #define NLOHMANN_JSON_VERSION_MAJOR 3
33 #define NLOHMANN_JSON_VERSION_MINOR 1
34 #define NLOHMANN_JSON_VERSION_PATCH 2
35 
36 #include <algorithm> // all_of, find, for_each
37 #include <cassert> // assert
38 #include <ciso646> // and, not, or
39 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
40 #include <functional> // hash, less
41 #include <initializer_list> // initializer_list
42 #include <iosfwd> // istream, ostream
43 #include <iterator> // iterator_traits, random_access_iterator_tag
44 #include <numeric> // accumulate
45 #include <string> // string, stoi, to_string
46 #include <utility> // declval, forward, move, pair, swap
47 
48 // #include <nlohmann/json_fwd.hpp>
49 #ifndef NLOHMANN_JSON_FWD_HPP
50 #define NLOHMANN_JSON_FWD_HPP
51 
52 #include <cstdint> // int64_t, uint64_t
53 #include <map> // map
54 #include <memory> // allocator
55 #include <string> // string
56 #include <vector> // vector
57 
58 /*!
59 @brief namespace for Niels Lohmann
60 @see https://github.com/nlohmann
61 @since version 1.0.0
62 */
63 namespace nlohmann
64 {
65 /*!
66 @brief default JSONSerializer template argument
67 
68 This serializer ignores the template arguments and uses ADL
69 ([argument-dependent lookup](http://en.cppreference.com/w/cpp/language/adl))
70 for serialization.
71 */
72 template<typename = void, typename = void>
73 struct adl_serializer;
74 
75 template<template<typename U, typename V, typename... Args> class ObjectType =
76  std::map,
77  template<typename U, typename... Args> class ArrayType = std::vector,
78  class StringType = std::string, class BooleanType = bool,
79  class NumberIntegerType = std::int64_t,
80  class NumberUnsignedType = std::uint64_t,
81  class NumberFloatType = double,
82  template<typename U> class AllocatorType = std::allocator,
83  template<typename T, typename SFINAE = void> class JSONSerializer =
84  adl_serializer>
85 class basic_json;
86 
87 /*!
88 @brief JSON Pointer
89 
90 A JSON pointer defines a string syntax for identifying a specific value
91 within a JSON document. It can be used with functions `at` and
92 `operator[]`. Furthermore, JSON pointers are the base for JSON patches.
93 
94 @sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
95 
96 @since version 2.0.0
97 */
98 template<typename BasicJsonType>
99 class json_pointer;
100 
101 /*!
102 @brief default JSON class
103 
104 This type is the default specialization of the @ref basic_json class which
105 uses the standard template types.
106 
107 @since version 1.0.0
108 */
109 using json = basic_json<>;
110 }
111 
112 #endif
113 
114 // #include <nlohmann/detail/macro_scope.hpp>
115 
116 
117 // This file contains all internal macro definitions
118 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
119 
120 // exclude unsupported compilers
121 #if defined(__clang__)
122  #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
123  #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
124  #endif
125 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
126  #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900
127  #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
128  #endif
129 #endif
130 
131 // disable float-equal warnings on GCC/clang
132 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
133  #pragma GCC diagnostic push
134  #pragma GCC diagnostic ignored "-Wfloat-equal"
135 #endif
136 
137 // disable documentation warnings on clang
138 #if defined(__clang__)
139  #pragma GCC diagnostic push
140  #pragma GCC diagnostic ignored "-Wdocumentation"
141 #endif
142 
143 // allow for portable deprecation warnings
144 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
145  #define JSON_DEPRECATED __attribute__((deprecated))
146 #elif defined(_MSC_VER)
147  #define JSON_DEPRECATED __declspec(deprecated)
148 #else
149  #define JSON_DEPRECATED
150 #endif
151 
152 // allow to disable exceptions
153 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
154  #define JSON_THROW(exception) throw exception
155  #define JSON_TRY try
156  #define JSON_CATCH(exception) catch(exception)
157 #else
158  #define JSON_THROW(exception) std::abort()
159  #define JSON_TRY if(true)
160  #define JSON_CATCH(exception) if(false)
161 #endif
162 
163 // override exception macros
164 #if defined(JSON_THROW_USER)
165  #undef JSON_THROW
166  #define JSON_THROW JSON_THROW_USER
167 #endif
168 #if defined(JSON_TRY_USER)
169  #undef JSON_TRY
170  #define JSON_TRY JSON_TRY_USER
171 #endif
172 #if defined(JSON_CATCH_USER)
173  #undef JSON_CATCH
174  #define JSON_CATCH JSON_CATCH_USER
175 #endif
176 
177 // manual branch prediction
178 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
179  #define JSON_LIKELY(x) __builtin_expect(!!(x), 1)
180  #define JSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
181 #else
182  #define JSON_LIKELY(x) x
183  #define JSON_UNLIKELY(x) x
184 #endif
185 
186 // C++ language standard detection
187 #if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
188  #define JSON_HAS_CPP_17
189  #define JSON_HAS_CPP_14
190 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
191  #define JSON_HAS_CPP_14
192 #endif
193 
194 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
195 // may be removed in the future once the class is split.
196 
197 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION
198  template<template<typename, typename, typename...> class ObjectType,
199  template<typename, typename...> class ArrayType,
200  class StringType, class BooleanType, class NumberIntegerType,
201  class NumberUnsignedType, class NumberFloatType,
202  template<typename> class AllocatorType,
203  template<typename, typename = void> class JSONSerializer>
204 
205 #define NLOHMANN_BASIC_JSON_TPL
206  basic_json<ObjectType, ArrayType, StringType, BooleanType,
207  NumberIntegerType, NumberUnsignedType, NumberFloatType,
208  AllocatorType, JSONSerializer>
209 
210 /*!
211 @brief Helper to determine whether there's a key_type for T.
212 
213 This helper is used to tell associative containers apart from other containers
214 such as sequence containers. For instance, `std::map` passes the test as it
215 contains a `mapped_type`, whereas `std::vector` fails the test.
216 
217 @sa http://stackoverflow.com/a/7728728/266378
218 @since version 1.0.0, overworked in version 2.0.6
219 */
220 #define NLOHMANN_JSON_HAS_HELPER(type)
221  template<typename T> struct has_##type {
222  private:
223  template<typename U, typename = typename U::type>
224  static int detect(U &&);
225  static void detect(...);
226  public:
227  static constexpr bool value =
228  std::is_integral<decltype(detect(std::declval<T>()))>::value;
229  }
230 
231 // #include <nlohmann/detail/meta.hpp>
232 
233 
234 #include <ciso646> // not
235 #include <cstddef> // size_t
236 #include <limits> // numeric_limits
237 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
238 #include <utility> // declval
239 
240 // #include <nlohmann/json_fwd.hpp>
241 
242 // #include <nlohmann/detail/macro_scope.hpp>
243 
244 
245 namespace nlohmann
246 {
247 /*!
248 @brief detail namespace with internal helper functions
249 
250 This namespace collects functions that should not be exposed,
251 implementations of some @ref basic_json methods, and meta-programming helpers.
252 
253 @since version 2.1.0
254 */
255 namespace detail
256 {
257 /////////////
258 // helpers //
259 /////////////
260 
261 template<typename> struct is_basic_json : std::false_type {};
262 
264 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
265 
266 // alias templates to reduce boilerplate
267 template<bool B, typename T = void>
268 using enable_if_t = typename std::enable_if<B, T>::type;
269 
270 template<typename T>
271 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
272 
273 // implementation of C++14 index_sequence and affiliates
274 // source: https://stackoverflow.com/a/32223343
275 template<std::size_t... Ints>
276 struct index_sequence
277 {
278  using type = index_sequence;
279  using value_type = std::size_t;
280  static constexpr std::size_t size() noexcept
281  {
282  return sizeof...(Ints);
283  }
284 };
285 
286 template<class Sequence1, class Sequence2>
287 struct merge_and_renumber;
288 
289 template<std::size_t... I1, std::size_t... I2>
290 struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
291  : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
292 
293 template<std::size_t N>
294 struct make_index_sequence
295  : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
296  typename make_index_sequence < N - N / 2 >::type > {};
297 
298 template<> struct make_index_sequence<0> : index_sequence<> {};
299 template<> struct make_index_sequence<1> : index_sequence<0> {};
300 
301 template<typename... Ts>
302 using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
303 
304 /*
305 Implementation of two C++17 constructs: conjunction, negation. This is needed
306 to avoid evaluating all the traits in a condition
307 
308 For example: not std::is_same<void, T>::value and has_value_type<T>::value
309 will not compile when T = void (on MSVC at least). Whereas
310 conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value will
311 stop evaluating if negation<...>::value == false
312 
313 Please note that those constructs must be used with caution, since symbols can
314 become very long quickly (which can slow down compilation and cause MSVC
315 internal compiler errors). Only use it when you have to (see example ahead).
316 */
317 template<class...> struct conjunction : std::true_type {};
318 template<class B1> struct conjunction<B1> : B1 {};
319 template<class B1, class... Bn>
320 struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
321 
322 template<class B> struct negation : std::integral_constant<bool, not B::value> {};
323 
324 // dispatch utility (taken from ranges-v3)
325 template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
326 template<> struct priority_tag<0> {};
327 
328 ////////////////////////
329 // has_/is_ functions //
330 ////////////////////////
331 
332 // source: https://stackoverflow.com/a/37193089/4116453
333 
334 template <typename T, typename = void>
335 struct is_complete_type : std::false_type {};
336 
337 template <typename T>
338 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
339 
340 NLOHMANN_JSON_HAS_HELPER(mapped_type);
341 NLOHMANN_JSON_HAS_HELPER(key_type);
342 NLOHMANN_JSON_HAS_HELPER(value_type);
343 NLOHMANN_JSON_HAS_HELPER(iterator);
344 
345 template<bool B, class RealType, class CompatibleObjectType>
346 struct is_compatible_object_type_impl : std::false_type {};
347 
348 template<class RealType, class CompatibleObjectType>
349 struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>
350 {
351  static constexpr auto value =
352  std::is_constructible<typename RealType::key_type, typename CompatibleObjectType::key_type>::value and
353  std::is_constructible<typename RealType::mapped_type, typename CompatibleObjectType::mapped_type>::value;
354 };
355 
356 template<class BasicJsonType, class CompatibleObjectType>
357 struct is_compatible_object_type
358 {
359  static auto constexpr value = is_compatible_object_type_impl <
360  conjunction<negation<std::is_same<void, CompatibleObjectType>>,
361  has_mapped_type<CompatibleObjectType>,
362  has_key_type<CompatibleObjectType>>::value,
363  typename BasicJsonType::object_t, CompatibleObjectType >::value;
364 };
365 
366 template<typename BasicJsonType, typename T>
367 struct is_basic_json_nested_type
368 {
369  static auto constexpr value = std::is_same<T, typename BasicJsonType::iterator>::value or
370  std::is_same<T, typename BasicJsonType::const_iterator>::value or
371  std::is_same<T, typename BasicJsonType::reverse_iterator>::value or
372  std::is_same<T, typename BasicJsonType::const_reverse_iterator>::value;
373 };
374 
375 template<class BasicJsonType, class CompatibleArrayType>
376 struct is_compatible_array_type
377 {
378  static auto constexpr value =
379  conjunction<negation<std::is_same<void, CompatibleArrayType>>,
380  negation<is_compatible_object_type<
381  BasicJsonType, CompatibleArrayType>>,
382  negation<std::is_constructible<typename BasicJsonType::string_t,
383  CompatibleArrayType>>,
384  negation<is_basic_json_nested_type<BasicJsonType, CompatibleArrayType>>,
385  has_value_type<CompatibleArrayType>,
386  has_iterator<CompatibleArrayType>>::value;
387 };
388 
389 template<bool, typename, typename>
390 struct is_compatible_integer_type_impl : std::false_type {};
391 
392 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
393 struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType>
394 {
395  // is there an assert somewhere on overflows?
396  using RealLimits = std::numeric_limits<RealIntegerType>;
397  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
398 
399  static constexpr auto value =
400  std::is_constructible<RealIntegerType, CompatibleNumberIntegerType>::value and
401  CompatibleLimits::is_integer and
402  RealLimits::is_signed == CompatibleLimits::is_signed;
403 };
404 
405 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
406 struct is_compatible_integer_type
407 {
408  static constexpr auto value =
409  is_compatible_integer_type_impl <
410  std::is_integral<CompatibleNumberIntegerType>::value and
411  not std::is_same<bool, CompatibleNumberIntegerType>::value,
412  RealIntegerType, CompatibleNumberIntegerType > ::value;
413 };
414 
415 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
416 template<typename BasicJsonType, typename T>
417 struct has_from_json
418 {
419  private:
420  // also check the return type of from_json
421  template<typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
422  std::declval<BasicJsonType>(), std::declval<T&>()))>::value>>
423  static int detect(U&&);
424  static void detect(...);
425 
426  public:
427  static constexpr bool value = std::is_integral<decltype(
428  detect(std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
429 };
430 
431 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
432 // this overload is used for non-default-constructible user-defined-types
433 template<typename BasicJsonType, typename T>
434 struct has_non_default_from_json
435 {
436  private:
437  template <
438  typename U,
439  typename = enable_if_t<std::is_same<
440  T, decltype(uncvref_t<U>::from_json(std::declval<BasicJsonType>()))>::value >>
441  static int detect(U&&);
442  static void detect(...);
443 
444  public:
445  static constexpr bool value = std::is_integral<decltype(detect(
446  std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
447 };
448 
449 // This trait checks if BasicJsonType::json_serializer<T>::to_json exists
450 template<typename BasicJsonType, typename T>
451 struct has_to_json
452 {
453  private:
454  template<typename U, typename = decltype(uncvref_t<U>::to_json(
455  std::declval<BasicJsonType&>(), std::declval<T>()))>
456  static int detect(U&&);
457  static void detect(...);
458 
459  public:
460  static constexpr bool value = std::is_integral<decltype(detect(
461  std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
462 };
463 
464 template <typename BasicJsonType, typename CompatibleCompleteType>
465 struct is_compatible_complete_type
466 {
467  static constexpr bool value =
468  not std::is_base_of<std::istream, CompatibleCompleteType>::value and
469  not is_basic_json<CompatibleCompleteType>::value and
470  not is_basic_json_nested_type<BasicJsonType, CompatibleCompleteType>::value and
471  has_to_json<BasicJsonType, CompatibleCompleteType>::value;
472 };
473 
474 template <typename BasicJsonType, typename CompatibleType>
475 struct is_compatible_type
476  : conjunction<is_complete_type<CompatibleType>,
477  is_compatible_complete_type<BasicJsonType, CompatibleType>>
478 {
479 };
480 
481 // taken from ranges-v3
482 template<typename T>
483 struct static_const
484 {
485  static constexpr T value{};
486 };
487 
488 template<typename T>
489 constexpr T static_const<T>::value;
490 }
491 }
492 
493 // #include <nlohmann/detail/exceptions.hpp>
494 
495 
496 #include <exception> // exception
497 #include <stdexcept> // runtime_error
498 #include <string> // to_string
499 
500 namespace nlohmann
501 {
502 namespace detail
503 {
504 ////////////////
505 // exceptions //
506 ////////////////
507 
508 /*!
509 @brief general exception of the @ref basic_json class
510 
511 This class is an extension of `std::exception` objects with a member @a id for
512 exception ids. It is used as the base class for all exceptions thrown by the
513 @ref basic_json class. This class can hence be used as "wildcard" to catch
514 exceptions.
515 
516 Subclasses:
517 - @ref parse_error for exceptions indicating a parse error
518 - @ref invalid_iterator for exceptions indicating errors with iterators
519 - @ref type_error for exceptions indicating executing a member function with
520  a wrong type
521 - @ref out_of_range for exceptions indicating access out of the defined range
522 - @ref other_error for exceptions indicating other library errors
523 
524 @internal
525 @note To have nothrow-copy-constructible exceptions, we internally use
526  `std::runtime_error` which can cope with arbitrary-length error messages.
527  Intermediate strings are built with static functions and then passed to
528  the actual constructor.
529 @endinternal
530 
531 @liveexample{The following code shows how arbitrary library exceptions can be
532 caught.,exception}
533 
534 @since version 3.0.0
535 */
536 class exception : public std::exception
537 {
538  public:
539  /// returns the explanatory string
540  const char* what() const noexcept override
541  {
542  return m.what();
543  }
544 
545  /// the id of the exception
546  const int id;
547 
548  protected:
549  exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
550 
551  static std::string name(const std::string& ename, int id_)
552  {
553  return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
554  }
555 
556  private:
557  /// an exception object as storage for error messages
558  std::runtime_error m;
559 };
560 
561 /*!
562 @brief exception indicating a parse error
563 
564 This exception is thrown by the library when a parse error occurs. Parse errors
565 can occur during the deserialization of JSON text, CBOR, MessagePack, as well
566 as when using JSON Patch.
567 
568 Member @a byte holds the byte index of the last read character in the input
569 file.
570 
571 Exceptions have ids 1xx.
572 
573 name / id | example message | description
574 ------------------------------ | --------------- | -------------------------
575 json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
576 json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
577 json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
578 json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
579 json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
580 json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
581 json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
582 json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
583 json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
584 json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
585 json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
586 json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
587 
588 @note For an input with n bytes, 1 is the index of the first character and n+1
589  is the index of the terminating null byte or the end of file. This also
590  holds true when reading a byte vector (CBOR or MessagePack).
591 
592 @liveexample{The following code shows how a `parse_error` exception can be
593 caught.,parse_error}
594 
595 @sa @ref exception for the base class of the library exceptions
596 @sa @ref invalid_iterator for exceptions indicating errors with iterators
597 @sa @ref type_error for exceptions indicating executing a member function with
598  a wrong type
599 @sa @ref out_of_range for exceptions indicating access out of the defined range
600 @sa @ref other_error for exceptions indicating other library errors
601 
602 @since version 3.0.0
603 */
604 class parse_error : public exception
605 {
606  public:
607  /*!
608  @brief create a parse error exception
609  @param[in] id_ the id of the exception
610  @param[in] byte_ the byte index where the error occurred (or 0 if the
611  position cannot be determined)
612  @param[in] what_arg the explanatory string
613  @return parse_error object
614  */
615  static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
616  {
617  std::string w = exception::name("parse_error", id_) + "parse error" +
618  (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +
619  ": " + what_arg;
620  return parse_error(id_, byte_, w.c_str());
621  }
622 
623  /*!
624  @brief byte index of the parse error
625 
626  The byte index of the last read character in the input file.
627 
628  @note For an input with n bytes, 1 is the index of the first character and
629  n+1 is the index of the terminating null byte or the end of file.
630  This also holds true when reading a byte vector (CBOR or MessagePack).
631  */
632  const std::size_t byte;
633 
634  private:
635  parse_error(int id_, std::size_t byte_, const char* what_arg)
636  : exception(id_, what_arg), byte(byte_) {}
637 };
638 
639 /*!
640 @brief exception indicating errors with iterators
641 
642 This exception is thrown if iterators passed to a library function do not match
643 the expected semantics.
644 
645 Exceptions have ids 2xx.
646 
647 name / id | example message | description
648 ----------------------------------- | --------------- | -------------------------
649 json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
650 json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
651 json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
652 json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
653 json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
654 json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
655 json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
656 json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
657 json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
658 json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
659 json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
660 json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
661 json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
662 json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
663 
664 @liveexample{The following code shows how an `invalid_iterator` exception can be
665 caught.,invalid_iterator}
666 
667 @sa @ref exception for the base class of the library exceptions
668 @sa @ref parse_error for exceptions indicating a parse error
669 @sa @ref type_error for exceptions indicating executing a member function with
670  a wrong type
671 @sa @ref out_of_range for exceptions indicating access out of the defined range
672 @sa @ref other_error for exceptions indicating other library errors
673 
674 @since version 3.0.0
675 */
676 class invalid_iterator : public exception
677 {
678  public:
679  static invalid_iterator create(int id_, const std::string& what_arg)
680  {
681  std::string w = exception::name("invalid_iterator", id_) + what_arg;
682  return invalid_iterator(id_, w.c_str());
683  }
684 
685  private:
686  invalid_iterator(int id_, const char* what_arg)
687  : exception(id_, what_arg) {}
688 };
689 
690 /*!
691 @brief exception indicating executing a member function with a wrong type
692 
693 This exception is thrown in case of a type error; that is, a library function is
694 executed on a JSON value whose type does not match the expected semantics.
695 
696 Exceptions have ids 3xx.
697 
698 name / id | example message | description
699 ----------------------------- | --------------- | -------------------------
700 json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
701 json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
702 json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t&.
703 json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
704 json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
705 json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
706 json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
707 json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
708 json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
709 json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
710 json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
711 json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
712 json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
713 json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
714 json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
715 json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
716 
717 @liveexample{The following code shows how a `type_error` exception can be
718 caught.,type_error}
719 
720 @sa @ref exception for the base class of the library exceptions
721 @sa @ref parse_error for exceptions indicating a parse error
722 @sa @ref invalid_iterator for exceptions indicating errors with iterators
723 @sa @ref out_of_range for exceptions indicating access out of the defined range
724 @sa @ref other_error for exceptions indicating other library errors
725 
726 @since version 3.0.0
727 */
728 class type_error : public exception
729 {
730  public:
731  static type_error create(int id_, const std::string& what_arg)
732  {
733  std::string w = exception::name("type_error", id_) + what_arg;
734  return type_error(id_, w.c_str());
735  }
736 
737  private:
738  type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
739 };
740 
741 /*!
742 @brief exception indicating access out of the defined range
743 
744 This exception is thrown in case a library function is called on an input
745 parameter that exceeds the expected range, for instance in case of array
746 indices or nonexisting object keys.
747 
748 Exceptions have ids 4xx.
749 
750 name / id | example message | description
751 ------------------------------- | --------------- | -------------------------
752 json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
753 json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
754 json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
755 json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
756 json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
757 json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
758 json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON only supports integers numbers up to 9223372036854775807. |
759 json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
760 
761 @liveexample{The following code shows how an `out_of_range` exception can be
762 caught.,out_of_range}
763 
764 @sa @ref exception for the base class of the library exceptions
765 @sa @ref parse_error for exceptions indicating a parse error
766 @sa @ref invalid_iterator for exceptions indicating errors with iterators
767 @sa @ref type_error for exceptions indicating executing a member function with
768  a wrong type
769 @sa @ref other_error for exceptions indicating other library errors
770 
771 @since version 3.0.0
772 */
773 class out_of_range : public exception
774 {
775  public:
776  static out_of_range create(int id_, const std::string& what_arg)
777  {
778  std::string w = exception::name("out_of_range", id_) + what_arg;
779  return out_of_range(id_, w.c_str());
780  }
781 
782  private:
783  out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
784 };
785 
786 /*!
787 @brief exception indicating other library errors
788 
789 This exception is thrown in case of errors that cannot be classified with the
790 other exception types.
791 
792 Exceptions have ids 5xx.
793 
794 name / id | example message | description
795 ------------------------------ | --------------- | -------------------------
796 json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
797 
798 @sa @ref exception for the base class of the library exceptions
799 @sa @ref parse_error for exceptions indicating a parse error
800 @sa @ref invalid_iterator for exceptions indicating errors with iterators
801 @sa @ref type_error for exceptions indicating executing a member function with
802  a wrong type
803 @sa @ref out_of_range for exceptions indicating access out of the defined range
804 
805 @liveexample{The following code shows how an `other_error` exception can be
806 caught.,other_error}
807 
808 @since version 3.0.0
809 */
810 class other_error : public exception
811 {
812  public:
813  static other_error create(int id_, const std::string& what_arg)
814  {
815  std::string w = exception::name("other_error", id_) + what_arg;
816  return other_error(id_, w.c_str());
817  }
818 
819  private:
820  other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
821 };
822 }
823 }
824 
825 // #include <nlohmann/detail/value_t.hpp>
826 
827 
828 #include <array> // array
829 #include <ciso646> // and
830 #include <cstddef> // size_t
831 #include <cstdint> // uint8_t
832 
833 namespace nlohmann
834 {
835 namespace detail
836 {
837 ///////////////////////////
838 // JSON type enumeration //
839 ///////////////////////////
840 
841 /*!
842 @brief the JSON type enumeration
843 
844 This enumeration collects the different JSON types. It is internally used to
845 distinguish the stored values, and the functions @ref basic_json::is_null(),
846 @ref basic_json::is_object(), @ref basic_json::is_array(),
847 @ref basic_json::is_string(), @ref basic_json::is_boolean(),
848 @ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
849 @ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
850 @ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
851 @ref basic_json::is_structured() rely on it.
852 
853 @note There are three enumeration entries (number_integer, number_unsigned, and
854 number_float), because the library distinguishes these three types for numbers:
855 @ref basic_json::number_unsigned_t is used for unsigned integers,
856 @ref basic_json::number_integer_t is used for signed integers, and
857 @ref basic_json::number_float_t is used for floating-point numbers or to
858 approximate integers which do not fit in the limits of their respective type.
859 
860 @sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
861 value with the default value for a given type
862 
863 @since version 1.0.0
864 */
865 enum class value_t : std::uint8_t
866 {
867  null, ///< null value
868  object, ///< object (unordered set of name/value pairs)
869  array, ///< array (ordered collection of values)
870  string, ///< string value
871  boolean, ///< boolean value
872  number_integer, ///< number value (signed integer)
873  number_unsigned, ///< number value (unsigned integer)
874  number_float, ///< number value (floating-point)
875  discarded ///< discarded by the the parser callback function
876 };
877 
878 /*!
879 @brief comparison operator for JSON types
880 
881 Returns an ordering that is similar to Python:
882 - order: null < boolean < number < object < array < string
883 - furthermore, each type is not smaller than itself
884 - discarded values are not comparable
885 
886 @since version 1.0.0
887 */
888 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
889 {
890  static constexpr std::array<std::uint8_t, 8> order = {{
891  0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
892  1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */
893  }
894  };
895 
896  const auto l_index = static_cast<std::size_t>(lhs);
897  const auto r_index = static_cast<std::size_t>(rhs);
898  return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
899 }
900 }
901 }
902 
903 // #include <nlohmann/detail/conversions/from_json.hpp>
904 
905 
906 #include <algorithm> // transform
907 #include <array> // array
908 #include <ciso646> // and, not
909 #include <forward_list> // forward_list
910 #include <iterator> // inserter, front_inserter, end
911 #include <string> // string
912 #include <tuple> // tuple, make_tuple
913 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
914 #include <utility> // pair, declval
915 #include <valarray> // valarray
916 
917 // #include <nlohmann/detail/exceptions.hpp>
918 
919 // #include <nlohmann/detail/macro_scope.hpp>
920 
921 // #include <nlohmann/detail/meta.hpp>
922 
923 // #include <nlohmann/detail/value_t.hpp>
924 
925 
926 namespace nlohmann
927 {
928 namespace detail
929 {
930 // overloads for basic_json template parameters
931 template<typename BasicJsonType, typename ArithmeticType,
932  enable_if_t<std::is_arithmetic<ArithmeticType>::value and
933  not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
934  int> = 0>
935 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
936 {
937  switch (static_cast<value_t>(j))
938  {
939  case value_t::number_unsigned:
940  {
941  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
942  break;
943  }
944  case value_t::number_integer:
945  {
946  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
947  break;
948  }
949  case value_t::number_float:
950  {
951  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
952  break;
953  }
954 
955  default:
956  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
957  }
958 }
959 
960 template<typename BasicJsonType>
961 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
962 {
963  if (JSON_UNLIKELY(not j.is_boolean()))
964  {
965  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
966  }
967  b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
968 }
969 
970 template<typename BasicJsonType>
971 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
972 {
973  if (JSON_UNLIKELY(not j.is_string()))
974  {
975  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
976  }
977  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
978 }
979 
980 template<typename BasicJsonType>
981 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
982 {
983  get_arithmetic_value(j, val);
984 }
985 
986 template<typename BasicJsonType>
987 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
988 {
989  get_arithmetic_value(j, val);
990 }
991 
992 template<typename BasicJsonType>
993 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
994 {
995  get_arithmetic_value(j, val);
996 }
997 
998 template<typename BasicJsonType, typename EnumType,
999  enable_if_t<std::is_enum<EnumType>::value, int> = 0>
1000 void from_json(const BasicJsonType& j, EnumType& e)
1001 {
1002  typename std::underlying_type<EnumType>::type val;
1003  get_arithmetic_value(j, val);
1004  e = static_cast<EnumType>(val);
1005 }
1006 
1007 template<typename BasicJsonType>
1008 void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr)
1009 {
1010  if (JSON_UNLIKELY(not j.is_array()))
1011  {
1012  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
1013  }
1014  arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
1015 }
1016 
1017 // forward_list doesn't have an insert method
1018 template<typename BasicJsonType, typename T, typename Allocator,
1019  enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
1020 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
1021 {
1022  if (JSON_UNLIKELY(not j.is_array()))
1023  {
1024  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
1025  }
1026  std::transform(j.rbegin(), j.rend(),
1027  std::front_inserter(l), [](const BasicJsonType & i)
1028  {
1029  return i.template get<T>();
1030  });
1031 }
1032 
1033 // valarray doesn't have an insert method
1034 template<typename BasicJsonType, typename T,
1035  enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
1036 void from_json(const BasicJsonType& j, std::valarray<T>& l)
1037 {
1038  if (JSON_UNLIKELY(not j.is_array()))
1039  {
1040  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
1041  }
1042  l.resize(j.size());
1043  std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
1044 }
1045 
1046 template<typename BasicJsonType, typename CompatibleArrayType>
1047 void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0> /*unused*/)
1048 {
1049  using std::end;
1050 
1051  std::transform(j.begin(), j.end(),
1052  std::inserter(arr, end(arr)), [](const BasicJsonType & i)
1053  {
1054  // get<BasicJsonType>() returns *this, this won't call a from_json
1055  // method when value_type is BasicJsonType
1056  return i.template get<typename CompatibleArrayType::value_type>();
1057  });
1058 }
1059 
1060 template<typename BasicJsonType, typename CompatibleArrayType>
1061 auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /*unused*/)
1062 -> decltype(
1063  arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
1064  void())
1065 {
1066  using std::end;
1067 
1068  arr.reserve(j.size());
1069  std::transform(j.begin(), j.end(),
1070  std::inserter(arr, end(arr)), [](const BasicJsonType & i)
1071  {
1072  // get<BasicJsonType>() returns *this, this won't call a from_json
1073  // method when value_type is BasicJsonType
1074  return i.template get<typename CompatibleArrayType::value_type>();
1075  });
1076 }
1077 
1078 template<typename BasicJsonType, typename T, std::size_t N>
1079 void from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr, priority_tag<2> /*unused*/)
1080 {
1081  for (std::size_t i = 0; i < N; ++i)
1082  {
1083  arr[i] = j.at(i).template get<T>();
1084  }
1085 }
1086 
1087 template <
1088  typename BasicJsonType, typename CompatibleArrayType,
1089  enable_if_t <
1090  is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and
1091  not std::is_same<typename BasicJsonType::array_t,
1092  CompatibleArrayType>::value and
1093  std::is_constructible <
1094  BasicJsonType, typename CompatibleArrayType::value_type >::value,
1095  int > = 0 >
1096 void from_json(const BasicJsonType& j, CompatibleArrayType& arr)
1097 {
1098  if (JSON_UNLIKELY(not j.is_array()))
1099  {
1100  JSON_THROW(type_error::create(302, "type must be array, but is " +
1101  std::string(j.type_name())));
1102  }
1103 
1104  from_json_array_impl(j, arr, priority_tag<2> {});
1105 }
1106 
1107 template<typename BasicJsonType, typename CompatibleObjectType,
1108  enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>
1109 void from_json(const BasicJsonType& j, CompatibleObjectType& obj)
1110 {
1111  if (JSON_UNLIKELY(not j.is_object()))
1112  {
1113  JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
1114  }
1115 
1116  auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
1117  using value_type = typename CompatibleObjectType::value_type;
1118  std::transform(
1119  inner_object->begin(), inner_object->end(),
1120  std::inserter(obj, obj.begin()),
1121  [](typename BasicJsonType::object_t::value_type const & p)
1122  {
1123  return value_type(p.first, p.second.template get<typename CompatibleObjectType::mapped_type>());
1124  });
1125 }
1126 
1127 // overload for arithmetic types, not chosen for basic_json template arguments
1128 // (BooleanType, etc..); note: Is it really necessary to provide explicit
1129 // overloads for boolean_t etc. in case of a custom BooleanType which is not
1130 // an arithmetic type?
1131 template<typename BasicJsonType, typename ArithmeticType,
1132  enable_if_t <
1133  std::is_arithmetic<ArithmeticType>::value and
1134  not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
1135  not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
1136  not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
1137  not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
1138  int> = 0>
1139 void from_json(const BasicJsonType& j, ArithmeticType& val)
1140 {
1141  switch (static_cast<value_t>(j))
1142  {
1143  case value_t::number_unsigned:
1144  {
1145  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
1146  break;
1147  }
1148  case value_t::number_integer:
1149  {
1150  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
1151  break;
1152  }
1153  case value_t::number_float:
1154  {
1155  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
1156  break;
1157  }
1158  case value_t::boolean:
1159  {
1160  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
1161  break;
1162  }
1163 
1164  default:
1165  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
1166  }
1167 }
1168 
1169 template<typename BasicJsonType, typename A1, typename A2>
1170 void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
1171 {
1172  p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
1173 }
1174 
1175 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
1176 void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)
1177 {
1178  t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
1179 }
1180 
1181 template<typename BasicJsonType, typename... Args>
1182 void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
1183 {
1184  from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
1185 }
1186 
1187 struct from_json_fn
1188 {
1189  private:
1190  template<typename BasicJsonType, typename T>
1191  auto call(const BasicJsonType& j, T& val, priority_tag<1> /*unused*/) const
1192  noexcept(noexcept(from_json(j, val)))
1193  -> decltype(from_json(j, val), void())
1194  {
1195  return from_json(j, val);
1196  }
1197 
1198  template<typename BasicJsonType, typename T>
1199  void call(const BasicJsonType& /*unused*/, T& /*unused*/, priority_tag<0> /*unused*/) const noexcept
1200  {
1201  static_assert(sizeof(BasicJsonType) == 0,
1202  "could not find from_json() method in T's namespace");
1203 #ifdef _MSC_VER
1204  // MSVC does not show a stacktrace for the above assert
1205  using decayed = uncvref_t<T>;
1206  static_assert(sizeof(typename decayed::force_msvc_stacktrace) == 0,
1207  "forcing MSVC stacktrace to show which T we're talking about.");
1208 #endif
1209  }
1210 
1211  public:
1212  template<typename BasicJsonType, typename T>
1213  void operator()(const BasicJsonType& j, T& val) const
1214  noexcept(noexcept(std::declval<from_json_fn>().call(j, val, priority_tag<1> {})))
1215  {
1216  return call(j, val, priority_tag<1> {});
1217  }
1218 };
1219 }
1220 
1221 /// namespace to hold default `from_json` function
1222 /// to see why this is required:
1223 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
1224 namespace
1225 {
1226 constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
1227 }
1228 }
1229 
1230 // #include <nlohmann/detail/conversions/to_json.hpp>
1231 
1232 
1233 #include <ciso646> // or, and, not
1234 #include <iterator> // begin, end
1235 #include <tuple> // tuple, get
1236 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
1237 #include <utility> // move, forward, declval, pair
1238 #include <valarray> // valarray
1239 #include <vector> // vector
1240 
1241 // #include <nlohmann/detail/meta.hpp>
1242 
1243 // #include <nlohmann/detail/value_t.hpp>
1244 
1245 
1246 namespace nlohmann
1247 {
1248 namespace detail
1249 {
1250 //////////////////
1251 // constructors //
1252 //////////////////
1253 
1254 template<value_t> struct external_constructor;
1255 
1256 template<>
1257 struct external_constructor<value_t::boolean>
1258 {
1259  template<typename BasicJsonType>
1260  static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
1261  {
1262  j.m_type = value_t::boolean;
1263  j.m_value = b;
1264  j.assert_invariant();
1265  }
1266 };
1267 
1268 template<>
1269 struct external_constructor<value_t::string>
1270 {
1271  template<typename BasicJsonType>
1272  static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
1273  {
1274  j.m_type = value_t::string;
1275  j.m_value = s;
1276  j.assert_invariant();
1277  }
1278 
1279  template<typename BasicJsonType>
1280  static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
1281  {
1282  j.m_type = value_t::string;
1283  j.m_value = std::move(s);
1284  j.assert_invariant();
1285  }
1286 };
1287 
1288 template<>
1289 struct external_constructor<value_t::number_float>
1290 {
1291  template<typename BasicJsonType>
1292  static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
1293  {
1294  j.m_type = value_t::number_float;
1295  j.m_value = val;
1296  j.assert_invariant();
1297  }
1298 };
1299 
1300 template<>
1301 struct external_constructor<value_t::number_unsigned>
1302 {
1303  template<typename BasicJsonType>
1304  static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
1305  {
1306  j.m_type = value_t::number_unsigned;
1307  j.m_value = val;
1308  j.assert_invariant();
1309  }
1310 };
1311 
1312 template<>
1313 struct external_constructor<value_t::number_integer>
1314 {
1315  template<typename BasicJsonType>
1316  static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
1317  {
1318  j.m_type = value_t::number_integer;
1319  j.m_value = val;
1320  j.assert_invariant();
1321  }
1322 };
1323 
1324 template<>
1325 struct external_constructor<value_t::array>
1326 {
1327  template<typename BasicJsonType>
1328  static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
1329  {
1330  j.m_type = value_t::array;
1331  j.m_value = arr;
1332  j.assert_invariant();
1333  }
1334 
1335  template<typename BasicJsonType>
1336  static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
1337  {
1338  j.m_type = value_t::array;
1339  j.m_value = std::move(arr);
1340  j.assert_invariant();
1341  }
1342 
1343  template<typename BasicJsonType, typename CompatibleArrayType,
1344  enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
1345  int> = 0>
1346  static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
1347  {
1348  using std::begin;
1349  using std::end;
1350  j.m_type = value_t::array;
1351  j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
1352  j.assert_invariant();
1353  }
1354 
1355  template<typename BasicJsonType>
1356  static void construct(BasicJsonType& j, const std::vector<bool>& arr)
1357  {
1358  j.m_type = value_t::array;
1359  j.m_value = value_t::array;
1360  j.m_value.array->reserve(arr.size());
1361  for (const bool x : arr)
1362  {
1363  j.m_value.array->push_back(x);
1364  }
1365  j.assert_invariant();
1366  }
1367 
1368  template<typename BasicJsonType, typename T,
1369  enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
1370  static void construct(BasicJsonType& j, const std::valarray<T>& arr)
1371  {
1372  j.m_type = value_t::array;
1373  j.m_value = value_t::array;
1374  j.m_value.array->resize(arr.size());
1375  std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
1376  j.assert_invariant();
1377  }
1378 };
1379 
1380 template<>
1381 struct external_constructor<value_t::object>
1382 {
1383  template<typename BasicJsonType>
1384  static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
1385  {
1386  j.m_type = value_t::object;
1387  j.m_value = obj;
1388  j.assert_invariant();
1389  }
1390 
1391  template<typename BasicJsonType>
1392  static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
1393  {
1394  j.m_type = value_t::object;
1395  j.m_value = std::move(obj);
1396  j.assert_invariant();
1397  }
1398 
1399  template<typename BasicJsonType, typename CompatibleObjectType,
1400  enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>
1401  static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
1402  {
1403  using std::begin;
1404  using std::end;
1405 
1406  j.m_type = value_t::object;
1407  j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
1408  j.assert_invariant();
1409  }
1410 };
1411 
1412 /////////////
1413 // to_json //
1414 /////////////
1415 
1416 template<typename BasicJsonType, typename T,
1417  enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
1418 void to_json(BasicJsonType& j, T b) noexcept
1419 {
1420  external_constructor<value_t::boolean>::construct(j, b);
1421 }
1422 
1423 template<typename BasicJsonType, typename CompatibleString,
1424  enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
1425 void to_json(BasicJsonType& j, const CompatibleString& s)
1426 {
1427  external_constructor<value_t::string>::construct(j, s);
1428 }
1429 
1430 template<typename BasicJsonType>
1431 void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
1432 {
1433  external_constructor<value_t::string>::construct(j, std::move(s));
1434 }
1435 
1436 template<typename BasicJsonType, typename FloatType,
1437  enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
1438 void to_json(BasicJsonType& j, FloatType val) noexcept
1439 {
1440  external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
1441 }
1442 
1443 template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
1444  enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
1445 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
1446 {
1447  external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
1448 }
1449 
1450 template<typename BasicJsonType, typename CompatibleNumberIntegerType,
1451  enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
1452 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
1453 {
1454  external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
1455 }
1456 
1457 template<typename BasicJsonType, typename EnumType,
1458  enable_if_t<std::is_enum<EnumType>::value, int> = 0>
1459 void to_json(BasicJsonType& j, EnumType e) noexcept
1460 {
1461  using underlying_type = typename std::underlying_type<EnumType>::type;
1462  external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
1463 }
1464 
1465 template<typename BasicJsonType>
1466 void to_json(BasicJsonType& j, const std::vector<bool>& e)
1467 {
1468  external_constructor<value_t::array>::construct(j, e);
1469 }
1470 
1471 template<typename BasicJsonType, typename CompatibleArrayType,
1472  enable_if_t<is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value or
1473  std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value,
1474  int> = 0>
1475 void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
1476 {
1477  external_constructor<value_t::array>::construct(j, arr);
1478 }
1479 
1480 template<typename BasicJsonType, typename T,
1481  enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
1482 void to_json(BasicJsonType& j, std::valarray<T> arr)
1483 {
1484  external_constructor<value_t::array>::construct(j, std::move(arr));
1485 }
1486 
1487 template<typename BasicJsonType>
1488 void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
1489 {
1490  external_constructor<value_t::array>::construct(j, std::move(arr));
1491 }
1492 
1493 template<typename BasicJsonType, typename CompatibleObjectType,
1494  enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>
1495 void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
1496 {
1497  external_constructor<value_t::object>::construct(j, obj);
1498 }
1499 
1500 template<typename BasicJsonType>
1501 void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
1502 {
1503  external_constructor<value_t::object>::construct(j, std::move(obj));
1504 }
1505 
1506 template<typename BasicJsonType, typename T, std::size_t N,
1507  enable_if_t<not std::is_constructible<typename BasicJsonType::string_t, T (&)[N]>::value, int> = 0>
1508 void to_json(BasicJsonType& j, T (&arr)[N])
1509 {
1510  external_constructor<value_t::array>::construct(j, arr);
1511 }
1512 
1513 template<typename BasicJsonType, typename... Args>
1514 void to_json(BasicJsonType& j, const std::pair<Args...>& p)
1515 {
1516  j = {p.first, p.second};
1517 }
1518 
1519 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
1520 void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...>)
1521 {
1522  j = {std::get<Idx>(t)...};
1523 }
1524 
1525 template<typename BasicJsonType, typename... Args>
1526 void to_json(BasicJsonType& j, const std::tuple<Args...>& t)
1527 {
1528  to_json_tuple_impl(j, t, index_sequence_for<Args...> {});
1529 }
1530 
1531 struct to_json_fn
1532 {
1533  private:
1534  template<typename BasicJsonType, typename T>
1535  auto call(BasicJsonType& j, T&& val, priority_tag<1> /*unused*/) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
1536  -> decltype(to_json(j, std::forward<T>(val)), void())
1537  {
1538  return to_json(j, std::forward<T>(val));
1539  }
1540 
1541  template<typename BasicJsonType, typename T>
1542  void call(BasicJsonType& /*unused*/, T&& /*unused*/, priority_tag<0> /*unused*/) const noexcept
1543  {
1544  static_assert(sizeof(BasicJsonType) == 0,
1545  "could not find to_json() method in T's namespace");
1546 
1547 #ifdef _MSC_VER
1548  // MSVC does not show a stacktrace for the above assert
1549  using decayed = uncvref_t<T>;
1550  static_assert(sizeof(typename decayed::force_msvc_stacktrace) == 0,
1551  "forcing MSVC stacktrace to show which T we're talking about.");
1552 #endif
1553  }
1554 
1555  public:
1556  template<typename BasicJsonType, typename T>
1557  void operator()(BasicJsonType& j, T&& val) const
1558  noexcept(noexcept(std::declval<to_json_fn>().call(j, std::forward<T>(val), priority_tag<1> {})))
1559  {
1560  return call(j, std::forward<T>(val), priority_tag<1> {});
1561  }
1562 };
1563 }
1564 
1565 /// namespace to hold default `to_json` function
1566 namespace
1567 {
1568 constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
1569 }
1570 }
1571 
1572 // #include <nlohmann/detail/input/input_adapters.hpp>
1573 
1574 
1575 #include <algorithm> // min
1576 #include <array> // array
1577 #include <cassert> // assert
1578 #include <cstddef> // size_t
1579 #include <cstring> // strlen
1580 #include <ios> // streamsize, streamoff, streampos
1581 #include <istream> // istream
1582 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
1583 #include <memory> // shared_ptr, make_shared, addressof
1584 #include <numeric> // accumulate
1585 #include <string> // string, char_traits
1586 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
1587 #include <utility> // pair, declval
1588 
1589 // #include <nlohmann/detail/macro_scope.hpp>
1590 
1591 
1592 namespace nlohmann
1593 {
1594 namespace detail
1595 {
1596 ////////////////////
1597 // input adapters //
1598 ////////////////////
1599 
1600 /*!
1601 @brief abstract input adapter interface
1602 
1603 Produces a stream of std::char_traits<char>::int_type characters from a
1604 std::istream, a buffer, or some other input type. Accepts the return of exactly
1605 one non-EOF character for future input. The int_type characters returned
1606 consist of all valid char values as positive values (typically unsigned char),
1607 plus an EOF value outside that range, specified by the value of the function
1608 std::char_traits<char>::eof(). This value is typically -1, but could be any
1609 arbitrary value which is not a valid char value.
1610 */
1611 struct input_adapter_protocol
1612 {
1613  /// get a character [0,255] or std::char_traits<char>::eof().
1614  virtual std::char_traits<char>::int_type get_character() = 0;
1615  /// restore the last non-eof() character to input
1616  virtual void unget_character() = 0;
1617  virtual ~input_adapter_protocol() = default;
1618 };
1619 
1620 /// a type to simplify interfaces
1621 using input_adapter_t = std::shared_ptr<input_adapter_protocol>;
1622 
1623 /*!
1624 Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
1625 beginning of input. Does not support changing the underlying std::streambuf
1626 in mid-input. Maintains underlying std::istream and std::streambuf to support
1627 subsequent use of standard std::istream operations to process any input
1628 characters following those used in parsing the JSON input. Clears the
1629 std::istream flags; any input errors (e.g., EOF) will be detected by the first
1630 subsequent call for input from the std::istream.
1631 */
1632 class input_stream_adapter : public input_adapter_protocol
1633 {
1634  public:
1635  ~input_stream_adapter() override
1636  {
1637  // clear stream flags; we use underlying streambuf I/O, do not
1638  // maintain ifstream flags
1639  is.clear();
1640  }
1641 
1642  explicit input_stream_adapter(std::istream& i)
1643  : is(i), sb(*i.rdbuf())
1644  {
1645  // skip byte order mark
1646  std::char_traits<char>::int_type c;
1647  if ((c = get_character()) == 0xEF)
1648  {
1649  if ((c = get_character()) == 0xBB)
1650  {
1651  if ((c = get_character()) == 0xBF)
1652  {
1653  return; // Ignore BOM
1654  }
1655  else if (c != std::char_traits<char>::eof())
1656  {
1657  is.unget();
1658  }
1659  is.putback('\xBB');
1660  }
1661  else if (c != std::char_traits<char>::eof())
1662  {
1663  is.unget();
1664  }
1665  is.putback('\xEF');
1666  }
1667  else if (c != std::char_traits<char>::eof())
1668  {
1669  is.unget(); // no byte order mark; process as usual
1670  }
1671  }
1672 
1673  // delete because of pointer members
1674  input_stream_adapter(const input_stream_adapter&) = delete;
1675  input_stream_adapter& operator=(input_stream_adapter&) = delete;
1676 
1677  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
1678  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
1679  // end up as the same value, eg. 0xFFFFFFFF.
1680  std::char_traits<char>::int_type get_character() override
1681  {
1682  return sb.sbumpc();
1683  }
1684 
1685  void unget_character() override
1686  {
1687  sb.sungetc(); // is.unget() avoided for performance
1688  }
1689 
1690  private:
1691  /// the associated input stream
1692  std::istream& is;
1693  std::streambuf& sb;
1694 };
1695 
1696 /// input adapter for buffer input
1697 class input_buffer_adapter : public input_adapter_protocol
1698 {
1699  public:
1700  input_buffer_adapter(const char* b, const std::size_t l)
1701  : cursor(b), limit(b + l), start(b)
1702  {
1703  // skip byte order mark
1704  if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF')
1705  {
1706  cursor += 3;
1707  }
1708  }
1709 
1710  // delete because of pointer members
1711  input_buffer_adapter(const input_buffer_adapter&) = delete;
1712  input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
1713 
1714  std::char_traits<char>::int_type get_character() noexcept override
1715  {
1716  if (JSON_LIKELY(cursor < limit))
1717  {
1718  return std::char_traits<char>::to_int_type(*(cursor++));
1719  }
1720 
1721  return std::char_traits<char>::eof();
1722  }
1723 
1724  void unget_character() noexcept override
1725  {
1726  if (JSON_LIKELY(cursor > start))
1727  {
1728  --cursor;
1729  }
1730  }
1731 
1732  private:
1733  /// pointer to the current character
1734  const char* cursor;
1735  /// pointer past the last character
1736  const char* limit;
1737  /// pointer to the first character
1738  const char* start;
1739 };
1740 
1741 class input_adapter
1742 {
1743  public:
1744  // native support
1745 
1746  /// input adapter for input stream
1747  input_adapter(std::istream& i)
1748  : ia(std::make_shared<input_stream_adapter>(i)) {}
1749 
1750  /// input adapter for input stream
1751  input_adapter(std::istream&& i)
1752  : ia(std::make_shared<input_stream_adapter>(i)) {}
1753 
1754  /// input adapter for buffer
1755  template<typename CharT,
1756  typename std::enable_if<
1757  std::is_pointer<CharT>::value and
1758  std::is_integral<typename std::remove_pointer<CharT>::type>::value and
1759  sizeof(typename std::remove_pointer<CharT>::type) == 1,
1760  int>::type = 0>
1761  input_adapter(CharT b, std::size_t l)
1762  : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
1763 
1764  // derived support
1765 
1766  /// input adapter for string literal
1767  template<typename CharT,
1768  typename std::enable_if<
1769  std::is_pointer<CharT>::value and
1770  std::is_integral<typename std::remove_pointer<CharT>::type>::value and
1771  sizeof(typename std::remove_pointer<CharT>::type) == 1,
1772  int>::type = 0>
1773  input_adapter(CharT b)
1774  : input_adapter(reinterpret_cast<const char*>(b),
1775  std::strlen(reinterpret_cast<const char*>(b))) {}
1776 
1777  /// input adapter for iterator range with contiguous storage
1778  template<class IteratorType,
1779  typename std::enable_if<
1780  std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
1781  int>::type = 0>
1782  input_adapter(IteratorType first, IteratorType last)
1783  {
1784  // assertion to check that the iterator range is indeed contiguous,
1785  // see http://stackoverflow.com/a/35008842/266378 for more discussion
1786  assert(std::accumulate(
1787  first, last, std::pair<bool, int>(true, 0),
1788  [&first](std::pair<bool, int> res, decltype(*first) val)
1789  {
1790  res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
1791  return res;
1792  }).first);
1793 
1794  // assertion to check that each element is 1 byte long
1795  static_assert(
1796  sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
1797  "each element in the iterator range must have the size of 1 byte");
1798 
1799  const auto len = static_cast<size_t>(std::distance(first, last));
1800  if (JSON_LIKELY(len > 0))
1801  {
1802  // there is at least one element: use the address of first
1803  ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
1804  }
1805  else
1806  {
1807  // the address of first cannot be used: use nullptr
1808  ia = std::make_shared<input_buffer_adapter>(nullptr, len);
1809  }
1810  }
1811 
1812  /// input adapter for array
1813  template<class T, std::size_t N>
1814  input_adapter(T (&array)[N])
1815  : input_adapter(std::begin(array), std::end(array)) {}
1816 
1817  /// input adapter for contiguous container
1818  template<class ContiguousContainer, typename
1819  std::enable_if<not std::is_pointer<ContiguousContainer>::value and
1820  std::is_base_of<std::random_access_iterator_tag, typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
1821  int>::type = 0>
1822  input_adapter(const ContiguousContainer& c)
1823  : input_adapter(std::begin(c), std::end(c)) {}
1824 
1825  operator input_adapter_t()
1826  {
1827  return ia;
1828  }
1829 
1830  private:
1831  /// the actual adapter
1832  input_adapter_t ia = nullptr;
1833 };
1834 }
1835 }
1836 
1837 // #include <nlohmann/detail/input/lexer.hpp>
1838 
1839 
1840 #include <clocale> // localeconv
1841 #include <cstddef> // size_t
1842 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
1843 #include <initializer_list> // initializer_list
1844 #include <ios> // hex, uppercase
1845 #include <iomanip> // setw, setfill
1846 #include <sstream> // stringstream
1847 #include <string> // char_traits, string
1848 #include <vector> // vector
1849 
1850 // #include <nlohmann/detail/macro_scope.hpp>
1851 
1852 // #include <nlohmann/detail/input/input_adapters.hpp>
1853 
1854 
1855 namespace nlohmann
1856 {
1857 namespace detail
1858 {
1859 ///////////
1860 // lexer //
1861 ///////////
1862 
1863 /*!
1864 @brief lexical analysis
1865 
1866 This class organizes the lexical analysis during JSON deserialization.
1867 */
1868 template<typename BasicJsonType>
1869 class lexer
1870 {
1871  using number_integer_t = typename BasicJsonType::number_integer_t;
1872  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
1873  using number_float_t = typename BasicJsonType::number_float_t;
1874  using string_t = typename BasicJsonType::string_t;
1875 
1876  public:
1877  /// token types for the parser
1878  enum class token_type
1879  {
1880  uninitialized, ///< indicating the scanner is uninitialized
1881  literal_true, ///< the `true` literal
1882  literal_false, ///< the `false` literal
1883  literal_null, ///< the `null` literal
1884  value_string, ///< a string -- use get_string() for actual value
1885  value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for actual value
1886  value_integer, ///< a signed integer -- use get_number_integer() for actual value
1887  value_float, ///< an floating point number -- use get_number_float() for actual value
1888  begin_array, ///< the character for array begin `[`
1889  begin_object, ///< the character for object begin `{`
1890  end_array, ///< the character for array end `]`
1891  end_object, ///< the character for object end `}`
1892  name_separator, ///< the name separator `:`
1893  value_separator, ///< the value separator `,`
1894  parse_error, ///< indicating a parse error
1895  end_of_input, ///< indicating the end of the input buffer
1896  literal_or_value ///< a literal or the begin of a value (only for diagnostics)
1897  };
1898 
1899  /// return name of values of type token_type (only used for errors)
1900  static const char* token_type_name(const token_type t) noexcept
1901  {
1902  switch (t)
1903  {
1904  case token_type::uninitialized:
1905  return "<uninitialized>";
1906  case token_type::literal_true:
1907  return "true literal";
1908  case token_type::literal_false:
1909  return "false literal";
1910  case token_type::literal_null:
1911  return "null literal";
1912  case token_type::value_string:
1913  return "string literal";
1914  case lexer::token_type::value_unsigned:
1915  case lexer::token_type::value_integer:
1916  case lexer::token_type::value_float:
1917  return "number literal";
1918  case token_type::begin_array:
1919  return "'['";
1920  case token_type::begin_object:
1921  return "'{'";
1922  case token_type::end_array:
1923  return "']'";
1924  case token_type::end_object:
1925  return "'}'";
1926  case token_type::name_separator:
1927  return "':'";
1928  case token_type::value_separator:
1929  return "','";
1930  case token_type::parse_error:
1931  return "<parse error>";
1932  case token_type::end_of_input:
1933  return "end of input";
1934  case token_type::literal_or_value:
1935  return "'[', '{', or a literal";
1936  default: // catch non-enum values
1937  return "unknown token"; // LCOV_EXCL_LINE
1938  }
1939  }
1940 
1941  explicit lexer(detail::input_adapter_t adapter)
1942  : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}
1943 
1944  // delete because of pointer members
1945  lexer(const lexer&) = delete;
1946  lexer& operator=(lexer&) = delete;
1947 
1948  private:
1949  /////////////////////
1950  // locales
1951  /////////////////////
1952 
1953  /// return the locale-dependent decimal point
1954  static char get_decimal_point() noexcept
1955  {
1956  const auto loc = localeconv();
1957  assert(loc != nullptr);
1958  return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
1959  }
1960 
1961  /////////////////////
1962  // scan functions
1963  /////////////////////
1964 
1965  /*!
1966  @brief get codepoint from 4 hex characters following `\u`
1967 
1968  For input "\u c1 c2 c3 c4" the codepoint is:
1969  (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
1970  = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
1971 
1972  Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
1973  must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
1974  conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
1975  between the ASCII value of the character and the desired integer value.
1976 
1977  @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
1978  non-hex character)
1979  */
1980  int get_codepoint()
1981  {
1982  // this function only makes sense after reading `\u`
1983  assert(current == 'u');
1984  int codepoint = 0;
1985 
1986  const auto factors = { 12, 8, 4, 0 };
1987  for (const auto factor : factors)
1988  {
1989  get();
1990 
1991  if (current >= '0' and current <= '9')
1992  {
1993  codepoint += ((current - 0x30) << factor);
1994  }
1995  else if (current >= 'A' and current <= 'F')
1996  {
1997  codepoint += ((current - 0x37) << factor);
1998  }
1999  else if (current >= 'a' and current <= 'f')
2000  {
2001  codepoint += ((current - 0x57) << factor);
2002  }
2003  else
2004  {
2005  return -1;
2006  }
2007  }
2008 
2009  assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
2010  return codepoint;
2011  }
2012 
2013  /*!
2014  @brief check if the next byte(s) are inside a given range
2015 
2016  Adds the current byte and, for each passed range, reads a new byte and
2017  checks if it is inside the range. If a violation was detected, set up an
2018  error message and return false. Otherwise, return true.
2019 
2020  @param[in] ranges list of integers; interpreted as list of pairs of
2021  inclusive lower and upper bound, respectively
2022 
2023  @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
2024  1, 2, or 3 pairs. This precondition is enforced by an assertion.
2025 
2026  @return true if and only if no range violation was detected
2027  */
2028  bool next_byte_in_range(std::initializer_list<int> ranges)
2029  {
2030  assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
2031  add(current);
2032 
2033  for (auto range = ranges.begin(); range != ranges.end(); ++range)
2034  {
2035  get();
2036  if (JSON_LIKELY(*range <= current and current <= *(++range)))
2037  {
2038  add(current);
2039  }
2040  else
2041  {
2042  error_message = "invalid string: ill-formed UTF-8 byte";
2043  return false;
2044  }
2045  }
2046 
2047  return true;
2048  }
2049 
2050  /*!
2051  @brief scan a string literal
2052 
2053  This function scans a string according to Sect. 7 of RFC 7159. While
2054  scanning, bytes are escaped and copied into buffer token_buffer. Then the
2055  function returns successfully, token_buffer is *not* null-terminated (as it
2056  may contain \0 bytes), and token_buffer.size() is the number of bytes in the
2057  string.
2058 
2059  @return token_type::value_string if string could be successfully scanned,
2060  token_type::parse_error otherwise
2061 
2062  @note In case of errors, variable error_message contains a textual
2063  description.
2064  */
2065  token_type scan_string()
2066  {
2067  // reset token_buffer (ignore opening quote)
2068  reset();
2069 
2070  // we entered the function by reading an open quote
2071  assert(current == '\"');
2072 
2073  while (true)
2074  {
2075  // get next character
2076  switch (get())
2077  {
2078  // end of file while parsing string
2079  case std::char_traits<char>::eof():
2080  {
2081  error_message = "invalid string: missing closing quote";
2082  return token_type::parse_error;
2083  }
2084 
2085  // closing quote
2086  case '\"':
2087  {
2088  return token_type::value_string;
2089  }
2090 
2091  // escapes
2092  case '\\':
2093  {
2094  switch (get())
2095  {
2096  // quotation mark
2097  case '\"':
2098  add('\"');
2099  break;
2100  // reverse solidus
2101  case '\\':
2102  add('\\');
2103  break;
2104  // solidus
2105  case '/':
2106  add('/');
2107  break;
2108  // backspace
2109  case 'b':
2110  add('\b');
2111  break;
2112  // form feed
2113  case 'f':
2114  add('\f');
2115  break;
2116  // line feed
2117  case 'n':
2118  add('\n');
2119  break;
2120  // carriage return
2121  case 'r':
2122  add('\r');
2123  break;
2124  // tab
2125  case 't':
2126  add('\t');
2127  break;
2128 
2129  // unicode escapes
2130  case 'u':
2131  {
2132  const int codepoint1 = get_codepoint();
2133  int codepoint = codepoint1; // start with codepoint1
2134 
2135  if (JSON_UNLIKELY(codepoint1 == -1))
2136  {
2137  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
2138  return token_type::parse_error;
2139  }
2140 
2141  // check if code point is a high surrogate
2142  if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
2143  {
2144  // expect next \uxxxx entry
2145  if (JSON_LIKELY(get() == '\\' and get() == 'u'))
2146  {
2147  const int codepoint2 = get_codepoint();
2148 
2149  if (JSON_UNLIKELY(codepoint2 == -1))
2150  {
2151  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
2152  return token_type::parse_error;
2153  }
2154 
2155  // check if codepoint2 is a low surrogate
2156  if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
2157  {
2158  // overwrite codepoint
2159  codepoint =
2160  // high surrogate occupies the most significant 22 bits
2161  (codepoint1 << 10)
2162  // low surrogate occupies the least significant 15 bits
2163  + codepoint2
2164  // there is still the 0xD800, 0xDC00 and 0x10000 noise
2165  // in the result so we have to subtract with:
2166  // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
2167  - 0x35FDC00;
2168  }
2169  else
2170  {
2171  error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
2172  return token_type::parse_error;
2173  }
2174  }
2175  else
2176  {
2177  error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
2178  return token_type::parse_error;
2179  }
2180  }
2181  else
2182  {
2183  if (JSON_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
2184  {
2185  error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
2186  return token_type::parse_error;
2187  }
2188  }
2189 
2190  // result of the above calculation yields a proper codepoint
2191  assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
2192 
2193  // translate codepoint into bytes
2194  if (codepoint < 0x80)
2195  {
2196  // 1-byte characters: 0xxxxxxx (ASCII)
2197  add(codepoint);
2198  }
2199  else if (codepoint <= 0x7FF)
2200  {
2201  // 2-byte characters: 110xxxxx 10xxxxxx
2202  add(0xC0 | (codepoint >> 6));
2203  add(0x80 | (codepoint & 0x3F));
2204  }
2205  else if (codepoint <= 0xFFFF)
2206  {
2207  // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
2208  add(0xE0 | (codepoint >> 12));
2209  add(0x80 | ((codepoint >> 6) & 0x3F));
2210  add(0x80 | (codepoint & 0x3F));
2211  }
2212  else
2213  {
2214  // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
2215  add(0xF0 | (codepoint >> 18));
2216  add(0x80 | ((codepoint >> 12) & 0x3F));
2217  add(0x80 | ((codepoint >> 6) & 0x3F));
2218  add(0x80 | (codepoint & 0x3F));
2219  }
2220 
2221  break;
2222  }
2223 
2224  // other characters after escape
2225  default:
2226  error_message = "invalid string: forbidden character after backslash";
2227  return token_type::parse_error;
2228  }
2229 
2230  break;
2231  }
2232 
2233  // invalid control characters
2234  case 0x00:
2235  case 0x01:
2236  case 0x02:
2237  case 0x03:
2238  case 0x04:
2239  case 0x05:
2240  case 0x06:
2241  case 0x07:
2242  case 0x08:
2243  case 0x09:
2244  case 0x0A:
2245  case 0x0B:
2246  case 0x0C:
2247  case 0x0D:
2248  case 0x0E:
2249  case 0x0F:
2250  case 0x10:
2251  case 0x11:
2252  case 0x12:
2253  case 0x13:
2254  case 0x14:
2255  case 0x15:
2256  case 0x16:
2257  case 0x17:
2258  case 0x18:
2259  case 0x19:
2260  case 0x1A:
2261  case 0x1B:
2262  case 0x1C:
2263  case 0x1D:
2264  case 0x1E:
2265  case 0x1F:
2266  {
2267  error_message = "invalid string: control character must be escaped";
2268  return token_type::parse_error;
2269  }
2270 
2271  // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
2272  case 0x20:
2273  case 0x21:
2274  case 0x23:
2275  case 0x24:
2276  case 0x25:
2277  case 0x26:
2278  case 0x27:
2279  case 0x28:
2280  case 0x29:
2281  case 0x2A:
2282  case 0x2B:
2283  case 0x2C:
2284  case 0x2D:
2285  case 0x2E:
2286  case 0x2F:
2287  case 0x30:
2288  case 0x31:
2289  case 0x32:
2290  case 0x33:
2291  case 0x34:
2292  case 0x35:
2293  case 0x36:
2294  case 0x37:
2295  case 0x38:
2296  case 0x39:
2297  case 0x3A:
2298  case 0x3B:
2299  case 0x3C:
2300  case 0x3D:
2301  case 0x3E:
2302  case 0x3F:
2303  case 0x40:
2304  case 0x41:
2305  case 0x42:
2306  case 0x43:
2307  case 0x44:
2308  case 0x45:
2309  case 0x46:
2310  case 0x47:
2311  case 0x48:
2312  case 0x49:
2313  case 0x4A:
2314  case 0x4B:
2315  case 0x4C:
2316  case 0x4D:
2317  case 0x4E:
2318  case 0x4F:
2319  case 0x50:
2320  case 0x51:
2321  case 0x52:
2322  case 0x53:
2323  case 0x54:
2324  case 0x55:
2325  case 0x56:
2326  case 0x57:
2327  case 0x58:
2328  case 0x59:
2329  case 0x5A:
2330  case 0x5B:
2331  case 0x5D:
2332  case 0x5E:
2333  case 0x5F:
2334  case 0x60:
2335  case 0x61:
2336  case 0x62:
2337  case 0x63:
2338  case 0x64:
2339  case 0x65:
2340  case 0x66:
2341  case 0x67:
2342  case 0x68:
2343  case 0x69:
2344  case 0x6A:
2345  case 0x6B:
2346  case 0x6C:
2347  case 0x6D:
2348  case 0x6E:
2349  case 0x6F:
2350  case 0x70:
2351  case 0x71:
2352  case 0x72:
2353  case 0x73:
2354  case 0x74:
2355  case 0x75:
2356  case 0x76:
2357  case 0x77:
2358  case 0x78:
2359  case 0x79:
2360  case 0x7A:
2361  case 0x7B:
2362  case 0x7C:
2363  case 0x7D:
2364  case 0x7E:
2365  case 0x7F:
2366  {
2367  add(current);
2368  break;
2369  }
2370 
2371  // U+0080..U+07FF: bytes C2..DF 80..BF
2372  case 0xC2:
2373  case 0xC3:
2374  case 0xC4:
2375  case 0xC5:
2376  case 0xC6:
2377  case 0xC7:
2378  case 0xC8:
2379  case 0xC9:
2380  case 0xCA:
2381  case 0xCB:
2382  case 0xCC:
2383  case 0xCD:
2384  case 0xCE:
2385  case 0xCF:
2386  case 0xD0:
2387  case 0xD1:
2388  case 0xD2:
2389  case 0xD3:
2390  case 0xD4:
2391  case 0xD5:
2392  case 0xD6:
2393  case 0xD7:
2394  case 0xD8:
2395  case 0xD9:
2396  case 0xDA:
2397  case 0xDB:
2398  case 0xDC:
2399  case 0xDD:
2400  case 0xDE:
2401  case 0xDF:
2402  {
2403  if (JSON_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
2404  {
2405  return token_type::parse_error;
2406  }
2407  break;
2408  }
2409 
2410  // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
2411  case 0xE0:
2412  {
2413  if (JSON_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
2414  {
2415  return token_type::parse_error;
2416  }
2417  break;
2418  }
2419 
2420  // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
2421  // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
2422  case 0xE1:
2423  case 0xE2:
2424  case 0xE3:
2425  case 0xE4:
2426  case 0xE5:
2427  case 0xE6:
2428  case 0xE7:
2429  case 0xE8:
2430  case 0xE9:
2431  case 0xEA:
2432  case 0xEB:
2433  case 0xEC:
2434  case 0xEE:
2435  case 0xEF:
2436  {
2437  if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
2438  {
2439  return token_type::parse_error;
2440  }
2441  break;
2442  }
2443 
2444  // U+D000..U+D7FF: bytes ED 80..9F 80..BF
2445  case 0xED:
2446  {
2447  if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
2448  {
2449  return token_type::parse_error;
2450  }
2451  break;
2452  }
2453 
2454  // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
2455  case 0xF0:
2456  {
2457  if (JSON_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
2458  {
2459  return token_type::parse_error;
2460  }
2461  break;
2462  }
2463 
2464  // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
2465  case 0xF1:
2466  case 0xF2:
2467  case 0xF3:
2468  {
2469  if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
2470  {
2471  return token_type::parse_error;
2472  }
2473  break;
2474  }
2475 
2476  // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
2477  case 0xF4:
2478  {
2479  if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
2480  {
2481  return token_type::parse_error;
2482  }
2483  break;
2484  }
2485 
2486  // remaining bytes (80..C1 and F5..FF) are ill-formed
2487  default:
2488  {
2489  error_message = "invalid string: ill-formed UTF-8 byte";
2490  return token_type::parse_error;
2491  }
2492  }
2493  }
2494  }
2495 
2496  static void strtof(float& f, const char* str, char** endptr) noexcept
2497  {
2498  f = std::strtof(str, endptr);
2499  }
2500 
2501  static void strtof(double& f, const char* str, char** endptr) noexcept
2502  {
2503  f = std::strtod(str, endptr);
2504  }
2505 
2506  static void strtof(long double& f, const char* str, char** endptr) noexcept
2507  {
2508  f = std::strtold(str, endptr);
2509  }
2510 
2511  /*!
2512  @brief scan a number literal
2513 
2514  This function scans a string according to Sect. 6 of RFC 7159.
2515 
2516  The function is realized with a deterministic finite state machine derived
2517  from the grammar described in RFC 7159. Starting in state "init", the
2518  input is read and used to determined the next state. Only state "done"
2519  accepts the number. State "error" is a trap state to model errors. In the
2520  table below, "anything" means any character but the ones listed before.
2521 
2522  state | 0 | 1-9 | e E | + | - | . | anything
2523  ---------|----------|----------|----------|---------|---------|----------|-----------
2524  init | zero | any1 | [error] | [error] | minus | [error] | [error]
2525  minus | zero | any1 | [error] | [error] | [error] | [error] | [error]
2526  zero | done | done | exponent | done | done | decimal1 | done
2527  any1 | any1 | any1 | exponent | done | done | decimal1 | done
2528  decimal1 | decimal2 | [error] | [error] | [error] | [error] | [error] | [error]
2529  decimal2 | decimal2 | decimal2 | exponent | done | done | done | done
2530  exponent | any2 | any2 | [error] | sign | sign | [error] | [error]
2531  sign | any2 | any2 | [error] | [error] | [error] | [error] | [error]
2532  any2 | any2 | any2 | done | done | done | done | done
2533 
2534  The state machine is realized with one label per state (prefixed with
2535  "scan_number_") and `goto` statements between them. The state machine
2536  contains cycles, but any cycle can be left when EOF is read. Therefore,
2537  the function is guaranteed to terminate.
2538 
2539  During scanning, the read bytes are stored in token_buffer. This string is
2540  then converted to a signed integer, an unsigned integer, or a
2541  floating-point number.
2542 
2543  @return token_type::value_unsigned, token_type::value_integer, or
2544  token_type::value_float if number could be successfully scanned,
2545  token_type::parse_error otherwise
2546 
2547  @note The scanner is independent of the current locale. Internally, the
2548  locale's decimal point is used instead of `.` to work with the
2549  locale-dependent converters.
2550  */
2551  token_type scan_number()
2552  {
2553  // reset token_buffer to store the number's bytes
2554  reset();
2555 
2556  // the type of the parsed number; initially set to unsigned; will be
2557  // changed if minus sign, decimal point or exponent is read
2558  token_type number_type = token_type::value_unsigned;
2559 
2560  // state (init): we just found out we need to scan a number
2561  switch (current)
2562  {
2563  case '-':
2564  {
2565  add(current);
2566  goto scan_number_minus;
2567  }
2568 
2569  case '0':
2570  {
2571  add(current);
2572  goto scan_number_zero;
2573  }
2574 
2575  case '1':
2576  case '2':
2577  case '3':
2578  case '4':
2579  case '5':
2580  case '6':
2581  case '7':
2582  case '8':
2583  case '9':
2584  {
2585  add(current);
2586  goto scan_number_any1;
2587  }
2588 
2589  default:
2590  {
2591  // all other characters are rejected outside scan_number()
2592  assert(false); // LCOV_EXCL_LINE
2593  }
2594  }
2595 
2596 scan_number_minus:
2597  // state: we just parsed a leading minus sign
2598  number_type = token_type::value_integer;
2599  switch (get())
2600  {
2601  case '0':
2602  {
2603  add(current);
2604  goto scan_number_zero;
2605  }
2606 
2607  case '1':
2608  case '2':
2609  case '3':
2610  case '4':
2611  case '5':
2612  case '6':
2613  case '7':
2614  case '8':
2615  case '9':
2616  {
2617  add(current);
2618  goto scan_number_any1;
2619  }
2620 
2621  default:
2622  {
2623  error_message = "invalid number; expected digit after '-'";
2624  return token_type::parse_error;
2625  }
2626  }
2627 
2628 scan_number_zero:
2629  // state: we just parse a zero (maybe with a leading minus sign)
2630  switch (get())
2631  {
2632  case '.':
2633  {
2634  add(decimal_point_char);
2635  goto scan_number_decimal1;
2636  }
2637 
2638  case 'e':
2639  case 'E':
2640  {
2641  add(current);
2642  goto scan_number_exponent;
2643  }
2644 
2645  default:
2646  goto scan_number_done;
2647  }
2648 
2649 scan_number_any1:
2650  // state: we just parsed a number 0-9 (maybe with a leading minus sign)
2651  switch (get())
2652  {
2653  case '0':
2654  case '1':
2655  case '2':
2656  case '3':
2657  case '4':
2658  case '5':
2659  case '6':
2660  case '7':
2661  case '8':
2662  case '9':
2663  {
2664  add(current);
2665  goto scan_number_any1;
2666  }
2667 
2668  case '.':
2669  {
2670  add(decimal_point_char);
2671  goto scan_number_decimal1;
2672  }
2673 
2674  case 'e':
2675  case 'E':
2676  {
2677  add(current);
2678  goto scan_number_exponent;
2679  }
2680 
2681  default:
2682  goto scan_number_done;
2683  }
2684 
2685 scan_number_decimal1:
2686  // state: we just parsed a decimal point
2687  number_type = token_type::value_float;
2688  switch (get())
2689  {
2690  case '0':
2691  case '1':
2692  case '2':
2693  case '3':
2694  case '4':
2695  case '5':
2696  case '6':
2697  case '7':
2698  case '8':
2699  case '9':
2700  {
2701  add(current);
2702  goto scan_number_decimal2;
2703  }
2704 
2705  default:
2706  {
2707  error_message = "invalid number; expected digit after '.'";
2708  return token_type::parse_error;
2709  }
2710  }
2711 
2712 scan_number_decimal2:
2713  // we just parsed at least one number after a decimal point
2714  switch (get())
2715  {
2716  case '0':
2717  case '1':
2718  case '2':
2719  case '3':
2720  case '4':
2721  case '5':
2722  case '6':
2723  case '7':
2724  case '8':
2725  case '9':
2726  {
2727  add(current);
2728  goto scan_number_decimal2;
2729  }
2730 
2731  case 'e':
2732  case 'E':
2733  {
2734  add(current);
2735  goto scan_number_exponent;
2736  }
2737 
2738  default:
2739  goto scan_number_done;
2740  }
2741 
2742 scan_number_exponent:
2743  // we just parsed an exponent
2744  number_type = token_type::value_float;
2745  switch (get())
2746  {
2747  case '+':
2748  case '-':
2749  {
2750  add(current);
2751  goto scan_number_sign;
2752  }
2753 
2754  case '0':
2755  case '1':
2756  case '2':
2757  case '3':
2758  case '4':
2759  case '5':
2760  case '6':
2761  case '7':
2762  case '8':
2763  case '9':
2764  {
2765  add(current);
2766  goto scan_number_any2;
2767  }
2768 
2769  default:
2770  {
2771  error_message =
2772  "invalid number; expected '+', '-', or digit after exponent";
2773  return token_type::parse_error;
2774  }
2775  }
2776 
2777 scan_number_sign:
2778  // we just parsed an exponent sign
2779  switch (get())
2780  {
2781  case '0':
2782  case '1':
2783  case '2':
2784  case '3':
2785  case '4':
2786  case '5':
2787  case '6':
2788  case '7':
2789  case '8':
2790  case '9':
2791  {
2792  add(current);
2793  goto scan_number_any2;
2794  }
2795 
2796  default:
2797  {
2798  error_message = "invalid number; expected digit after exponent sign";
2799  return token_type::parse_error;
2800  }
2801  }
2802 
2803 scan_number_any2:
2804  // we just parsed a number after the exponent or exponent sign
2805  switch (get())
2806  {
2807  case '0':
2808  case '1':
2809  case '2':
2810  case '3':
2811  case '4':
2812  case '5':
2813  case '6':
2814  case '7':
2815  case '8':
2816  case '9':
2817  {
2818  add(current);
2819  goto scan_number_any2;
2820  }
2821 
2822  default:
2823  goto scan_number_done;
2824  }
2825 
2826 scan_number_done:
2827  // unget the character after the number (we only read it to know that
2828  // we are done scanning a number)
2829  unget();
2830 
2831  char* endptr = nullptr;
2832  errno = 0;
2833 
2834  // try to parse integers first and fall back to floats
2835  if (number_type == token_type::value_unsigned)
2836  {
2837  const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
2838 
2839  // we checked the number format before
2840  assert(endptr == token_buffer.data() + token_buffer.size());
2841 
2842  if (errno == 0)
2843  {
2844  value_unsigned = static_cast<number_unsigned_t>(x);
2845  if (value_unsigned == x)
2846  {
2847  return token_type::value_unsigned;
2848  }
2849  }
2850  }
2851  else if (number_type == token_type::value_integer)
2852  {
2853  const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
2854 
2855  // we checked the number format before
2856  assert(endptr == token_buffer.data() + token_buffer.size());
2857 
2858  if (errno == 0)
2859  {
2860  value_integer = static_cast<number_integer_t>(x);
2861  if (value_integer == x)
2862  {
2863  return token_type::value_integer;
2864  }
2865  }
2866  }
2867 
2868  // this code is reached if we parse a floating-point number or if an
2869  // integer conversion above failed
2870  strtof(value_float, token_buffer.data(), &endptr);
2871 
2872  // we checked the number format before
2873  assert(endptr == token_buffer.data() + token_buffer.size());
2874 
2875  return token_type::value_float;
2876  }
2877 
2878  /*!
2879  @param[in] literal_text the literal text to expect
2880  @param[in] length the length of the passed literal text
2881  @param[in] return_type the token type to return on success
2882  */
2883  token_type scan_literal(const char* literal_text, const std::size_t length,
2884  token_type return_type)
2885  {
2886  assert(current == literal_text[0]);
2887  for (std::size_t i = 1; i < length; ++i)
2888  {
2889  if (JSON_UNLIKELY(get() != literal_text[i]))
2890  {
2891  error_message = "invalid literal";
2892  return token_type::parse_error;
2893  }
2894  }
2895  return return_type;
2896  }
2897 
2898  /////////////////////
2899  // input management
2900  /////////////////////
2901 
2902  /// reset token_buffer; current character is beginning of token
2903  void reset() noexcept
2904  {
2905  token_buffer.clear();
2906  token_string.clear();
2907  token_string.push_back(std::char_traits<char>::to_char_type(current));
2908  }
2909 
2910  /*
2911  @brief get next character from the input
2912 
2913  This function provides the interface to the used input adapter. It does
2914  not throw in case the input reached EOF, but returns a
2915  `std::char_traits<char>::eof()` in that case. Stores the scanned characters
2916  for use in error messages.
2917 
2918  @return character read from the input
2919  */
2920  std::char_traits<char>::int_type get()
2921  {
2922  ++chars_read;
2923  current = ia->get_character();
2924  if (JSON_LIKELY(current != std::char_traits<char>::eof()))
2925  {
2926  token_string.push_back(std::char_traits<char>::to_char_type(current));
2927  }
2928  return current;
2929  }
2930 
2931  /// unget current character (return it again on next get)
2932  void unget()
2933  {
2934  --chars_read;
2935  if (JSON_LIKELY(current != std::char_traits<char>::eof()))
2936  {
2937  ia->unget_character();
2938  assert(token_string.size() != 0);
2939  token_string.pop_back();
2940  }
2941  }
2942 
2943  /// add a character to token_buffer
2944  void add(int c)
2945  {
2946  token_buffer.push_back(std::char_traits<char>::to_char_type(c));
2947  }
2948 
2949  public:
2950  /////////////////////
2951  // value getters
2952  /////////////////////
2953 
2954  /// return integer value
2955  constexpr number_integer_t get_number_integer() const noexcept
2956  {
2957  return value_integer;
2958  }
2959 
2960  /// return unsigned integer value
2961  constexpr number_unsigned_t get_number_unsigned() const noexcept
2962  {
2963  return value_unsigned;
2964  }
2965 
2966  /// return floating-point value
2967  constexpr number_float_t get_number_float() const noexcept
2968  {
2969  return value_float;
2970  }
2971 
2972  /// return current string value (implicitly resets the token; useful only once)
2973  string_t&& move_string()
2974  {
2975  return std::move(token_buffer);
2976  }
2977 
2978  /////////////////////
2979  // diagnostics
2980  /////////////////////
2981 
2982  /// return position of last read token
2983  constexpr std::size_t get_position() const noexcept
2984  {
2985  return chars_read;
2986  }
2987 
2988  /// return the last read token (for errors only). Will never contain EOF
2989  /// (an arbitrary value that is not a valid char value, often -1), because
2990  /// 255 may legitimately occur. May contain NUL, which should be escaped.
2991  std::string get_token_string() const
2992  {
2993  // escape control characters
2994  std::string result;
2995  for (const auto c : token_string)
2996  {
2997  if ('\x00' <= c and c <= '\x1F')
2998  {
2999  // escape control characters
3000  std::stringstream ss;
3001  ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
3002  << std::hex << static_cast<int>(c) << ">";
3003  result += ss.str();
3004  }
3005  else
3006  {
3007  // add character as is
3008  result.push_back(c);
3009  }
3010  }
3011 
3012  return result;
3013  }
3014 
3015  /// return syntax error message
3016  constexpr const char* get_error_message() const noexcept
3017  {
3018  return error_message;
3019  }
3020 
3021  /////////////////////
3022  // actual scanner
3023  /////////////////////
3024 
3025  token_type scan()
3026  {
3027  // read next character and ignore whitespace
3028  do
3029  {
3030  get();
3031  }
3032  while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
3033 
3034  switch (current)
3035  {
3036  // structural characters
3037  case '[':
3038  return token_type::begin_array;
3039  case ']':
3040  return token_type::end_array;
3041  case '{':
3042  return token_type::begin_object;
3043  case '}':
3044  return token_type::end_object;
3045  case ':':
3046  return token_type::name_separator;
3047  case ',':
3048  return token_type::value_separator;
3049 
3050  // literals
3051  case 't':
3052  return scan_literal("true", 4, token_type::literal_true);
3053  case 'f':
3054  return scan_literal("false", 5, token_type::literal_false);
3055  case 'n':
3056  return scan_literal("null", 4, token_type::literal_null);
3057 
3058  // string
3059  case '\"':
3060  return scan_string();
3061 
3062  // number
3063  case '-':
3064  case '0':
3065  case '1':
3066  case '2':
3067  case '3':
3068  case '4':
3069  case '5':
3070  case '6':
3071  case '7':
3072  case '8':
3073  case '9':
3074  return scan_number();
3075 
3076  // end of input (the null byte is needed when parsing from
3077  // string literals)
3078  case '\0':
3079  case std::char_traits<char>::eof():
3080  return token_type::end_of_input;
3081 
3082  // error
3083  default:
3084  error_message = "invalid literal";
3085  return token_type::parse_error;
3086  }
3087  }
3088 
3089  private:
3090  /// input adapter
3091  detail::input_adapter_t ia = nullptr;
3092 
3093  /// the current character
3094  std::char_traits<char>::int_type current = std::char_traits<char>::eof();
3095 
3096  /// the number of characters read
3097  std::size_t chars_read = 0;
3098 
3099  /// raw input token string (for error messages)
3100  std::vector<char> token_string {};
3101 
3102  /// buffer for variable-length tokens (numbers, strings)
3103  string_t token_buffer {};
3104 
3105  /// a description of occurred lexer errors
3106  const char* error_message = "";
3107 
3108  // number values
3109  number_integer_t value_integer = 0;
3110  number_unsigned_t value_unsigned = 0;
3111  number_float_t value_float = 0;
3112 
3113  /// the decimal point
3114  const char decimal_point_char = '.';
3115 };
3116 }
3117 }
3118 
3119 // #include <nlohmann/detail/input/parser.hpp>
3120 
3121 
3122 #include <cassert> // assert
3123 #include <cmath> // isfinite
3124 #include <cstdint> // uint8_t
3125 #include <functional> // function
3126 #include <string> // string
3127 #include <utility> // move
3128 
3129 // #include <nlohmann/detail/exceptions.hpp>
3130 
3131 // #include <nlohmann/detail/macro_scope.hpp>
3132 
3133 // #include <nlohmann/detail/input/input_adapters.hpp>
3134 
3135 // #include <nlohmann/detail/input/lexer.hpp>
3136 
3137 // #include <nlohmann/detail/value_t.hpp>
3138 
3139 
3140 namespace nlohmann
3141 {
3142 namespace detail
3143 {
3144 ////////////
3145 // parser //
3146 ////////////
3147 
3148 /*!
3149 @brief syntax analysis
3150 
3151 This class implements a recursive decent parser.
3152 */
3153 template<typename BasicJsonType>
3154 class parser
3155 {
3156  using number_integer_t = typename BasicJsonType::number_integer_t;
3157  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
3158  using number_float_t = typename BasicJsonType::number_float_t;
3159  using string_t = typename BasicJsonType::string_t;
3160  using lexer_t = lexer<BasicJsonType>;
3161  using token_type = typename lexer_t::token_type;
3162 
3163  public:
3164  enum class parse_event_t : uint8_t
3165  {
3166  /// the parser read `{` and started to process a JSON object
3167  object_start,
3168  /// the parser read `}` and finished processing a JSON object
3169  object_end,
3170  /// the parser read `[` and started to process a JSON array
3171  array_start,
3172  /// the parser read `]` and finished processing a JSON array
3173  array_end,
3174  /// the parser read a key of a value in an object
3175  key,
3176  /// the parser finished reading a JSON value
3177  value
3178  };
3179 
3180  using parser_callback_t =
3181  std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
3182 
3183  /// a parser reading from an input adapter
3184  explicit parser(detail::input_adapter_t adapter,
3185  const parser_callback_t cb = nullptr,
3186  const bool allow_exceptions_ = true)
3187  : callback(cb), m_lexer(adapter), allow_exceptions(allow_exceptions_)
3188  {}
3189 
3190  /*!
3191  @brief public parser interface
3192 
3193  @param[in] strict whether to expect the last token to be EOF
3194  @param[in,out] result parsed JSON value
3195 
3196  @throw parse_error.101 in case of an unexpected token
3197  @throw parse_error.102 if to_unicode fails or surrogate error
3198  @throw parse_error.103 if to_unicode fails
3199  */
3200  void parse(const bool strict, BasicJsonType& result)
3201  {
3202  // read first token
3203  get_token();
3204 
3205  parse_internal(true, result);
3206  result.assert_invariant();
3207 
3208  // in strict mode, input must be completely read
3209  if (strict)
3210  {
3211  get_token();
3212  expect(token_type::end_of_input);
3213  }
3214 
3215  // in case of an error, return discarded value
3216  if (errored)
3217  {
3218  result = value_t::discarded;
3219  return;
3220  }
3221 
3222  // set top-level value to null if it was discarded by the callback
3223  // function
3224  if (result.is_discarded())
3225  {
3226  result = nullptr;
3227  }
3228  }
3229 
3230  /*!
3231  @brief public accept interface
3232 
3233  @param[in] strict whether to expect the last token to be EOF
3234  @return whether the input is a proper JSON text
3235  */
3236  bool accept(const bool strict = true)
3237  {
3238  // read first token
3239  get_token();
3240 
3241  if (not accept_internal())
3242  {
3243  return false;
3244  }
3245 
3246  // strict => last token must be EOF
3247  return not strict or (get_token() == token_type::end_of_input);
3248  }
3249 
3250  private:
3251  /*!
3252  @brief the actual parser
3253  @throw parse_error.101 in case of an unexpected token
3254  @throw parse_error.102 if to_unicode fails or surrogate error
3255  @throw parse_error.103 if to_unicode fails
3256  */
3257  void parse_internal(bool keep, BasicJsonType& result)
3258  {
3259  // never parse after a parse error was detected
3260  assert(not errored);
3261 
3262  // start with a discarded value
3263  if (not result.is_discarded())
3264  {
3265  result.m_value.destroy(result.m_type);
3266  result.m_type = value_t::discarded;
3267  }
3268 
3269  switch (last_token)
3270  {
3271  case token_type::begin_object:
3272  {
3273  if (keep)
3274  {
3275  if (callback)
3276  {
3277  keep = callback(depth++, parse_event_t::object_start, result);
3278  }
3279 
3280  if (not callback or keep)
3281  {
3282  // explicitly set result to object to cope with {}
3283  result.m_type = value_t::object;
3284  result.m_value = value_t::object;
3285  }
3286  }
3287 
3288  // read next token
3289  get_token();
3290 
3291  // closing } -> we are done
3292  if (last_token == token_type::end_object)
3293  {
3294  if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
3295  {
3296  result.m_value.destroy(result.m_type);
3297  result.m_type = value_t::discarded;
3298  }
3299  break;
3300  }
3301 
3302  // parse values
3303  string_t key;
3304  BasicJsonType value;
3305  while (true)
3306  {
3307  // store key
3308  if (not expect(token_type::value_string))
3309  {
3310  return;
3311  }
3312  key = m_lexer.move_string();
3313 
3314  bool keep_tag = false;
3315  if (keep)
3316  {
3317  if (callback)
3318  {
3319  BasicJsonType k(key);
3320  keep_tag = callback(depth, parse_event_t::key, k);
3321  }
3322  else
3323  {
3324  keep_tag = true;
3325  }
3326  }
3327 
3328  // parse separator (:)
3329  get_token();
3330  if (not expect(token_type::name_separator))
3331  {
3332  return;
3333  }
3334 
3335  // parse and add value
3336  get_token();
3337  value.m_value.destroy(value.m_type);
3338  value.m_type = value_t::discarded;
3339  parse_internal(keep, value);
3340 
3341  if (JSON_UNLIKELY(errored))
3342  {
3343  return;
3344  }
3345 
3346  if (keep and keep_tag and not value.is_discarded())
3347  {
3348  result.m_value.object->emplace(std::move(key), std::move(value));
3349  }
3350 
3351  // comma -> next value
3352  get_token();
3353  if (last_token == token_type::value_separator)
3354  {
3355  get_token();
3356  continue;
3357  }
3358 
3359  // closing }
3360  if (not expect(token_type::end_object))
3361  {
3362  return;
3363  }
3364  break;
3365  }
3366 
3367  if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
3368  {
3369  result.m_value.destroy(result.m_type);
3370  result.m_type = value_t::discarded;
3371  }
3372  break;
3373  }
3374 
3375  case token_type::begin_array:
3376  {
3377  if (keep)
3378  {
3379  if (callback)
3380  {
3381  keep = callback(depth++, parse_event_t::array_start, result);
3382  }
3383 
3384  if (not callback or keep)
3385  {
3386  // explicitly set result to array to cope with []
3387  result.m_type = value_t::array;
3388  result.m_value = value_t::array;
3389  }
3390  }
3391 
3392  // read next token
3393  get_token();
3394 
3395  // closing ] -> we are done
3396  if (last_token == token_type::end_array)
3397  {
3398  if (callback and not callback(--depth, parse_event_t::array_end, result))
3399  {
3400  result.m_value.destroy(result.m_type);
3401  result.m_type = value_t::discarded;
3402  }
3403  break;
3404  }
3405 
3406  // parse values
3407  BasicJsonType value;
3408  while (true)
3409  {
3410  // parse value
3411  value.m_value.destroy(value.m_type);
3412  value.m_type = value_t::discarded;
3413  parse_internal(keep, value);
3414 
3415  if (JSON_UNLIKELY(errored))
3416  {
3417  return;
3418  }
3419 
3420  if (keep and not value.is_discarded())
3421  {
3422  result.m_value.array->push_back(std::move(value));
3423  }
3424 
3425  // comma -> next value
3426  get_token();
3427  if (last_token == token_type::value_separator)
3428  {
3429  get_token();
3430  continue;
3431  }
3432 
3433  // closing ]
3434  if (not expect(token_type::end_array))
3435  {
3436  return;
3437  }
3438  break;
3439  }
3440 
3441  if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
3442  {
3443  result.m_value.destroy(result.m_type);
3444  result.m_type = value_t::discarded;
3445  }
3446  break;
3447  }
3448 
3449  case token_type::literal_null:
3450  {
3451  result.m_type = value_t::null;
3452  break;
3453  }
3454 
3455  case token_type::value_string:
3456  {
3457  result.m_type = value_t::string;
3458  result.m_value = m_lexer.move_string();
3459  break;
3460  }
3461 
3462  case token_type::literal_true:
3463  {
3464  result.m_type = value_t::boolean;
3465  result.m_value = true;
3466  break;
3467  }
3468 
3469  case token_type::literal_false:
3470  {
3471  result.m_type = value_t::boolean;
3472  result.m_value = false;
3473  break;
3474  }
3475 
3476  case token_type::value_unsigned:
3477  {
3478  result.m_type = value_t::number_unsigned;
3479  result.m_value = m_lexer.get_number_unsigned();
3480  break;
3481  }
3482 
3483  case token_type::value_integer:
3484  {
3485  result.m_type = value_t::number_integer;
3486  result.m_value = m_lexer.get_number_integer();
3487  break;
3488  }
3489 
3490  case token_type::value_float:
3491  {
3492  result.m_type = value_t::number_float;
3493  result.m_value = m_lexer.get_number_float();
3494 
3495  // throw in case of infinity or NAN
3496  if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float)))
3497  {
3498  if (allow_exceptions)
3499  {
3500  JSON_THROW(out_of_range::create(406, "number overflow parsing '" +
3501  m_lexer.get_token_string() + "'"));
3502  }
3503  expect(token_type::uninitialized);
3504  }
3505  break;
3506  }
3507 
3508  case token_type::parse_error:
3509  {
3510  // using "uninitialized" to avoid "expected" message
3511  if (not expect(token_type::uninitialized))
3512  {
3513  return;
3514  }
3515  break; // LCOV_EXCL_LINE
3516  }
3517 
3518  default:
3519  {
3520  // the last token was unexpected; we expected a value
3521  if (not expect(token_type::literal_or_value))
3522  {
3523  return;
3524  }
3525  break; // LCOV_EXCL_LINE
3526  }
3527  }
3528 
3529  if (keep and callback and not callback(depth, parse_event_t::value, result))
3530  {
3531  result.m_value.destroy(result.m_type);
3532  result.m_type = value_t::discarded;
3533  }
3534  }
3535 
3536  /*!
3537  @brief the actual acceptor
3538 
3539  @invariant 1. The last token is not yet processed. Therefore, the caller
3540  of this function must make sure a token has been read.
3541  2. When this function returns, the last token is processed.
3542  That is, the last read character was already considered.
3543 
3544  This invariant makes sure that no token needs to be "unput".
3545  */
3546  bool accept_internal()
3547  {
3548  switch (last_token)
3549  {
3550  case token_type::begin_object:
3551  {
3552  // read next token
3553  get_token();
3554 
3555  // closing } -> we are done
3556  if (last_token == token_type::end_object)
3557  {
3558  return true;
3559  }
3560 
3561  // parse values
3562  while (true)
3563  {
3564  // parse key
3565  if (last_token != token_type::value_string)
3566  {
3567  return false;
3568  }
3569 
3570  // parse separator (:)
3571  get_token();
3572  if (last_token != token_type::name_separator)
3573  {
3574  return false;
3575  }
3576 
3577  // parse value
3578  get_token();
3579  if (not accept_internal())
3580  {
3581  return false;
3582  }
3583 
3584  // comma -> next value
3585  get_token();
3586  if (last_token == token_type::value_separator)
3587  {
3588  get_token();
3589  continue;
3590  }
3591 
3592  // closing }
3593  return (last_token == token_type::end_object);
3594  }
3595  }
3596 
3597  case token_type::begin_array:
3598  {
3599  // read next token
3600  get_token();
3601 
3602  // closing ] -> we are done
3603  if (last_token == token_type::end_array)
3604  {
3605  return true;
3606  }
3607 
3608  // parse values
3609  while (true)
3610  {
3611  // parse value
3612  if (not accept_internal())
3613  {
3614  return false;
3615  }
3616 
3617  // comma -> next value
3618  get_token();
3619  if (last_token == token_type::value_separator)
3620  {
3621  get_token();
3622  continue;
3623  }
3624 
3625  // closing ]
3626  return (last_token == token_type::end_array);
3627  }
3628  }
3629 
3630  case token_type::value_float:
3631  {
3632  // reject infinity or NAN
3633  return std::isfinite(m_lexer.get_number_float());
3634  }
3635 
3636  case token_type::literal_false:
3637  case token_type::literal_null:
3638  case token_type::literal_true:
3639  case token_type::value_integer:
3640  case token_type::value_string:
3641  case token_type::value_unsigned:
3642  return true;
3643 
3644  default: // the last token was unexpected
3645  return false;
3646  }
3647  }
3648 
3649  /// get next token from lexer
3650  token_type get_token()
3651  {
3652  return (last_token = m_lexer.scan());
3653  }
3654 
3655  /*!
3656  @throw parse_error.101 if expected token did not occur
3657  */
3658  bool expect(token_type t)
3659  {
3660  if (JSON_UNLIKELY(t != last_token))
3661  {
3662  errored = true;
3663  expected = t;
3664  if (allow_exceptions)
3665  {
3666  throw_exception();
3667  }
3668  else
3669  {
3670  return false;
3671  }
3672  }
3673 
3674  return true;
3675  }
3676 
3677  [[noreturn]] void throw_exception() const
3678  {
3679  std::string error_msg = "syntax error - ";
3680  if (last_token == token_type::parse_error)
3681  {
3682  error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
3683  m_lexer.get_token_string() + "'";
3684  }
3685  else
3686  {
3687  error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
3688  }
3689 
3690  if (expected != token_type::uninitialized)
3691  {
3692  error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
3693  }
3694 
3695  JSON_THROW(parse_error::create(101, m_lexer.get_position(), error_msg));
3696  }
3697 
3698  private:
3699  /// current level of recursion
3700  int depth = 0;
3701  /// callback function
3702  const parser_callback_t callback = nullptr;
3703  /// the type of the last read token
3704  token_type last_token = token_type::uninitialized;
3705  /// the lexer
3706  lexer_t m_lexer;
3707  /// whether a syntax error occurred
3708  bool errored = false;
3709  /// possible reason for the syntax error
3710  token_type expected = token_type::uninitialized;
3711  /// whether to throw exceptions in case of errors
3712  const bool allow_exceptions = true;
3713 };
3714 }
3715 }
3716 
3717 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
3718 
3719 
3720 #include <cstddef> // ptrdiff_t
3721 #include <limits> // numeric_limits
3722 
3723 namespace nlohmann
3724 {
3725 namespace detail
3726 {
3727 /*
3728 @brief an iterator for primitive JSON types
3729 
3730 This class models an iterator for primitive JSON types (boolean, number,
3731 string). It's only purpose is to allow the iterator/const_iterator classes
3732 to "iterate" over primitive values. Internally, the iterator is modeled by
3733 a `difference_type` variable. Value begin_value (`0`) models the begin,
3734 end_value (`1`) models past the end.
3735 */
3736 class primitive_iterator_t
3737 {
3738  private:
3739  using difference_type = std::ptrdiff_t;
3740  static constexpr difference_type begin_value = 0;
3741  static constexpr difference_type end_value = begin_value + 1;
3742 
3743  /// iterator as signed integer type
3744  difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
3745 
3746  public:
3747  constexpr difference_type get_value() const noexcept
3748  {
3749  return m_it;
3750  }
3751 
3752  /// set iterator to a defined beginning
3753  void set_begin() noexcept
3754  {
3755  m_it = begin_value;
3756  }
3757 
3758  /// set iterator to a defined past the end
3759  void set_end() noexcept
3760  {
3761  m_it = end_value;
3762  }
3763 
3764  /// return whether the iterator can be dereferenced
3765  constexpr bool is_begin() const noexcept
3766  {
3767  return m_it == begin_value;
3768  }
3769 
3770  /// return whether the iterator is at end
3771  constexpr bool is_end() const noexcept
3772  {
3773  return m_it == end_value;
3774  }
3775 
3776  friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
3777  {
3778  return lhs.m_it == rhs.m_it;
3779  }
3780 
3781  friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
3782  {
3783  return lhs.m_it < rhs.m_it;
3784  }
3785 
3786  primitive_iterator_t operator+(difference_type n) noexcept
3787  {
3788  auto result = *this;
3789  result += n;
3790  return result;
3791  }
3792 
3793  friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
3794  {
3795  return lhs.m_it - rhs.m_it;
3796  }
3797 
3798  primitive_iterator_t& operator++() noexcept
3799  {
3800  ++m_it;
3801  return *this;
3802  }
3803 
3804  primitive_iterator_t const operator++(int) noexcept
3805  {
3806  auto result = *this;
3807  m_it++;
3808  return result;
3809  }
3810 
3811  primitive_iterator_t& operator--() noexcept
3812  {
3813  --m_it;
3814  return *this;
3815  }
3816 
3817  primitive_iterator_t const operator--(int) noexcept
3818  {
3819  auto result = *this;
3820  m_it--;
3821  return result;
3822  }
3823 
3824  primitive_iterator_t& operator+=(difference_type n) noexcept
3825  {
3826  m_it += n;
3827  return *this;
3828  }
3829 
3830  primitive_iterator_t& operator-=(difference_type n) noexcept
3831  {
3832  m_it -= n;
3833  return *this;
3834  }
3835 };
3836 }
3837 }
3838 
3839 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
3840 
3841 
3842 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
3843 
3844 
3845 namespace nlohmann
3846 {
3847 namespace detail
3848 {
3849 /*!
3850 @brief an iterator value
3851 
3852 @note This structure could easily be a union, but MSVC currently does not allow
3853 unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
3854 */
3855 template<typename BasicJsonType> struct internal_iterator
3856 {
3857  /// iterator for JSON objects
3858  typename BasicJsonType::object_t::iterator object_iterator {};
3859  /// iterator for JSON arrays
3860  typename BasicJsonType::array_t::iterator array_iterator {};
3861  /// generic iterator for all other types
3862  primitive_iterator_t primitive_iterator {};
3863 };
3864 }
3865 }
3866 
3867 // #include <nlohmann/detail/iterators/iter_impl.hpp>
3868 
3869 
3870 #include <ciso646> // not
3871 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
3872 #include <type_traits> // conditional, is_const, remove_const
3873 
3874 // #include <nlohmann/detail/exceptions.hpp>
3875 
3876 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
3877 
3878 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
3879 
3880 // #include <nlohmann/detail/macro_scope.hpp>
3881 
3882 // #include <nlohmann/detail/meta.hpp>
3883 
3884 // #include <nlohmann/detail/value_t.hpp>
3885 
3886 
3887 namespace nlohmann
3888 {
3889 namespace detail
3890 {
3891 // forward declare, to be able to friend it later on
3892 template<typename IteratorType> class iteration_proxy;
3893 
3894 /*!
3895 @brief a template for a bidirectional iterator for the @ref basic_json class
3896 
3897 This class implements a both iterators (iterator and const_iterator) for the
3898 @ref basic_json class.
3899 
3900 @note An iterator is called *initialized* when a pointer to a JSON value has
3901  been set (e.g., by a constructor or a copy assignment). If the iterator is
3902  default-constructed, it is *uninitialized* and most methods are undefined.
3903  **The library uses assertions to detect calls on uninitialized iterators.**
3904 
3905 @requirement The class satisfies the following concept requirements:
3906 -
3907 [BidirectionalIterator](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator):
3908  The iterator that can be moved can be moved in both directions (i.e.
3909  incremented and decremented).
3910 
3911 @since version 1.0.0, simplified in version 2.0.9, change to bidirectional
3912  iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
3913 */
3914 template<typename BasicJsonType>
3915 class iter_impl
3916 {
3917  /// allow basic_json to access private members
3918  friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
3919  friend BasicJsonType;
3920  friend iteration_proxy<iter_impl>;
3921 
3922  using object_t = typename BasicJsonType::object_t;
3923  using array_t = typename BasicJsonType::array_t;
3924  // make sure BasicJsonType is basic_json or const basic_json
3925  static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
3926  "iter_impl only accepts (const) basic_json");
3927 
3928  public:
3929 
3930  /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
3931  /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
3932  /// A user-defined iterator should provide publicly accessible typedefs named
3933  /// iterator_category, value_type, difference_type, pointer, and reference.
3934  /// Note that value_type is required to be non-const, even for constant iterators.
3935  using iterator_category = std::bidirectional_iterator_tag;
3936 
3937  /// the type of the values when the iterator is dereferenced
3938  using value_type = typename BasicJsonType::value_type;
3939  /// a type to represent differences between iterators
3940  using difference_type = typename BasicJsonType::difference_type;
3941  /// defines a pointer to the type iterated over (value_type)
3942  using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
3943  typename BasicJsonType::const_pointer,
3944  typename BasicJsonType::pointer>::type;
3945  /// defines a reference to the type iterated over (value_type)
3946  using reference =
3947  typename std::conditional<std::is_const<BasicJsonType>::value,
3948  typename BasicJsonType::const_reference,
3949  typename BasicJsonType::reference>::type;
3950 
3951  /// default constructor
3952  iter_impl() = default;
3953 
3954  /*!
3955  @brief constructor for a given JSON instance
3956  @param[in] object pointer to a JSON object for this iterator
3957  @pre object != nullptr
3958  @post The iterator is initialized; i.e. `m_object != nullptr`.
3959  */
3960  explicit iter_impl(pointer object) noexcept : m_object(object)
3961  {
3962  assert(m_object != nullptr);
3963 
3964  switch (m_object->m_type)
3965  {
3966  case value_t::object:
3967  {
3968  m_it.object_iterator = typename object_t::iterator();
3969  break;
3970  }
3971 
3972  case value_t::array:
3973  {
3974  m_it.array_iterator = typename array_t::iterator();
3975  break;
3976  }
3977 
3978  default:
3979  {
3980  m_it.primitive_iterator = primitive_iterator_t();
3981  break;
3982  }
3983  }
3984  }
3985 
3986  /*!
3987  @note The conventional copy constructor and copy assignment are implicitly
3988  defined. Combined with the following converting constructor and
3989  assignment, they support: (1) copy from iterator to iterator, (2)
3990  copy from const iterator to const iterator, and (3) conversion from
3991  iterator to const iterator. However conversion from const iterator
3992  to iterator is not defined.
3993  */
3994 
3995  /*!
3996  @brief converting constructor
3997  @param[in] other non-const iterator to copy from
3998  @note It is not checked whether @a other is initialized.
3999  */
4000  iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
4001  : m_object(other.m_object), m_it(other.m_it) {}
4002 
4003  /*!
4004  @brief converting assignment
4005  @param[in,out] other non-const iterator to copy from
4006  @return const/non-const iterator
4007  @note It is not checked whether @a other is initialized.
4008  */
4009  iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
4010  {
4011  m_object = other.m_object;
4012  m_it = other.m_it;
4013  return *this;
4014  }
4015 
4016  private:
4017  /*!
4018  @brief set the iterator to the first value
4019  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4020  */
4021  void set_begin() noexcept
4022  {
4023  assert(m_object != nullptr);
4024 
4025  switch (m_object->m_type)
4026  {
4027  case value_t::object:
4028  {
4029  m_it.object_iterator = m_object->m_value.object->begin();
4030  break;
4031  }
4032 
4033  case value_t::array:
4034  {
4035  m_it.array_iterator = m_object->m_value.array->begin();
4036  break;
4037  }
4038 
4039  case value_t::null:
4040  {
4041  // set to end so begin()==end() is true: null is empty
4042  m_it.primitive_iterator.set_end();
4043  break;
4044  }
4045 
4046  default:
4047  {
4048  m_it.primitive_iterator.set_begin();
4049  break;
4050  }
4051  }
4052  }
4053 
4054  /*!
4055  @brief set the iterator past the last value
4056  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4057  */
4058  void set_end() noexcept
4059  {
4060  assert(m_object != nullptr);
4061 
4062  switch (m_object->m_type)
4063  {
4064  case value_t::object:
4065  {
4066  m_it.object_iterator = m_object->m_value.object->end();
4067  break;
4068  }
4069 
4070  case value_t::array:
4071  {
4072  m_it.array_iterator = m_object->m_value.array->end();
4073  break;
4074  }
4075 
4076  default:
4077  {
4078  m_it.primitive_iterator.set_end();
4079  break;
4080  }
4081  }
4082  }
4083 
4084  public:
4085  /*!
4086  @brief return a reference to the value pointed to by the iterator
4087  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4088  */
4089  reference operator*() const
4090  {
4091  assert(m_object != nullptr);
4092 
4093  switch (m_object->m_type)
4094  {
4095  case value_t::object:
4096  {
4097  assert(m_it.object_iterator != m_object->m_value.object->end());
4098  return m_it.object_iterator->second;
4099  }
4100 
4101  case value_t::array:
4102  {
4103  assert(m_it.array_iterator != m_object->m_value.array->end());
4104  return *m_it.array_iterator;
4105  }
4106 
4107  case value_t::null:
4108  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
4109 
4110  default:
4111  {
4112  if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
4113  {
4114  return *m_object;
4115  }
4116 
4117  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
4118  }
4119  }
4120  }
4121 
4122  /*!
4123  @brief dereference the iterator
4124  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4125  */
4126  pointer operator->() const
4127  {
4128  assert(m_object != nullptr);
4129 
4130  switch (m_object->m_type)
4131  {
4132  case value_t::object:
4133  {
4134  assert(m_it.object_iterator != m_object->m_value.object->end());
4135  return &(m_it.object_iterator->second);
4136  }
4137 
4138  case value_t::array:
4139  {
4140  assert(m_it.array_iterator != m_object->m_value.array->end());
4141  return &*m_it.array_iterator;
4142  }
4143 
4144  default:
4145  {
4146  if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
4147  {
4148  return m_object;
4149  }
4150 
4151  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
4152  }
4153  }
4154  }
4155 
4156  /*!
4157  @brief post-increment (it++)
4158  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4159  */
4160  iter_impl const operator++(int)
4161  {
4162  auto result = *this;
4163  ++(*this);
4164  return result;
4165  }
4166 
4167  /*!
4168  @brief pre-increment (++it)
4169  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4170  */
4171  iter_impl& operator++()
4172  {
4173  assert(m_object != nullptr);
4174 
4175  switch (m_object->m_type)
4176  {
4177  case value_t::object:
4178  {
4179  std::advance(m_it.object_iterator, 1);
4180  break;
4181  }
4182 
4183  case value_t::array:
4184  {
4185  std::advance(m_it.array_iterator, 1);
4186  break;
4187  }
4188 
4189  default:
4190  {
4191  ++m_it.primitive_iterator;
4192  break;
4193  }
4194  }
4195 
4196  return *this;
4197  }
4198 
4199  /*!
4200  @brief post-decrement (it--)
4201  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4202  */
4203  iter_impl const operator--(int)
4204  {
4205  auto result = *this;
4206  --(*this);
4207  return result;
4208  }
4209 
4210  /*!
4211  @brief pre-decrement (--it)
4212  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4213  */
4214  iter_impl& operator--()
4215  {
4216  assert(m_object != nullptr);
4217 
4218  switch (m_object->m_type)
4219  {
4220  case value_t::object:
4221  {
4222  std::advance(m_it.object_iterator, -1);
4223  break;
4224  }
4225 
4226  case value_t::array:
4227  {
4228  std::advance(m_it.array_iterator, -1);
4229  break;
4230  }
4231 
4232  default:
4233  {
4234  --m_it.primitive_iterator;
4235  break;
4236  }
4237  }
4238 
4239  return *this;
4240  }
4241 
4242  /*!
4243  @brief comparison: equal
4244  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4245  */
4246  bool operator==(const iter_impl& other) const
4247  {
4248  // if objects are not the same, the comparison is undefined
4249  if (JSON_UNLIKELY(m_object != other.m_object))
4250  {
4251  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
4252  }
4253 
4254  assert(m_object != nullptr);
4255 
4256  switch (m_object->m_type)
4257  {
4258  case value_t::object:
4259  return (m_it.object_iterator == other.m_it.object_iterator);
4260 
4261  case value_t::array:
4262  return (m_it.array_iterator == other.m_it.array_iterator);
4263 
4264  default:
4265  return (m_it.primitive_iterator == other.m_it.primitive_iterator);
4266  }
4267  }
4268 
4269  /*!
4270  @brief comparison: not equal
4271  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4272  */
4273  bool operator!=(const iter_impl& other) const
4274  {
4275  return not operator==(other);
4276  }
4277 
4278  /*!
4279  @brief comparison: smaller
4280  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4281  */
4282  bool operator<(const iter_impl& other) const
4283  {
4284  // if objects are not the same, the comparison is undefined
4285  if (JSON_UNLIKELY(m_object != other.m_object))
4286  {
4287  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
4288  }
4289 
4290  assert(m_object != nullptr);
4291 
4292  switch (m_object->m_type)
4293  {
4294  case value_t::object:
4295  JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
4296 
4297  case value_t::array:
4298  return (m_it.array_iterator < other.m_it.array_iterator);
4299 
4300  default:
4301  return (m_it.primitive_iterator < other.m_it.primitive_iterator);
4302  }
4303  }
4304 
4305  /*!
4306  @brief comparison: less than or equal
4307  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4308  */
4309  bool operator<=(const iter_impl& other) const
4310  {
4311  return not other.operator < (*this);
4312  }
4313 
4314  /*!
4315  @brief comparison: greater than
4316  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4317  */
4318  bool operator>(const iter_impl& other) const
4319  {
4320  return not operator<=(other);
4321  }
4322 
4323  /*!
4324  @brief comparison: greater than or equal
4325  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4326  */
4327  bool operator>=(const iter_impl& other) const
4328  {
4329  return not operator<(other);
4330  }
4331 
4332  /*!
4333  @brief add to iterator
4334  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4335  */
4336  iter_impl& operator+=(difference_type i)
4337  {
4338  assert(m_object != nullptr);
4339 
4340  switch (m_object->m_type)
4341  {
4342  case value_t::object:
4343  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
4344 
4345  case value_t::array:
4346  {
4347  std::advance(m_it.array_iterator, i);
4348  break;
4349  }
4350 
4351  default:
4352  {
4353  m_it.primitive_iterator += i;
4354  break;
4355  }
4356  }
4357 
4358  return *this;
4359  }
4360 
4361  /*!
4362  @brief subtract from iterator
4363  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4364  */
4365  iter_impl& operator-=(difference_type i)
4366  {
4367  return operator+=(-i);
4368  }
4369 
4370  /*!
4371  @brief add to iterator
4372  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4373  */
4374  iter_impl operator+(difference_type i) const
4375  {
4376  auto result = *this;
4377  result += i;
4378  return result;
4379  }
4380 
4381  /*!
4382  @brief addition of distance and iterator
4383  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4384  */
4385  friend iter_impl operator+(difference_type i, const iter_impl& it)
4386  {
4387  auto result = it;
4388  result += i;
4389  return result;
4390  }
4391 
4392  /*!
4393  @brief subtract from iterator
4394  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4395  */
4396  iter_impl operator-(difference_type i) const
4397  {
4398  auto result = *this;
4399  result -= i;
4400  return result;
4401  }
4402 
4403  /*!
4404  @brief return difference
4405  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4406  */
4407  difference_type operator-(const iter_impl& other) const
4408  {
4409  assert(m_object != nullptr);
4410 
4411  switch (m_object->m_type)
4412  {
4413  case value_t::object:
4414  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
4415 
4416  case value_t::array:
4417  return m_it.array_iterator - other.m_it.array_iterator;
4418 
4419  default:
4420  return m_it.primitive_iterator - other.m_it.primitive_iterator;
4421  }
4422  }
4423 
4424  /*!
4425  @brief access to successor
4426  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4427  */
4428  reference operator[](difference_type n) const
4429  {
4430  assert(m_object != nullptr);
4431 
4432  switch (m_object->m_type)
4433  {
4434  case value_t::object:
4435  JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
4436 
4437  case value_t::array:
4438  return *std::next(m_it.array_iterator, n);
4439 
4440  case value_t::null:
4441  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
4442 
4443  default:
4444  {
4445  if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n))
4446  {
4447  return *m_object;
4448  }
4449 
4450  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
4451  }
4452  }
4453  }
4454 
4455  /*!
4456  @brief return the key of an object iterator
4457  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4458  */
4459  typename object_t::key_type key() const
4460  {
4461  assert(m_object != nullptr);
4462 
4463  if (JSON_LIKELY(m_object->is_object()))
4464  {
4465  return m_it.object_iterator->first;
4466  }
4467 
4468  JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
4469  }
4470 
4471  /*!
4472  @brief return the value of an iterator
4473  @pre The iterator is initialized; i.e. `m_object != nullptr`.
4474  */
4475  reference value() const
4476  {
4477  return operator*();
4478  }
4479 
4480  private:
4481  /// associated JSON instance
4482  pointer m_object = nullptr;
4483  /// the actual iterator of the associated instance
4484  internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it;
4485 };
4486 }
4487 }
4488 
4489 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
4490 
4491 
4492 #include <cstddef> // size_t
4493 #include <string> // string, to_string
4494 
4495 // #include <nlohmann/detail/value_t.hpp>
4496 
4497 
4498 namespace nlohmann
4499 {
4500 namespace detail
4501 {
4502 /// proxy class for the items() function
4503 template<typename IteratorType> class iteration_proxy
4504 {
4505  private:
4506  /// helper class for iteration
4507  class iteration_proxy_internal
4508  {
4509  private:
4510  /// the iterator
4511  IteratorType anchor;
4512  /// an index for arrays (used to create key names)
4513  std::size_t array_index = 0;
4514 
4515  public:
4516  explicit iteration_proxy_internal(IteratorType it) noexcept : anchor(it) {}
4517 
4518  /// dereference operator (needed for range-based for)
4519  iteration_proxy_internal& operator*()
4520  {
4521  return *this;
4522  }
4523 
4524  /// increment operator (needed for range-based for)
4525  iteration_proxy_internal& operator++()
4526  {
4527  ++anchor;
4528  ++array_index;
4529 
4530  return *this;
4531  }
4532 
4533  /// inequality operator (needed for range-based for)
4534  bool operator!=(const iteration_proxy_internal& o) const noexcept
4535  {
4536  return anchor != o.anchor;
4537  }
4538 
4539  /// return key of the iterator
4540  std::string key() const
4541  {
4542  assert(anchor.m_object != nullptr);
4543 
4544  switch (anchor.m_object->type())
4545  {
4546  // use integer array index as key
4547  case value_t::array:
4548  return std::to_string(array_index);
4549 
4550  // use key from the object
4551  case value_t::object:
4552  return anchor.key();
4553 
4554  // use an empty key for all primitive types
4555  default:
4556  return "";
4557  }
4558  }
4559 
4560  /// return value of the iterator
4561  typename IteratorType::reference value() const
4562  {
4563  return anchor.value();
4564  }
4565  };
4566 
4567  /// the container to iterate
4568  typename IteratorType::reference container;
4569 
4570  public:
4571  /// construct iteration proxy from a container
4572  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
4573  : container(cont) {}
4574 
4575  /// return iterator begin (needed for range-based for)
4576  iteration_proxy_internal begin() noexcept
4577  {
4578  return iteration_proxy_internal(container.begin());
4579  }
4580 
4581  /// return iterator end (needed for range-based for)
4582  iteration_proxy_internal end() noexcept
4583  {
4584  return iteration_proxy_internal(container.end());
4585  }
4586 };
4587 }
4588 }
4589 
4590 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
4591 
4592 
4593 #include <cstddef> // ptrdiff_t
4594 #include <iterator> // reverse_iterator
4595 #include <utility> // declval
4596 
4597 namespace nlohmann
4598 {
4599 namespace detail
4600 {
4601 //////////////////////
4602 // reverse_iterator //
4603 //////////////////////
4604 
4605 /*!
4606 @brief a template for a reverse iterator class
4607 
4608 @tparam Base the base iterator type to reverse. Valid types are @ref
4609 iterator (to create @ref reverse_iterator) and @ref const_iterator (to
4610 create @ref const_reverse_iterator).
4611 
4612 @requirement The class satisfies the following concept requirements:
4613 -
4614 [BidirectionalIterator](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator):
4615  The iterator that can be moved can be moved in both directions (i.e.
4616  incremented and decremented).
4617 - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
4618  It is possible to write to the pointed-to element (only if @a Base is
4619  @ref iterator).
4620 
4621 @since version 1.0.0
4622 */
4623 template<typename Base>
4624 class json_reverse_iterator : public std::reverse_iterator<Base>
4625 {
4626  public:
4627  using difference_type = std::ptrdiff_t;
4628  /// shortcut to the reverse iterator adapter
4629  using base_iterator = std::reverse_iterator<Base>;
4630  /// the reference type for the pointed-to element
4631  using reference = typename Base::reference;
4632 
4633  /// create reverse iterator from iterator
4634  json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
4635  : base_iterator(it) {}
4636 
4637  /// create reverse iterator from base class
4638  json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
4639 
4640  /// post-increment (it++)
4641  json_reverse_iterator const operator++(int)
4642  {
4643  return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
4644  }
4645 
4646  /// pre-increment (++it)
4647  json_reverse_iterator& operator++()
4648  {
4649  return static_cast<json_reverse_iterator&>(base_iterator::operator++());
4650  }
4651 
4652  /// post-decrement (it--)
4653  json_reverse_iterator const operator--(int)
4654  {
4655  return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
4656  }
4657 
4658  /// pre-decrement (--it)
4659  json_reverse_iterator& operator--()
4660  {
4661  return static_cast<json_reverse_iterator&>(base_iterator::operator--());
4662  }
4663 
4664  /// add to iterator
4665  json_reverse_iterator& operator+=(difference_type i)
4666  {
4667  return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
4668  }
4669 
4670  /// add to iterator
4671  json_reverse_iterator operator+(difference_type i) const
4672  {
4673  return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
4674  }
4675 
4676  /// subtract from iterator
4677  json_reverse_iterator operator-(difference_type i) const
4678  {
4679  return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
4680  }
4681 
4682  /// return difference
4683  difference_type operator-(const json_reverse_iterator& other) const
4684  {
4685  return base_iterator(*this) - base_iterator(other);
4686  }
4687 
4688  /// access to successor
4689  reference operator[](difference_type n) const
4690  {
4691  return *(this->operator+(n));
4692  }
4693 
4694  /// return the key of an object iterator
4695  auto key() const -> decltype(std::declval<Base>().key())
4696  {
4697  auto it = --this->base();
4698  return it.key();
4699  }
4700 
4701  /// return the value of an iterator
4702  reference value() const
4703  {
4704  auto it = --this->base();
4705  return it.operator * ();
4706  }
4707 };
4708 }
4709 }
4710 
4711 // #include <nlohmann/detail/output/output_adapters.hpp>
4712 
4713 
4714 #include <algorithm> // copy
4715 #include <cstddef> // size_t
4716 #include <ios> // streamsize
4717 #include <iterator> // back_inserter
4718 #include <memory> // shared_ptr, make_shared
4719 #include <ostream> // basic_ostream
4720 #include <string> // basic_string
4721 #include <vector> // vector
4722 
4723 namespace nlohmann
4724 {
4725 namespace detail
4726 {
4727 /// abstract output adapter interface
4728 template<typename CharType> struct output_adapter_protocol
4729 {
4730  virtual void write_character(CharType c) = 0;
4731  virtual void write_characters(const CharType* s, std::size_t length) = 0;
4732  virtual ~output_adapter_protocol() = default;
4733 };
4734 
4735 /// a type to simplify interfaces
4736 template<typename CharType>
4737 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
4738 
4739 /// output adapter for byte vectors
4740 template<typename CharType>
4741 class output_vector_adapter : public output_adapter_protocol<CharType>
4742 {
4743  public:
4744  explicit output_vector_adapter(std::vector<CharType>& vec) : v(vec) {}
4745 
4746  void write_character(CharType c) override
4747  {
4748  v.push_back(c);
4749  }
4750 
4751  void write_characters(const CharType* s, std::size_t length) override
4752  {
4753  std::copy(s, s + length, std::back_inserter(v));
4754  }
4755 
4756  private:
4757  std::vector<CharType>& v;
4758 };
4759 
4760 /// output adapter for output streams
4761 template<typename CharType>
4762 class output_stream_adapter : public output_adapter_protocol<CharType>
4763 {
4764  public:
4765  explicit output_stream_adapter(std::basic_ostream<CharType>& s) : stream(s) {}
4766 
4767  void write_character(CharType c) override
4768  {
4769  stream.put(c);
4770  }
4771 
4772  void write_characters(const CharType* s, std::size_t length) override
4773  {
4774  stream.write(s, static_cast<std::streamsize>(length));
4775  }
4776 
4777  private:
4778  std::basic_ostream<CharType>& stream;
4779 };
4780 
4781 /// output adapter for basic_string
4782 template<typename CharType, typename StringType = std::basic_string<CharType>>
4783 class output_string_adapter : public output_adapter_protocol<CharType>
4784 {
4785  public:
4786  explicit output_string_adapter(StringType& s) : str(s) {}
4787 
4788  void write_character(CharType c) override
4789  {
4790  str.push_back(c);
4791  }
4792 
4793  void write_characters(const CharType* s, std::size_t length) override
4794  {
4795  str.append(s, length);
4796  }
4797 
4798  private:
4799  StringType& str;
4800 };
4801 
4802 template<typename CharType, typename StringType = std::basic_string<CharType>>
4803 class output_adapter
4804 {
4805  public:
4806  output_adapter(std::vector<CharType>& vec)
4807  : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
4808 
4809  output_adapter(std::basic_ostream<CharType>& s)
4810  : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
4811 
4812  output_adapter(StringType& s)
4813  : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
4814 
4815  operator output_adapter_t<CharType>()
4816  {
4817  return oa;
4818  }
4819 
4820  private:
4821  output_adapter_t<CharType> oa = nullptr;
4822 };
4823 }
4824 }
4825 
4826 // #include <nlohmann/detail/input/binary_reader.hpp>
4827 
4828 
4829 #include <algorithm> // generate_n
4830 #include <array> // array
4831 #include <cassert> // assert
4832 #include <cmath> // ldexp
4833 #include <cstddef> // size_t
4834 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
4835 #include <cstring> // memcpy
4836 #include <iomanip> // setw, setfill
4837 #include <ios> // hex
4838 #include <iterator> // back_inserter
4839 #include <limits> // numeric_limits
4840 #include <sstream> // stringstream
4841 #include <string> // char_traits, string
4842 #include <utility> // make_pair, move
4843 
4844 // #include <nlohmann/detail/input/input_adapters.hpp>
4845 
4846 // #include <nlohmann/detail/exceptions.hpp>
4847 
4848 // #include <nlohmann/detail/macro_scope.hpp>
4849 
4850 // #include <nlohmann/detail/value_t.hpp>
4851 
4852 
4853 namespace nlohmann
4854 {
4855 namespace detail
4856 {
4857 ///////////////////
4858 // binary reader //
4859 ///////////////////
4860 
4861 /*!
4862 @brief deserialization of CBOR and MessagePack values
4863 */
4864 template<typename BasicJsonType>
4865 class binary_reader
4866 {
4867  using number_integer_t = typename BasicJsonType::number_integer_t;
4868  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
4869  using string_t = typename BasicJsonType::string_t;
4870 
4871  public:
4872  /*!
4873  @brief create a binary reader
4874 
4875  @param[in] adapter input adapter to read from
4876  */
4877  explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
4878  {
4879  assert(ia);
4880  }
4881 
4882  /*!
4883  @brief create a JSON value from CBOR input
4884 
4885  @param[in] strict whether to expect the input to be consumed completed
4886  @return JSON value created from CBOR input
4887 
4888  @throw parse_error.110 if input ended unexpectedly or the end of file was
4889  not reached when @a strict was set to true
4890  @throw parse_error.112 if unsupported byte was read
4891  */
4892  BasicJsonType parse_cbor(const bool strict)
4893  {
4894  const auto res = parse_cbor_internal();
4895  if (strict)
4896  {
4897  get();
4898  expect_eof();
4899  }
4900  return res;
4901  }
4902 
4903  /*!
4904  @brief create a JSON value from MessagePack input
4905 
4906  @param[in] strict whether to expect the input to be consumed completed
4907  @return JSON value created from MessagePack input
4908 
4909  @throw parse_error.110 if input ended unexpectedly or the end of file was
4910  not reached when @a strict was set to true
4911  @throw parse_error.112 if unsupported byte was read
4912  */
4913  BasicJsonType parse_msgpack(const bool strict)
4914  {
4915  const auto res = parse_msgpack_internal();
4916  if (strict)
4917  {
4918  get();
4919  expect_eof();
4920  }
4921  return res;
4922  }
4923 
4924  /*!
4925  @brief create a JSON value from UBJSON input
4926 
4927  @param[in] strict whether to expect the input to be consumed completed
4928  @return JSON value created from UBJSON input
4929 
4930  @throw parse_error.110 if input ended unexpectedly or the end of file was
4931  not reached when @a strict was set to true
4932  @throw parse_error.112 if unsupported byte was read
4933  */
4934  BasicJsonType parse_ubjson(const bool strict)
4935  {
4936  const auto res = parse_ubjson_internal();
4937  if (strict)
4938  {
4939  get_ignore_noop();
4940  expect_eof();
4941  }
4942  return res;
4943  }
4944 
4945  /*!
4946  @brief determine system byte order
4947 
4948  @return true if and only if system's byte order is little endian
4949 
4950  @note from http://stackoverflow.com/a/1001328/266378
4951  */
4952  static constexpr bool little_endianess(int num = 1) noexcept
4953  {
4954  return (*reinterpret_cast<char*>(&num) == 1);
4955  }
4956 
4957  private:
4958  /*!
4959  @param[in] get_char whether a new character should be retrieved from the
4960  input (true, default) or whether the last read
4961  character should be considered instead
4962  */
4963  BasicJsonType parse_cbor_internal(const bool get_char = true)
4964  {
4965  switch (get_char ? get() : current)
4966  {
4967  // EOF
4968  case std::char_traits<char>::eof():
4969  JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
4970 
4971  // Integer 0x00..0x17 (0..23)
4972  case 0x00:
4973  case 0x01:
4974  case 0x02:
4975  case 0x03:
4976  case 0x04:
4977  case 0x05:
4978  case 0x06:
4979  case 0x07:
4980  case 0x08:
4981  case 0x09:
4982  case 0x0A:
4983  case 0x0B:
4984  case 0x0C:
4985  case 0x0D:
4986  case 0x0E:
4987  case 0x0F:
4988  case 0x10:
4989  case 0x11:
4990  case 0x12:
4991  case 0x13:
4992  case 0x14:
4993  case 0x15:
4994  case 0x16:
4995  case 0x17:
4996  return static_cast<number_unsigned_t>(current);
4997 
4998  case 0x18: // Unsigned integer (one-byte uint8_t follows)
4999  return get_number<uint8_t>();
5000 
5001  case 0x19: // Unsigned integer (two-byte uint16_t follows)
5002  return get_number<uint16_t>();
5003 
5004  case 0x1A: // Unsigned integer (four-byte uint32_t follows)
5005  return get_number<uint32_t>();
5006 
5007  case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
5008  return get_number<uint64_t>();
5009 
5010  // Negative integer -1-0x00..-1-0x17 (-1..-24)
5011  case 0x20:
5012  case 0x21:
5013  case 0x22:
5014  case 0x23:
5015  case 0x24:
5016  case 0x25:
5017  case 0x26:
5018  case 0x27:
5019  case 0x28:
5020  case 0x29:
5021  case 0x2A:
5022  case 0x2B:
5023  case 0x2C:
5024  case 0x2D:
5025  case 0x2E:
5026  case 0x2F:
5027  case 0x30:
5028  case 0x31:
5029  case 0x32:
5030  case 0x33:
5031  case 0x34:
5032  case 0x35:
5033  case 0x36:
5034  case 0x37:
5035  return static_cast<int8_t>(0x20 - 1 - current);
5036 
5037  case 0x38: // Negative integer (one-byte uint8_t follows)
5038  {
5039  return static_cast<number_integer_t>(-1) - get_number<uint8_t>();
5040  }
5041 
5042  case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
5043  {
5044  return static_cast<number_integer_t>(-1) - get_number<uint16_t>();
5045  }
5046 
5047  case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
5048  {
5049  return static_cast<number_integer_t>(-1) - get_number<uint32_t>();
5050  }
5051 
5052  case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
5053  {
5054  return static_cast<number_integer_t>(-1) -
5055  static_cast<number_integer_t>(get_number<uint64_t>());
5056  }
5057 
5058  // UTF-8 string (0x00..0x17 bytes follow)
5059  case 0x60:
5060  case 0x61:
5061  case 0x62:
5062  case 0x63:
5063  case 0x64:
5064  case 0x65:
5065  case 0x66:
5066  case 0x67:
5067  case 0x68:
5068  case 0x69:
5069  case 0x6A:
5070  case 0x6B:
5071  case 0x6C:
5072  case 0x6D:
5073  case 0x6E:
5074  case 0x6F:
5075  case 0x70:
5076  case 0x71:
5077  case 0x72:
5078  case 0x73:
5079  case 0x74:
5080  case 0x75:
5081  case 0x76:
5082  case 0x77:
5083  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
5084  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
5085  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
5086  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
5087  case 0x7F: // UTF-8 string (indefinite length)
5088  {
5089  return get_cbor_string();
5090  }
5091 
5092  // array (0x00..0x17 data items follow)
5093  case 0x80:
5094  case 0x81:
5095  case 0x82:
5096  case 0x83:
5097  case 0x84:
5098  case 0x85:
5099  case 0x86:
5100  case 0x87:
5101  case 0x88:
5102  case 0x89:
5103  case 0x8A:
5104  case 0x8B:
5105  case 0x8C:
5106  case 0x8D:
5107  case 0x8E:
5108  case 0x8F:
5109  case 0x90:
5110  case 0x91:
5111  case 0x92:
5112  case 0x93:
5113  case 0x94:
5114  case 0x95:
5115  case 0x96:
5116  case 0x97:
5117  {
5118  return get_cbor_array(current & 0x1F);
5119  }
5120 
5121  case 0x98: // array (one-byte uint8_t for n follows)
5122  {
5123  return get_cbor_array(get_number<uint8_t>());
5124  }
5125 
5126  case 0x99: // array (two-byte uint16_t for n follow)
5127  {
5128  return get_cbor_array(get_number<uint16_t>());
5129  }
5130 
5131  case 0x9A: // array (four-byte uint32_t for n follow)
5132  {
5133  return get_cbor_array(get_number<uint32_t>());
5134  }
5135 
5136  case 0x9B: // array (eight-byte uint64_t for n follow)
5137  {
5138  return get_cbor_array(get_number<uint64_t>());
5139  }
5140 
5141  case 0x9F: // array (indefinite length)
5142  {
5143  BasicJsonType result = value_t::array;
5144  while (get() != 0xFF)
5145  {
5146  result.push_back(parse_cbor_internal(false));
5147  }
5148  return result;
5149  }
5150 
5151  // map (0x00..0x17 pairs of data items follow)
5152  case 0xA0:
5153  case 0xA1:
5154  case 0xA2:
5155  case 0xA3:
5156  case 0xA4:
5157  case 0xA5:
5158  case 0xA6:
5159  case 0xA7:
5160  case 0xA8:
5161  case 0xA9:
5162  case 0xAA:
5163  case 0xAB:
5164  case 0xAC:
5165  case 0xAD:
5166  case 0xAE:
5167  case 0xAF:
5168  case 0xB0:
5169  case 0xB1:
5170  case 0xB2:
5171  case 0xB3:
5172  case 0xB4:
5173  case 0xB5:
5174  case 0xB6:
5175  case 0xB7:
5176  {
5177  return get_cbor_object(current & 0x1F);
5178  }
5179 
5180  case 0xB8: // map (one-byte uint8_t for n follows)
5181  {
5182  return get_cbor_object(get_number<uint8_t>());
5183  }
5184 
5185  case 0xB9: // map (two-byte uint16_t for n follow)
5186  {
5187  return get_cbor_object(get_number<uint16_t>());
5188  }
5189 
5190  case 0xBA: // map (four-byte uint32_t for n follow)
5191  {
5192  return get_cbor_object(get_number<uint32_t>());
5193  }
5194 
5195  case 0xBB: // map (eight-byte uint64_t for n follow)
5196  {
5197  return get_cbor_object(get_number<uint64_t>());
5198  }
5199 
5200  case 0xBF: // map (indefinite length)
5201  {
5202  BasicJsonType result = value_t::object;
5203  while (get() != 0xFF)
5204  {
5205  auto key = get_cbor_string();
5206  result[key] = parse_cbor_internal();
5207  }
5208  return result;
5209  }
5210 
5211  case 0xF4: // false
5212  {
5213  return false;
5214  }
5215 
5216  case 0xF5: // true
5217  {
5218  return true;
5219  }
5220 
5221  case 0xF6: // null
5222  {
5223  return value_t::null;
5224  }
5225 
5226  case 0xF9: // Half-Precision Float (two-byte IEEE 754)
5227  {
5228  const int byte1 = get();
5229  unexpect_eof();
5230  const int byte2 = get();
5231  unexpect_eof();
5232 
5233  // code from RFC 7049, Appendix D, Figure 3:
5234  // As half-precision floating-point numbers were only added
5235  // to IEEE 754 in 2008, today's programming platforms often
5236  // still only have limited support for them. It is very
5237  // easy to include at least decoding support for them even
5238  // without such support. An example of a small decoder for
5239  // half-precision floating-point numbers in the C language
5240  // is shown in Fig. 3.
5241  const int half = (byte1 << 8) + byte2;
5242  const int exp = (half >> 10) & 0x1F;
5243  const int mant = half & 0x3FF;
5244  double val;
5245  if (exp == 0)
5246  {
5247  val = std::ldexp(mant, -24);
5248  }
5249  else if (exp != 31)
5250  {
5251  val = std::ldexp(mant + 1024, exp - 25);
5252  }
5253  else
5254  {
5255  val = (mant == 0) ? std::numeric_limits<double>::infinity()
5256  : std::numeric_limits<double>::quiet_NaN();
5257  }
5258  return (half & 0x8000) != 0 ? -val : val;
5259  }
5260 
5261  case 0xFA: // Single-Precision Float (four-byte IEEE 754)
5262  {
5263  return get_number<float>();
5264  }
5265 
5266  case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
5267  {
5268  return get_number<double>();
5269  }
5270 
5271  default: // anything else (0xFF is handled inside the other types)
5272  {
5273  std::stringstream ss;
5274  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
5275  JSON_THROW(parse_error::create(112, chars_read, "error reading CBOR; last byte: 0x" + ss.str()));
5276  }
5277  }
5278  }
5279 
5280  BasicJsonType parse_msgpack_internal()
5281  {
5282  switch (get())
5283  {
5284  // EOF
5285  case std::char_traits<char>::eof():
5286  JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
5287 
5288  // positive fixint
5289  case 0x00:
5290  case 0x01:
5291  case 0x02:
5292  case 0x03:
5293  case 0x04:
5294  case 0x05:
5295  case 0x06:
5296  case 0x07:
5297  case 0x08:
5298  case 0x09:
5299  case 0x0A:
5300  case 0x0B:
5301  case 0x0C:
5302  case 0x0D:
5303  case 0x0E:
5304  case 0x0F:
5305  case 0x10:
5306  case 0x11:
5307  case 0x12:
5308  case 0x13:
5309  case 0x14:
5310  case 0x15:
5311  case 0x16:
5312  case 0x17:
5313  case 0x18:
5314  case 0x19:
5315  case 0x1A:
5316  case 0x1B:
5317  case 0x1C:
5318  case 0x1D:
5319  case 0x1E:
5320  case 0x1F:
5321  case 0x20:
5322  case 0x21:
5323  case 0x22:
5324  case 0x23:
5325  case 0x24:
5326  case 0x25:
5327  case 0x26:
5328  case 0x27:
5329  case 0x28:
5330  case 0x29:
5331  case 0x2A:
5332  case 0x2B:
5333  case 0x2C:
5334  case 0x2D:
5335  case 0x2E:
5336  case 0x2F:
5337  case 0x30:
5338  case 0x31:
5339  case 0x32:
5340  case 0x33:
5341  case 0x34:
5342  case 0x35:
5343  case 0x36:
5344  case 0x37:
5345  case 0x38:
5346  case 0x39:
5347  case 0x3A:
5348  case 0x3B:
5349  case 0x3C:
5350  case 0x3D:
5351  case 0x3E:
5352  case 0x3F:
5353  case 0x40:
5354  case 0x41:
5355  case 0x42:
5356  case 0x43:
5357  case 0x44:
5358  case 0x45:
5359  case 0x46:
5360  case 0x47:
5361  case 0x48:
5362  case 0x49:
5363  case 0x4A:
5364  case 0x4B:
5365  case 0x4C:
5366  case 0x4D:
5367  case 0x4E:
5368  case 0x4F:
5369  case 0x50:
5370  case 0x51:
5371  case 0x52:
5372  case 0x53:
5373  case 0x54:
5374  case 0x55:
5375  case 0x56:
5376  case 0x57:
5377  case 0x58:
5378  case 0x59:
5379  case 0x5A:
5380  case 0x5B:
5381  case 0x5C:
5382  case 0x5D:
5383  case 0x5E:
5384  case 0x5F:
5385  case 0x60:
5386  case 0x61:
5387  case 0x62:
5388  case 0x63:
5389  case 0x64:
5390  case 0x65:
5391  case 0x66:
5392  case 0x67:
5393  case 0x68:
5394  case 0x69:
5395  case 0x6A:
5396  case 0x6B:
5397  case 0x6C:
5398  case 0x6D:
5399  case 0x6E:
5400  case 0x6F:
5401  case 0x70:
5402  case 0x71:
5403  case 0x72:
5404  case 0x73:
5405  case 0x74:
5406  case 0x75:
5407  case 0x76:
5408  case 0x77:
5409  case 0x78:
5410  case 0x79:
5411  case 0x7A:
5412  case 0x7B:
5413  case 0x7C:
5414  case 0x7D:
5415  case 0x7E:
5416  case 0x7F:
5417  return static_cast<number_unsigned_t>(current);
5418 
5419  // fixmap
5420  case 0x80:
5421  case 0x81:
5422  case 0x82:
5423  case 0x83:
5424  case 0x84:
5425  case 0x85:
5426  case 0x86:
5427  case 0x87:
5428  case 0x88:
5429  case 0x89:
5430  case 0x8A:
5431  case 0x8B:
5432  case 0x8C:
5433  case 0x8D:
5434  case 0x8E:
5435  case 0x8F:
5436  {
5437  return get_msgpack_object(current & 0x0F);
5438  }
5439 
5440  // fixarray
5441  case 0x90:
5442  case 0x91:
5443  case 0x92:
5444  case 0x93:
5445  case 0x94:
5446  case 0x95:
5447  case 0x96:
5448  case 0x97:
5449  case 0x98:
5450  case 0x99:
5451  case 0x9A:
5452  case 0x9B:
5453  case 0x9C:
5454  case 0x9D:
5455  case 0x9E:
5456  case 0x9F:
5457  {
5458  return get_msgpack_array(current & 0x0F);
5459  }
5460 
5461  // fixstr
5462  case 0xA0:
5463  case 0xA1:
5464  case 0xA2:
5465  case 0xA3:
5466  case 0xA4:
5467  case 0xA5:
5468  case 0xA6:
5469  case 0xA7:
5470  case 0xA8:
5471  case 0xA9:
5472  case 0xAA:
5473  case 0xAB:
5474  case 0xAC:
5475  case 0xAD:
5476  case 0xAE:
5477  case 0xAF:
5478  case 0xB0:
5479  case 0xB1:
5480  case 0xB2:
5481  case 0xB3:
5482  case 0xB4:
5483  case 0xB5:
5484  case 0xB6:
5485  case 0xB7:
5486  case 0xB8:
5487  case 0xB9:
5488  case 0xBA:
5489  case 0xBB:
5490  case 0xBC:
5491  case 0xBD:
5492  case 0xBE:
5493  case 0xBF:
5494  return get_msgpack_string();
5495 
5496  case 0xC0: // nil
5497  return value_t::null;
5498 
5499  case 0xC2: // false
5500  return false;
5501 
5502  case 0xC3: // true
5503  return true;
5504 
5505  case 0xCA: // float 32
5506  return get_number<float>();
5507 
5508  case 0xCB: // float 64
5509  return get_number<double>();
5510 
5511  case 0xCC: // uint 8
5512  return get_number<uint8_t>();
5513 
5514  case 0xCD: // uint 16
5515  return get_number<uint16_t>();
5516 
5517  case 0xCE: // uint 32
5518  return get_number<uint32_t>();
5519 
5520  case 0xCF: // uint 64
5521  return get_number<uint64_t>();
5522 
5523  case 0xD0: // int 8
5524  return get_number<int8_t>();
5525 
5526  case 0xD1: // int 16
5527  return get_number<int16_t>();
5528 
5529  case 0xD2: // int 32
5530  return get_number<int32_t>();
5531 
5532  case 0xD3: // int 64
5533  return get_number<int64_t>();
5534 
5535  case 0xD9: // str 8
5536  case 0xDA: // str 16
5537  case 0xDB: // str 32
5538  return get_msgpack_string();
5539 
5540  case 0xDC: // array 16
5541  {
5542  return get_msgpack_array(get_number<uint16_t>());
5543  }
5544 
5545  case 0xDD: // array 32
5546  {
5547  return get_msgpack_array(get_number<uint32_t>());
5548  }
5549 
5550  case 0xDE: // map 16
5551  {
5552  return get_msgpack_object(get_number<uint16_t>());
5553  }
5554 
5555  case 0xDF: // map 32
5556  {
5557  return get_msgpack_object(get_number<uint32_t>());
5558  }
5559 
5560  // positive fixint
5561  case 0xE0:
5562  case 0xE1:
5563  case 0xE2:
5564  case 0xE3:
5565  case 0xE4:
5566  case 0xE5:
5567  case 0xE6:
5568  case 0xE7:
5569  case 0xE8:
5570  case 0xE9:
5571  case 0xEA:
5572  case 0xEB:
5573  case 0xEC:
5574  case 0xED:
5575  case 0xEE:
5576  case 0xEF:
5577  case 0xF0:
5578  case 0xF1:
5579  case 0xF2:
5580  case 0xF3:
5581  case 0xF4:
5582  case 0xF5:
5583  case 0xF6:
5584  case 0xF7:
5585  case 0xF8:
5586  case 0xF9:
5587  case 0xFA:
5588  case 0xFB:
5589  case 0xFC:
5590  case 0xFD:
5591  case 0xFE:
5592  case 0xFF:
5593  return static_cast<int8_t>(current);
5594 
5595  default: // anything else
5596  {
5597  std::stringstream ss;
5598  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
5599  JSON_THROW(parse_error::create(112, chars_read,
5600  "error reading MessagePack; last byte: 0x" + ss.str()));
5601  }
5602  }
5603  }
5604 
5605  /*!
5606  @param[in] get_char whether a new character should be retrieved from the
5607  input (true, default) or whether the last read
5608  character should be considered instead
5609  */
5610  BasicJsonType parse_ubjson_internal(const bool get_char = true)
5611  {
5612  return get_ubjson_value(get_char ? get_ignore_noop() : current);
5613  }
5614 
5615  /*!
5616  @brief get next character from the input
5617 
5618  This function provides the interface to the used input adapter. It does
5619  not throw in case the input reached EOF, but returns a -'ve valued
5620  `std::char_traits<char>::eof()` in that case.
5621 
5622  @return character read from the input
5623  */
5624  int get()
5625  {
5626  ++chars_read;
5627  return (current = ia->get_character());
5628  }
5629 
5630  /*!
5631  @return character read from the input after ignoring all 'N' entries
5632  */
5633  int get_ignore_noop()
5634  {
5635  do
5636  {
5637  get();
5638  }
5639  while (current == 'N');
5640 
5641  return current;
5642  }
5643 
5644  /*
5645  @brief read a number from the input
5646 
5647  @tparam NumberType the type of the number
5648 
5649  @return number of type @a NumberType
5650 
5651  @note This function needs to respect the system's endianess, because
5652  bytes in CBOR and MessagePack are stored in network order (big
5653  endian) and therefore need reordering on little endian systems.
5654 
5655  @throw parse_error.110 if input has less than `sizeof(NumberType)` bytes
5656  */
5657  template<typename NumberType> NumberType get_number()
5658  {
5659  // step 1: read input into array with system's byte order
5660  std::array<uint8_t, sizeof(NumberType)> vec;
5661  for (std::size_t i = 0; i < sizeof(NumberType); ++i)
5662  {
5663  get();
5664  unexpect_eof();
5665 
5666  // reverse byte order prior to conversion if necessary
5667  if (is_little_endian)
5668  {
5669  vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
5670  }
5671  else
5672  {
5673  vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE
5674  }
5675  }
5676 
5677  // step 2: convert array into number of type T and return
5678  NumberType result;
5679  std::memcpy(&result, vec.data(), sizeof(NumberType));
5680  return result;
5681  }
5682 
5683  /*!
5684  @brief create a string by reading characters from the input
5685 
5686  @param[in] len number of bytes to read
5687 
5688  @note We can not reserve @a len bytes for the result, because @a len
5689  may be too large. Usually, @ref unexpect_eof() detects the end of
5690  the input before we run out of string memory.
5691 
5692  @return string created by reading @a len bytes
5693 
5694  @throw parse_error.110 if input has less than @a len bytes
5695  */
5696  template<typename NumberType>
5697  string_t get_string(const NumberType len)
5698  {
5699  string_t result;
5700  std::generate_n(std::back_inserter(result), len, [this]()
5701  {
5702  get();
5703  unexpect_eof();
5704  return static_cast<char>(current);
5705  });
5706  return result;
5707  }
5708 
5709  /*!
5710  @brief reads a CBOR string
5711 
5712  This function first reads starting bytes to determine the expected
5713  string length and then copies this number of bytes into a string.
5714  Additionally, CBOR's strings with indefinite lengths are supported.
5715 
5716  @return string
5717 
5718  @throw parse_error.110 if input ended
5719  @throw parse_error.113 if an unexpected byte is read
5720  */
5721  string_t get_cbor_string()
5722  {
5723  unexpect_eof();
5724 
5725  switch (current)
5726  {
5727  // UTF-8 string (0x00..0x17 bytes follow)
5728  case 0x60:
5729  case 0x61:
5730  case 0x62:
5731  case 0x63:
5732  case 0x64:
5733  case 0x65:
5734  case 0x66:
5735  case 0x67:
5736  case 0x68:
5737  case 0x69:
5738  case 0x6A:
5739  case 0x6B:
5740  case 0x6C:
5741  case 0x6D:
5742  case 0x6E:
5743  case 0x6F:
5744  case 0x70:
5745  case 0x71:
5746  case 0x72:
5747  case 0x73:
5748  case 0x74:
5749  case 0x75:
5750  case 0x76:
5751  case 0x77:
5752  {
5753  return get_string(current & 0x1F);
5754  }
5755 
5756  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
5757  {
5758  return get_string(get_number<uint8_t>());
5759  }
5760 
5761  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
5762  {
5763  return get_string(get_number<uint16_t>());
5764  }
5765 
5766  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
5767  {
5768  return get_string(get_number<uint32_t>());
5769  }
5770 
5771  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
5772  {
5773  return get_string(get_number<uint64_t>());
5774  }
5775 
5776  case 0x7F: // UTF-8 string (indefinite length)
5777  {
5778  string_t result;
5779  while (get() != 0xFF)
5780  {
5781  result.append(get_cbor_string());
5782  }
5783  return result;
5784  }
5785 
5786  default:
5787  {
5788  std::stringstream ss;
5789  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
5790  JSON_THROW(parse_error::create(113, chars_read, "expected a CBOR string; last byte: 0x" + ss.str()));
5791  }
5792  }
5793  }
5794 
5795  template<typename NumberType>
5796  BasicJsonType get_cbor_array(const NumberType len)
5797  {
5798  BasicJsonType result = value_t::array;
5799  std::generate_n(std::back_inserter(*result.m_value.array), len, [this]()
5800  {
5801  return parse_cbor_internal();
5802  });
5803  return result;
5804  }
5805 
5806  template<typename NumberType>
5807  BasicJsonType get_cbor_object(const NumberType len)
5808  {
5809  BasicJsonType result = value_t::object;
5810  std::generate_n(std::inserter(*result.m_value.object,
5811  result.m_value.object->end()),
5812  len, [this]()
5813  {
5814  get();
5815  auto key = get_cbor_string();
5816  auto val = parse_cbor_internal();
5817  return std::make_pair(std::move(key), std::move(val));
5818  });
5819  return result;
5820  }
5821 
5822  /*!
5823  @brief reads a MessagePack string
5824 
5825  This function first reads starting bytes to determine the expected
5826  string length and then copies this number of bytes into a string.
5827 
5828  @return string
5829 
5830  @throw parse_error.110 if input ended
5831  @throw parse_error.113 if an unexpected byte is read
5832  */
5833  string_t get_msgpack_string()
5834  {
5835  unexpect_eof();
5836 
5837  switch (current)
5838  {
5839  // fixstr
5840  case 0xA0:
5841  case 0xA1:
5842  case 0xA2:
5843  case 0xA3:
5844  case 0xA4:
5845  case 0xA5:
5846  case 0xA6:
5847  case 0xA7:
5848  case 0xA8:
5849  case 0xA9:
5850  case 0xAA:
5851  case 0xAB:
5852  case 0xAC:
5853  case 0xAD:
5854  case 0xAE:
5855  case 0xAF:
5856  case 0xB0:
5857  case 0xB1:
5858  case 0xB2:
5859  case 0xB3:
5860  case 0xB4:
5861  case 0xB5:
5862  case 0xB6:
5863  case 0xB7:
5864  case 0xB8:
5865  case 0xB9:
5866  case 0xBA:
5867  case 0xBB:
5868  case 0xBC:
5869  case 0xBD:
5870  case 0xBE:
5871  case 0xBF:
5872  {
5873  return get_string(current & 0x1F);
5874  }
5875 
5876  case 0xD9: // str 8
5877  {
5878  return get_string(get_number<uint8_t>());
5879  }
5880 
5881  case 0xDA: // str 16
5882  {
5883  return get_string(get_number<uint16_t>());
5884  }
5885 
5886  case 0xDB: // str 32
5887  {
5888  return get_string(get_number<uint32_t>());
5889  }
5890 
5891  default:
5892  {
5893  std::stringstream ss;
5894  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
5895  JSON_THROW(parse_error::create(113, chars_read,
5896  "expected a MessagePack string; last byte: 0x" + ss.str()));
5897  }
5898  }
5899  }
5900 
5901  template<typename NumberType>
5902  BasicJsonType get_msgpack_array(const NumberType len)
5903  {
5904  BasicJsonType result = value_t::array;
5905  std::generate_n(std::back_inserter(*result.m_value.array), len, [this]()
5906  {
5907  return parse_msgpack_internal();
5908  });
5909  return result;
5910  }
5911 
5912  template<typename NumberType>
5913  BasicJsonType get_msgpack_object(const NumberType len)
5914  {
5915  BasicJsonType result = value_t::object;
5916  std::generate_n(std::inserter(*result.m_value.object,
5917  result.m_value.object->end()),
5918  len, [this]()
5919  {
5920  get();
5921  auto key = get_msgpack_string();
5922  auto val = parse_msgpack_internal();
5923  return std::make_pair(std::move(key), std::move(val));
5924  });
5925  return result;
5926  }
5927 
5928  /*!
5929  @brief reads a UBJSON string
5930 
5931  This function is either called after reading the 'S' byte explicitly
5932  indicating a string, or in case of an object key where the 'S' byte can be
5933  left out.
5934 
5935  @param[in] get_char whether a new character should be retrieved from the
5936  input (true, default) or whether the last read
5937  character should be considered instead
5938 
5939  @return string
5940 
5941  @throw parse_error.110 if input ended
5942  @throw parse_error.113 if an unexpected byte is read
5943  */
5944  string_t get_ubjson_string(const bool get_char = true)
5945  {
5946  if (get_char)
5947  {
5948  get(); // TODO: may we ignore N here?
5949  }
5950 
5951  unexpect_eof();
5952 
5953  switch (current)
5954  {
5955  case 'U':
5956  return get_string(get_number<uint8_t>());
5957  case 'i':
5958  return get_string(get_number<int8_t>());
5959  case 'I':
5960  return get_string(get_number<int16_t>());
5961  case 'l':
5962  return get_string(get_number<int32_t>());
5963  case 'L':
5964  return get_string(get_number<int64_t>());
5965  default:
5966  std::stringstream ss;
5967  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
5968  JSON_THROW(parse_error::create(113, chars_read,
5969  "expected a UBJSON string; last byte: 0x" + ss.str()));
5970  }
5971  }
5972 
5973  /*!
5974  @brief determine the type and size for a container
5975 
5976  In the optimized UBJSON format, a type and a size can be provided to allow
5977  for a more compact representation.
5978 
5979  @return pair of the size and the type
5980  */
5981  std::pair<std::size_t, int> get_ubjson_size_type()
5982  {
5983  std::size_t sz = string_t::npos;
5984  int tc = 0;
5985 
5986  get_ignore_noop();
5987 
5988  if (current == '$')
5989  {
5990  tc = get(); // must not ignore 'N', because 'N' maybe the type
5991  unexpect_eof();
5992 
5993  get_ignore_noop();
5994  if (current != '#')
5995  {
5996  std::stringstream ss;
5997  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
5998  JSON_THROW(parse_error::create(112, chars_read,
5999  "expected '#' after UBJSON type information; last byte: 0x" + ss.str()));
6000  }
6001  sz = parse_ubjson_internal();
6002  }
6003  else if (current == '#')
6004  {
6005  sz = parse_ubjson_internal();
6006  }
6007 
6008  return std::make_pair(sz, tc);
6009  }
6010 
6011  BasicJsonType get_ubjson_value(const int prefix)
6012  {
6013  switch (prefix)
6014  {
6015  case std::char_traits<char>::eof(): // EOF
6016  JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
6017 
6018  case 'T': // true
6019  return true;
6020  case 'F': // false
6021  return false;
6022 
6023  case 'Z': // null
6024  return nullptr;
6025 
6026  case 'U':
6027  return get_number<uint8_t>();
6028  case 'i':
6029  return get_number<int8_t>();
6030  case 'I':
6031  return get_number<int16_t>();
6032  case 'l':
6033  return get_number<int32_t>();
6034  case 'L':
6035  return get_number<int64_t>();
6036  case 'd':
6037  return get_number<float>();
6038  case 'D':
6039  return get_number<double>();
6040 
6041  case 'C': // char
6042  {
6043  get();
6044  unexpect_eof();
6045  if (JSON_UNLIKELY(current > 127))
6046  {
6047  std::stringstream ss;
6048  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
6049  JSON_THROW(parse_error::create(113, chars_read,
6050  "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + ss.str()));
6051  }
6052  return string_t(1, static_cast<char>(current));
6053  }
6054 
6055  case 'S': // string
6056  return get_ubjson_string();
6057 
6058  case '[': // array
6059  return get_ubjson_array();
6060 
6061  case '{': // object
6062  return get_ubjson_object();
6063 
6064  default: // anything else
6065  std::stringstream ss;
6066  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
6067  JSON_THROW(parse_error::create(112, chars_read,
6068  "error reading UBJSON; last byte: 0x" + ss.str()));
6069  }
6070  }
6071 
6072  BasicJsonType get_ubjson_array()
6073  {
6074  BasicJsonType result = value_t::array;
6075  const auto size_and_type = get_ubjson_size_type();
6076 
6077  if (size_and_type.first != string_t::npos)
6078  {
6079  if (JSON_UNLIKELY(size_and_type.first > result.max_size()))
6080  {
6081  JSON_THROW(out_of_range::create(408,
6082  "excessive array size: " + std::to_string(size_and_type.first)));
6083  }
6084 
6085  if (size_and_type.second != 0)
6086  {
6087  if (size_and_type.second != 'N')
6088  {
6089  std::generate_n(std::back_inserter(*result.m_value.array),
6090  size_and_type.first, [this, size_and_type]()
6091  {
6092  return get_ubjson_value(size_and_type.second);
6093  });
6094  }
6095  }
6096  else
6097  {
6098  std::generate_n(std::back_inserter(*result.m_value.array),
6099  size_and_type.first, [this]()
6100  {
6101  return parse_ubjson_internal();
6102  });
6103  }
6104  }
6105  else
6106  {
6107  while (current != ']')
6108  {
6109  result.push_back(parse_ubjson_internal(false));
6110  get_ignore_noop();
6111  }
6112  }
6113 
6114  return result;
6115  }
6116 
6117  BasicJsonType get_ubjson_object()
6118  {
6119  BasicJsonType result = value_t::object;
6120  const auto size_and_type = get_ubjson_size_type();
6121 
6122  if (size_and_type.first != string_t::npos)
6123  {
6124  if (JSON_UNLIKELY(size_and_type.first > result.max_size()))
6125  {
6126  JSON_THROW(out_of_range::create(408,
6127  "excessive object size: " + std::to_string(size_and_type.first)));
6128  }
6129 
6130  if (size_and_type.second != 0)
6131  {
6132  std::generate_n(std::inserter(*result.m_value.object,
6133  result.m_value.object->end()),
6134  size_and_type.first, [this, size_and_type]()
6135  {
6136  auto key = get_ubjson_string();
6137  auto val = get_ubjson_value(size_and_type.second);
6138  return std::make_pair(std::move(key), std::move(val));
6139  });
6140  }
6141  else
6142  {
6143  std::generate_n(std::inserter(*result.m_value.object,
6144  result.m_value.object->end()),
6145  size_and_type.first, [this]()
6146  {
6147  auto key = get_ubjson_string();
6148  auto val = parse_ubjson_internal();
6149  return std::make_pair(std::move(key), std::move(val));
6150  });
6151  }
6152  }
6153  else
6154  {
6155  while (current != '}')
6156  {
6157  auto key = get_ubjson_string(false);
6158  result[std::move(key)] = parse_ubjson_internal();
6159  get_ignore_noop();
6160  }
6161  }
6162 
6163  return result;
6164  }
6165 
6166  /*!
6167  @brief throw if end of input is not reached
6168  @throw parse_error.110 if input not ended
6169  */
6170  void expect_eof() const
6171  {
6172  if (JSON_UNLIKELY(current != std::char_traits<char>::eof()))
6173  {
6174  JSON_THROW(parse_error::create(110, chars_read, "expected end of input"));
6175  }
6176  }
6177 
6178  /*!
6179  @briefthrow if end of input is reached
6180  @throw parse_error.110 if input ended
6181  */
6182  void unexpect_eof() const
6183  {
6184  if (JSON_UNLIKELY(current == std::char_traits<char>::eof()))
6185  {
6186  JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
6187  }
6188  }
6189 
6190  private:
6191  /// input adapter
6192  input_adapter_t ia = nullptr;
6193 
6194  /// the current character
6195  int current = std::char_traits<char>::eof();
6196 
6197  /// the number of characters read
6198  std::size_t chars_read = 0;
6199 
6200  /// whether we can assume little endianess
6201  const bool is_little_endian = little_endianess();
6202 };
6203 }
6204 }
6205 
6206 // #include <nlohmann/detail/output/binary_writer.hpp>
6207 
6208 
6209 #include <algorithm> // reverse
6210 #include <array> // array
6211 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
6212 #include <cstring> // memcpy
6213 #include <limits> // numeric_limits
6214 
6215 // #include <nlohmann/detail/input/binary_reader.hpp>
6216 
6217 // #include <nlohmann/detail/output/output_adapters.hpp>
6218 
6219 
6220 namespace nlohmann
6221 {
6222 namespace detail
6223 {
6224 ///////////////////
6225 // binary writer //
6226 ///////////////////
6227 
6228 /*!
6229 @brief serialization to CBOR and MessagePack values
6230 */
6231 template<typename BasicJsonType, typename CharType>
6232 class binary_writer
6233 {
6234  public:
6235  /*!
6236  @brief create a binary writer
6237 
6238  @param[in] adapter output adapter to write to
6239  */
6240  explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
6241  {
6242  assert(oa);
6243  }
6244 
6245  /*!
6246  @brief[in] j JSON value to serialize
6247  */
6248  void write_cbor(const BasicJsonType& j)
6249  {
6250  switch (j.type())
6251  {
6252  case value_t::null:
6253  {
6254  oa->write_character(static_cast<CharType>(0xF6));
6255  break;
6256  }
6257 
6258  case value_t::boolean:
6259  {
6260  oa->write_character(j.m_value.boolean
6261  ? static_cast<CharType>(0xF5)
6262  : static_cast<CharType>(0xF4));
6263  break;
6264  }
6265 
6266  case value_t::number_integer:
6267  {
6268  if (j.m_value.number_integer >= 0)
6269  {
6270  // CBOR does not differentiate between positive signed
6271  // integers and unsigned integers. Therefore, we used the
6272  // code from the value_t::number_unsigned case here.
6273  if (j.m_value.number_integer <= 0x17)
6274  {
6275  write_number(static_cast<uint8_t>(j.m_value.number_integer));
6276  }
6277  else if (j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
6278  {
6279  oa->write_character(static_cast<CharType>(0x18));
6280  write_number(static_cast<uint8_t>(j.m_value.number_integer));
6281  }
6282  else if (j.m_value.number_integer <= (std::numeric_limits<uint16_t>::max)())
6283  {
6284  oa->write_character(static_cast<CharType>(0x19));
6285  write_number(static_cast<uint16_t>(j.m_value.number_integer));
6286  }
6287  else if (j.m_value.number_integer <= (std::numeric_limits<uint32_t>::max)())
6288  {
6289  oa->write_character(static_cast<CharType>(0x1A));
6290  write_number(static_cast<uint32_t>(j.m_value.number_integer));
6291  }
6292  else
6293  {
6294  oa->write_character(static_cast<CharType>(0x1B));
6295  write_number(static_cast<uint64_t>(j.m_value.number_integer));
6296  }
6297  }
6298  else
6299  {
6300  // The conversions below encode the sign in the first
6301  // byte, and the value is converted to a positive number.
6302  const auto positive_number = -1 - j.m_value.number_integer;
6303  if (j.m_value.number_integer >= -24)
6304  {
6305  write_number(static_cast<uint8_t>(0x20 + positive_number));
6306  }
6307  else if (positive_number <= (std::numeric_limits<uint8_t>::max)())
6308  {
6309  oa->write_character(static_cast<CharType>(0x38));
6310  write_number(static_cast<uint8_t>(positive_number));
6311  }
6312  else if (positive_number <= (std::numeric_limits<uint16_t>::max)())
6313  {
6314  oa->write_character(static_cast<CharType>(0x39));
6315  write_number(static_cast<uint16_t>(positive_number));
6316  }
6317  else if (positive_number <= (std::numeric_limits<uint32_t>::max)())
6318  {
6319  oa->write_character(static_cast<CharType>(0x3A));
6320  write_number(static_cast<uint32_t>(positive_number));
6321  }
6322  else
6323  {
6324  oa->write_character(static_cast<CharType>(0x3B));
6325  write_number(static_cast<uint64_t>(positive_number));
6326  }
6327  }
6328  break;
6329  }
6330 
6331  case value_t::number_unsigned:
6332  {
6333  if (j.m_value.number_unsigned <= 0x17)
6334  {
6335  write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
6336  }
6337  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
6338  {
6339  oa->write_character(static_cast<CharType>(0x18));
6340  write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
6341  }
6342  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
6343  {
6344  oa->write_character(static_cast<CharType>(0x19));
6345  write_number(static_cast<uint16_t>(j.m_value.number_unsigned));
6346  }
6347  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
6348  {
6349  oa->write_character(static_cast<CharType>(0x1A));
6350  write_number(static_cast<uint32_t>(j.m_value.number_unsigned));
6351  }
6352  else
6353  {
6354  oa->write_character(static_cast<CharType>(0x1B));
6355  write_number(static_cast<uint64_t>(j.m_value.number_unsigned));
6356  }
6357  break;
6358  }
6359 
6360  case value_t::number_float: // Double-Precision Float
6361  {
6362  oa->write_character(static_cast<CharType>(0xFB));
6363  write_number(j.m_value.number_float);
6364  break;
6365  }
6366 
6367  case value_t::string:
6368  {
6369  // step 1: write control byte and the string length
6370  const auto N = j.m_value.string->size();
6371  if (N <= 0x17)
6372  {
6373  write_number(static_cast<uint8_t>(0x60 + N));
6374  }
6375  else if (N <= (std::numeric_limits<uint8_t>::max)())
6376  {
6377  oa->write_character(static_cast<CharType>(0x78));
6378  write_number(static_cast<uint8_t>(N));
6379  }
6380  else if (N <= (std::numeric_limits<uint16_t>::max)())
6381  {
6382  oa->write_character(static_cast<CharType>(0x79));
6383  write_number(static_cast<uint16_t>(N));
6384  }
6385  else if (N <= (std::numeric_limits<uint32_t>::max)())
6386  {
6387  oa->write_character(static_cast<CharType>(0x7A));
6388  write_number(static_cast<uint32_t>(N));
6389  }
6390  // LCOV_EXCL_START
6391  else if (N <= (std::numeric_limits<uint64_t>::max)())
6392  {
6393  oa->write_character(static_cast<CharType>(0x7B));
6394  write_number(static_cast<uint64_t>(N));
6395  }
6396  // LCOV_EXCL_STOP
6397 
6398  // step 2: write the string
6399  oa->write_characters(
6400  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
6401  j.m_value.string->size());
6402  break;
6403  }
6404 
6405  case value_t::array:
6406  {
6407  // step 1: write control byte and the array size
6408  const auto N = j.m_value.array->size();
6409  if (N <= 0x17)
6410  {
6411  write_number(static_cast<uint8_t>(0x80 + N));
6412  }
6413  else if (N <= (std::numeric_limits<uint8_t>::max)())
6414  {
6415  oa->write_character(static_cast<CharType>(0x98));
6416  write_number(static_cast<uint8_t>(N));
6417  }
6418  else if (N <= (std::numeric_limits<uint16_t>::max)())
6419  {
6420  oa->write_character(static_cast<CharType>(0x99));
6421  write_number(static_cast<uint16_t>(N));
6422  }
6423  else if (N <= (std::numeric_limits<uint32_t>::max)())
6424  {
6425  oa->write_character(static_cast<CharType>(0x9A));
6426  write_number(static_cast<uint32_t>(N));
6427  }
6428  // LCOV_EXCL_START
6429  else if (N <= (std::numeric_limits<uint64_t>::max)())
6430  {
6431  oa->write_character(static_cast<CharType>(0x9B));
6432  write_number(static_cast<uint64_t>(N));
6433  }
6434  // LCOV_EXCL_STOP
6435 
6436  // step 2: write each element
6437  for (const auto& el : *j.m_value.array)
6438  {
6439  write_cbor(el);
6440  }
6441  break;
6442  }
6443 
6444  case value_t::object:
6445  {
6446  // step 1: write control byte and the object size
6447  const auto N = j.m_value.object->size();
6448  if (N <= 0x17)
6449  {
6450  write_number(static_cast<uint8_t>(0xA0 + N));
6451  }
6452  else if (N <= (std::numeric_limits<uint8_t>::max)())
6453  {
6454  oa->write_character(static_cast<CharType>(0xB8));
6455  write_number(static_cast<uint8_t>(N));
6456  }
6457  else if (N <= (std::numeric_limits<uint16_t>::max)())
6458  {
6459  oa->write_character(static_cast<CharType>(0xB9));
6460  write_number(static_cast<uint16_t>(N));
6461  }
6462  else if (N <= (std::numeric_limits<uint32_t>::max)())
6463  {
6464  oa->write_character(static_cast<CharType>(0xBA));
6465  write_number(static_cast<uint32_t>(N));
6466  }
6467  // LCOV_EXCL_START
6468  else if (N <= (std::numeric_limits<uint64_t>::max)())
6469  {
6470  oa->write_character(static_cast<CharType>(0xBB));
6471  write_number(static_cast<uint64_t>(N));
6472  }
6473  // LCOV_EXCL_STOP
6474 
6475  // step 2: write each element
6476  for (const auto& el : *j.m_value.object)
6477  {
6478  write_cbor(el.first);
6479  write_cbor(el.second);
6480  }
6481  break;
6482  }
6483 
6484  default:
6485  break;
6486  }
6487  }
6488 
6489  /*!
6490  @brief[in] j JSON value to serialize
6491  */
6492  void write_msgpack(const BasicJsonType& j)
6493  {
6494  switch (j.type())
6495  {
6496  case value_t::null: // nil
6497  {
6498  oa->write_character(static_cast<CharType>(0xC0));
6499  break;
6500  }
6501 
6502  case value_t::boolean: // true and false
6503  {
6504  oa->write_character(j.m_value.boolean
6505  ? static_cast<CharType>(0xC3)
6506  : static_cast<CharType>(0xC2));
6507  break;
6508  }
6509 
6510  case value_t::number_integer:
6511  {
6512  if (j.m_value.number_integer >= 0)
6513  {
6514  // MessagePack does not differentiate between positive
6515  // signed integers and unsigned integers. Therefore, we used
6516  // the code from the value_t::number_unsigned case here.
6517  if (j.m_value.number_unsigned < 128)
6518  {
6519  // positive fixnum
6520  write_number(static_cast<uint8_t>(j.m_value.number_integer));
6521  }
6522  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
6523  {
6524  // uint 8
6525  oa->write_character(static_cast<CharType>(0xCC));
6526  write_number(static_cast<uint8_t>(j.m_value.number_integer));
6527  }
6528  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
6529  {
6530  // uint 16
6531  oa->write_character(static_cast<CharType>(0xCD));
6532  write_number(static_cast<uint16_t>(j.m_value.number_integer));
6533  }
6534  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
6535  {
6536  // uint 32
6537  oa->write_character(static_cast<CharType>(0xCE));
6538  write_number(static_cast<uint32_t>(j.m_value.number_integer));
6539  }
6540  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
6541  {
6542  // uint 64
6543  oa->write_character(static_cast<CharType>(0xCF));
6544  write_number(static_cast<uint64_t>(j.m_value.number_integer));
6545  }
6546  }
6547  else
6548  {
6549  if (j.m_value.number_integer >= -32)
6550  {
6551  // negative fixnum
6552  write_number(static_cast<int8_t>(j.m_value.number_integer));
6553  }
6554  else if (j.m_value.number_integer >= (std::numeric_limits<int8_t>::min)() and
6555  j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
6556  {
6557  // int 8
6558  oa->write_character(static_cast<CharType>(0xD0));
6559  write_number(static_cast<int8_t>(j.m_value.number_integer));
6560  }
6561  else if (j.m_value.number_integer >= (std::numeric_limits<int16_t>::min)() and
6562  j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
6563  {
6564  // int 16
6565  oa->write_character(static_cast<CharType>(0xD1));
6566  write_number(static_cast<int16_t>(j.m_value.number_integer));
6567  }
6568  else if (j.m_value.number_integer >= (std::numeric_limits<int32_t>::min)() and
6569  j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
6570  {
6571  // int 32
6572  oa->write_character(static_cast<CharType>(0xD2));
6573  write_number(static_cast<int32_t>(j.m_value.number_integer));
6574  }
6575  else if (j.m_value.number_integer >= (std::numeric_limits<int64_t>::min)() and
6576  j.m_value.number_integer <= (std::numeric_limits<int64_t>::max)())
6577  {
6578  // int 64
6579  oa->write_character(static_cast<CharType>(0xD3));
6580  write_number(static_cast<int64_t>(j.m_value.number_integer));
6581  }
6582  }
6583  break;
6584  }
6585 
6586  case value_t::number_unsigned:
6587  {
6588  if (j.m_value.number_unsigned < 128)
6589  {
6590  // positive fixnum
6591  write_number(static_cast<uint8_t>(j.m_value.number_integer));
6592  }
6593  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
6594  {
6595  // uint 8
6596  oa->write_character(static_cast<CharType>(0xCC));
6597  write_number(static_cast<uint8_t>(j.m_value.number_integer));
6598  }
6599  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
6600  {
6601  // uint 16
6602  oa->write_character(static_cast<CharType>(0xCD));
6603  write_number(static_cast<uint16_t>(j.m_value.number_integer));
6604  }
6605  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
6606  {
6607  // uint 32
6608  oa->write_character(static_cast<CharType>(0xCE));
6609  write_number(static_cast<uint32_t>(j.m_value.number_integer));
6610  }
6611  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
6612  {
6613  // uint 64
6614  oa->write_character(static_cast<CharType>(0xCF));
6615  write_number(static_cast<uint64_t>(j.m_value.number_integer));
6616  }
6617  break;
6618  }
6619 
6620  case value_t::number_float: // float 64
6621  {
6622  oa->write_character(static_cast<CharType>(0xCB));
6623  write_number(j.m_value.number_float);
6624  break;
6625  }
6626 
6627  case value_t::string:
6628  {
6629  // step 1: write control byte and the string length
6630  const auto N = j.m_value.string->size();
6631  if (N <= 31)
6632  {
6633  // fixstr
6634  write_number(static_cast<uint8_t>(0xA0 | N));
6635  }
6636  else if (N <= (std::numeric_limits<uint8_t>::max)())
6637  {
6638  // str 8
6639  oa->write_character(static_cast<CharType>(0xD9));
6640  write_number(static_cast<uint8_t>(N));
6641  }
6642  else if (N <= (std::numeric_limits<uint16_t>::max)())
6643  {
6644  // str 16
6645  oa->write_character(static_cast<CharType>(0xDA));
6646  write_number(static_cast<uint16_t>(N));
6647  }
6648  else if (N <= (std::numeric_limits<uint32_t>::max)())
6649  {
6650  // str 32
6651  oa->write_character(static_cast<CharType>(0xDB));
6652  write_number(static_cast<uint32_t>(N));
6653  }
6654 
6655  // step 2: write the string
6656  oa->write_characters(
6657  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
6658  j.m_value.string->size());
6659  break;
6660  }
6661 
6662  case value_t::array:
6663  {
6664  // step 1: write control byte and the array size
6665  const auto N = j.m_value.array->size();
6666  if (N <= 15)
6667  {
6668  // fixarray
6669  write_number(static_cast<uint8_t>(0x90 | N));
6670  }
6671  else if (N <= (std::numeric_limits<uint16_t>::max)())
6672  {
6673  // array 16
6674  oa->write_character(static_cast<CharType>(0xDC));
6675  write_number(static_cast<uint16_t>(N));
6676  }
6677  else if (N <= (std::numeric_limits<uint32_t>::max)())
6678  {
6679  // array 32
6680  oa->write_character(static_cast<CharType>(0xDD));
6681  write_number(static_cast<uint32_t>(N));
6682  }
6683 
6684  // step 2: write each element
6685  for (const auto& el : *j.m_value.array)
6686  {
6687  write_msgpack(el);
6688  }
6689  break;
6690  }
6691 
6692  case value_t::object:
6693  {
6694  // step 1: write control byte and the object size
6695  const auto N = j.m_value.object->size();
6696  if (N <= 15)
6697  {
6698  // fixmap
6699  write_number(static_cast<uint8_t>(0x80 | (N & 0xF)));
6700  }
6701  else if (N <= (std::numeric_limits<uint16_t>::max)())
6702  {
6703  // map 16
6704  oa->write_character(static_cast<CharType>(0xDE));
6705  write_number(static_cast<uint16_t>(N));
6706  }
6707  else if (N <= (std::numeric_limits<uint32_t>::max)())
6708  {
6709  // map 32
6710  oa->write_character(static_cast<CharType>(0xDF));
6711  write_number(static_cast<uint32_t>(N));
6712  }
6713 
6714  // step 2: write each element
6715  for (const auto& el : *j.m_value.object)
6716  {
6717  write_msgpack(el.first);
6718  write_msgpack(el.second);
6719  }
6720  break;
6721  }
6722 
6723  default:
6724  break;
6725  }
6726  }
6727 
6728  /*!
6729  @param[in] j JSON value to serialize
6730  @param[in] use_count whether to use '#' prefixes (optimized format)
6731  @param[in] use_type whether to use '$' prefixes (optimized format)
6732  @param[in] add_prefix whether prefixes need to be used for this value
6733  */
6734  void write_ubjson(const BasicJsonType& j, const bool use_count,
6735  const bool use_type, const bool add_prefix = true)
6736  {
6737  switch (j.type())
6738  {
6739  case value_t::null:
6740  {
6741  if (add_prefix)
6742  {
6743  oa->write_character(static_cast<CharType>('Z'));
6744  }
6745  break;
6746  }
6747 
6748  case value_t::boolean:
6749  {
6750  if (add_prefix)
6751  oa->write_character(j.m_value.boolean
6752  ? static_cast<CharType>('T')
6753  : static_cast<CharType>('F'));
6754  break;
6755  }
6756 
6757  case value_t::number_integer:
6758  {
6759  write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
6760  break;
6761  }
6762 
6763  case value_t::number_unsigned:
6764  {
6765  write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
6766  break;
6767  }
6768 
6769  case value_t::number_float:
6770  {
6771  write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
6772  break;
6773  }
6774 
6775  case value_t::string:
6776  {
6777  if (add_prefix)
6778  {
6779  oa->write_character(static_cast<CharType>('S'));
6780  }
6781  write_number_with_ubjson_prefix(j.m_value.string->size(), true);
6782  oa->write_characters(
6783  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
6784  j.m_value.string->size());
6785  break;
6786  }
6787 
6788  case value_t::array:
6789  {
6790  if (add_prefix)
6791  {
6792  oa->write_character(static_cast<CharType>('['));
6793  }
6794 
6795  bool prefix_required = true;
6796  if (use_type and not j.m_value.array->empty())
6797  {
6798  assert(use_count);
6799  const char first_prefix = ubjson_prefix(j.front());
6800  const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
6801  [this, first_prefix](const BasicJsonType & v)
6802  {
6803  return ubjson_prefix(v) == first_prefix;
6804  });
6805 
6806  if (same_prefix)
6807  {
6808  prefix_required = false;
6809  oa->write_character(static_cast<CharType>('$'));
6810  oa->write_character(static_cast<CharType>(first_prefix));
6811  }
6812  }
6813 
6814  if (use_count)
6815  {
6816  oa->write_character(static_cast<CharType>('#'));
6817  write_number_with_ubjson_prefix(j.m_value.array->size(), true);
6818  }
6819 
6820  for (const auto& el : *j.m_value.array)
6821  {
6822  write_ubjson(el, use_count, use_type, prefix_required);
6823  }
6824 
6825  if (not use_count)
6826  {
6827  oa->write_character(static_cast<CharType>(']'));
6828  }
6829 
6830  break;
6831  }
6832 
6833  case value_t::object:
6834  {
6835  if (add_prefix)
6836  {
6837  oa->write_character(static_cast<CharType>('{'));
6838  }
6839 
6840  bool prefix_required = true;
6841  if (use_type and not j.m_value.object->empty())
6842  {
6843  assert(use_count);
6844  const char first_prefix = ubjson_prefix(j.front());
6845  const bool same_prefix = std::all_of(j.begin(), j.end(),
6846  [this, first_prefix](const BasicJsonType & v)
6847  {
6848  return ubjson_prefix(v) == first_prefix;
6849  });
6850 
6851  if (same_prefix)
6852  {
6853  prefix_required = false;
6854  oa->write_character(static_cast<CharType>('$'));
6855  oa->write_character(static_cast<CharType>(first_prefix));
6856  }
6857  }
6858 
6859  if (use_count)
6860  {
6861  oa->write_character(static_cast<CharType>('#'));
6862  write_number_with_ubjson_prefix(j.m_value.object->size(), true);
6863  }
6864 
6865  for (const auto& el : *j.m_value.object)
6866  {
6867  write_number_with_ubjson_prefix(el.first.size(), true);
6868  oa->write_characters(
6869  reinterpret_cast<const CharType*>(el.first.c_str()),
6870  el.first.size());
6871  write_ubjson(el.second, use_count, use_type, prefix_required);
6872  }
6873 
6874  if (not use_count)
6875  {
6876  oa->write_character(static_cast<CharType>('}'));
6877  }
6878 
6879  break;
6880  }
6881 
6882  default:
6883  break;
6884  }
6885  }
6886 
6887  private:
6888  /*
6889  @brief write a number to output input
6890 
6891  @param[in] n number of type @a NumberType
6892  @tparam NumberType the type of the number
6893 
6894  @note This function needs to respect the system's endianess, because bytes
6895  in CBOR, MessagePack, and UBJSON are stored in network order (big
6896  endian) and therefore need reordering on little endian systems.
6897  */
6898  template<typename NumberType>
6899  void write_number(const NumberType n)
6900  {
6901  // step 1: write number to array of length NumberType
6902  std::array<CharType, sizeof(NumberType)> vec;
6903  std::memcpy(vec.data(), &n, sizeof(NumberType));
6904 
6905  // step 2: write array to output (with possible reordering)
6906  if (is_little_endian)
6907  {
6908  // reverse byte order prior to conversion if necessary
6909  std::reverse(vec.begin(), vec.end());
6910  }
6911 
6912  oa->write_characters(vec.data(), sizeof(NumberType));
6913  }
6914 
6915  // UBJSON: write number (floating point)
6916  template<typename NumberType, typename std::enable_if<
6917  std::is_floating_point<NumberType>::value, int>::type = 0>
6918  void write_number_with_ubjson_prefix(const NumberType n,
6919  const bool add_prefix)
6920  {
6921  if (add_prefix)
6922  {
6923  oa->write_character(static_cast<CharType>('D')); // float64
6924  }
6925  write_number(n);
6926  }
6927 
6928  // UBJSON: write number (unsigned integer)
6929  template<typename NumberType, typename std::enable_if<
6930  std::is_unsigned<NumberType>::value, int>::type = 0>
6931  void write_number_with_ubjson_prefix(const NumberType n,
6932  const bool add_prefix)
6933  {
6934  if (n <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))
6935  {
6936  if (add_prefix)
6937  {
6938  oa->write_character(static_cast<CharType>('i')); // int8
6939  }
6940  write_number(static_cast<uint8_t>(n));
6941  }
6942  else if (n <= (std::numeric_limits<uint8_t>::max)())
6943  {
6944  if (add_prefix)
6945  {
6946  oa->write_character(static_cast<CharType>('U')); // uint8
6947  }
6948  write_number(static_cast<uint8_t>(n));
6949  }
6950  else if (n <= static_cast<uint64_t>((std::numeric_limits<int16_t>::max)()))
6951  {
6952  if (add_prefix)
6953  {
6954  oa->write_character(static_cast<CharType>('I')); // int16
6955  }
6956  write_number(static_cast<int16_t>(n));
6957  }
6958  else if (n <= static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))
6959  {
6960  if (add_prefix)
6961  {
6962  oa->write_character(static_cast<CharType>('l')); // int32
6963  }
6964  write_number(static_cast<int32_t>(n));
6965  }
6966  else if (n <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
6967  {
6968  if (add_prefix)
6969  {
6970  oa->write_character(static_cast<CharType>('L')); // int64
6971  }
6972  write_number(static_cast<int64_t>(n));
6973  }
6974  else
6975  {
6976  JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n)));
6977  }
6978  }
6979 
6980  // UBJSON: write number (signed integer)
6981  template<typename NumberType, typename std::enable_if<
6982  std::is_signed<NumberType>::value and
6983  not std::is_floating_point<NumberType>::value, int>::type = 0>
6984  void write_number_with_ubjson_prefix(const NumberType n,
6985  const bool add_prefix)
6986  {
6987  if ((std::numeric_limits<int8_t>::min)() <= n and n <= (std::numeric_limits<int8_t>::max)())
6988  {
6989  if (add_prefix)
6990  {
6991  oa->write_character(static_cast<CharType>('i')); // int8
6992  }
6993  write_number(static_cast<int8_t>(n));
6994  }
6995  else if (static_cast<int64_t>((std::numeric_limits<uint8_t>::min)()) <= n and n <= static_cast<int64_t>((std::numeric_limits<uint8_t>::max)()))
6996  {
6997  if (add_prefix)
6998  {
6999  oa->write_character(static_cast<CharType>('U')); // uint8
7000  }
7001  write_number(static_cast<uint8_t>(n));
7002  }
7003  else if ((std::numeric_limits<int16_t>::min)() <= n and n <= (std::numeric_limits<int16_t>::max)())
7004  {
7005  if (add_prefix)
7006  {
7007  oa->write_character(static_cast<CharType>('I')); // int16
7008  }
7009  write_number(static_cast<int16_t>(n));
7010  }
7011  else if ((std::numeric_limits<int32_t>::min)() <= n and n <= (std::numeric_limits<int32_t>::max)())
7012  {
7013  if (add_prefix)
7014  {
7015  oa->write_character(static_cast<CharType>('l')); // int32
7016  }
7017  write_number(static_cast<int32_t>(n));
7018  }
7019  else if ((std::numeric_limits<int64_t>::min)() <= n and n <= (std::numeric_limits<int64_t>::max)())
7020  {
7021  if (add_prefix)
7022  {
7023  oa->write_character(static_cast<CharType>('L')); // int64
7024  }
7025  write_number(static_cast<int64_t>(n));
7026  }
7027  // LCOV_EXCL_START
7028  else
7029  {
7030  JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n)));
7031  }
7032  // LCOV_EXCL_STOP
7033  }
7034 
7035  /*!
7036  @brief determine the type prefix of container values
7037 
7038  @note This function does not need to be 100% accurate when it comes to
7039  integer limits. In case a number exceeds the limits of int64_t,
7040  this will be detected by a later call to function
7041  write_number_with_ubjson_prefix. Therefore, we return 'L' for any
7042  value that does not fit the previous limits.
7043  */
7044  char ubjson_prefix(const BasicJsonType& j) const noexcept
7045  {
7046  switch (j.type())
7047  {
7048  case value_t::null:
7049  return 'Z';
7050 
7051  case value_t::boolean:
7052  return j.m_value.boolean ? 'T' : 'F';
7053 
7054  case value_t::number_integer:
7055  {
7056  if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
7057  {
7058  return 'i';
7059  }
7060  else if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
7061  {
7062  return 'U';
7063  }
7064  else if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
7065  {
7066  return 'I';
7067  }
7068  else if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
7069  {
7070  return 'l';
7071  }
7072  else // no check and assume int64_t (see note above)
7073  {
7074  return 'L';
7075  }
7076  }
7077 
7078  case value_t::number_unsigned:
7079  {
7080  if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())
7081  {
7082  return 'i';
7083  }
7084  else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
7085  {
7086  return 'U';
7087  }
7088  else if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())
7089  {
7090  return 'I';
7091  }
7092  else if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())
7093  {
7094  return 'l';
7095  }
7096  else // no check and assume int64_t (see note above)
7097  {
7098  return 'L';
7099  }
7100  }
7101 
7102  case value_t::number_float:
7103  return 'D';
7104 
7105  case value_t::string:
7106  return 'S';
7107 
7108  case value_t::array:
7109  return '[';
7110 
7111  case value_t::object:
7112  return '{';
7113 
7114  default: // discarded values
7115  return 'N';
7116  }
7117  }
7118 
7119  private:
7120  /// whether we can assume little endianess
7121  const bool is_little_endian = binary_reader<BasicJsonType>::little_endianess();
7122 
7123  /// the output
7124  output_adapter_t<CharType> oa = nullptr;
7125 };
7126 }
7127 }
7128 
7129 // #include <nlohmann/detail/output/serializer.hpp>
7130 
7131 
7132 #include <algorithm> // reverse, remove, fill, find, none_of
7133 #include <array> // array
7134 #include <cassert> // assert
7135 #include <ciso646> // and, or
7136 #include <clocale> // localeconv, lconv
7137 #include <cmath> // labs, isfinite, isnan, signbit
7138 #include <cstddef> // size_t, ptrdiff_t
7139 #include <cstdint> // uint8_t
7140 #include <cstdio> // snprintf
7141 #include <iomanip> // setfill
7142 #include <iterator> // next
7143 #include <limits> // numeric_limits
7144 #include <string> // string
7145 #include <sstream> // stringstream
7146 #include <type_traits> // is_same
7147 
7148 // #include <nlohmann/detail/exceptions.hpp>
7149 
7150 // #include <nlohmann/detail/conversions/to_chars.hpp>
7151 
7152 
7153 #include <cassert> // assert
7154 #include <ciso646> // or, and, not
7155 #include <cmath> // signbit, isfinite
7156 #include <cstdint> // intN_t, uintN_t
7157 #include <cstring> // memcpy, memmove
7158 
7159 namespace nlohmann
7160 {
7161 namespace detail
7162 {
7163 
7164 /*!
7165 @brief implements the Grisu2 algorithm for binary to decimal floating-point
7166 conversion.
7167 
7168 This implementation is a slightly modified version of the reference
7169 implementation which may be obtained from
7170 http://florian.loitsch.com/publications (bench.tar.gz).
7171 
7172 The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
7173 
7174 For a detailed description of the algorithm see:
7175 
7176 [1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
7177  Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
7178  Language Design and Implementation, PLDI 2010
7179 [2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
7180  Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
7181  Design and Implementation, PLDI 1996
7182 */
7183 namespace dtoa_impl
7184 {
7185 
7186 template <typename Target, typename Source>
7187 Target reinterpret_bits(const Source source)
7188 {
7189  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
7190 
7191  Target target;
7192  std::memcpy(&target, &source, sizeof(Source));
7193  return target;
7194 }
7195 
7196 struct diyfp // f * 2^e
7197 {
7198  static constexpr int kPrecision = 64; // = q
7199 
7200  uint64_t f;
7201  int e;
7202 
7203  constexpr diyfp() noexcept : f(0), e(0) {}
7204  constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
7205 
7206  /*!
7207  @brief returns x - y
7208  @pre x.e == y.e and x.f >= y.f
7209  */
7210  static diyfp sub(const diyfp& x, const diyfp& y) noexcept
7211  {
7212  assert(x.e == y.e);
7213  assert(x.f >= y.f);
7214 
7215  return diyfp(x.f - y.f, x.e);
7216  }
7217 
7218  /*!
7219  @brief returns x * y
7220  @note The result is rounded. (Only the upper q bits are returned.)
7221  */
7222  static diyfp mul(const diyfp& x, const diyfp& y) noexcept
7223  {
7224  static_assert(kPrecision == 64, "internal error");
7225 
7226  // Computes:
7227  // f = round((x.f * y.f) / 2^q)
7228  // e = x.e + y.e + q
7229 
7230  // Emulate the 64-bit * 64-bit multiplication:
7231  //
7232  // p = u * v
7233  // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
7234  // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
7235  // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
7236  // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
7237  // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
7238  // = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
7239  // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
7240  //
7241  // (Since Q might be larger than 2^32 - 1)
7242  //
7243  // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
7244  //
7245  // (Q_hi + H does not overflow a 64-bit int)
7246  //
7247  // = p_lo + 2^64 p_hi
7248 
7249  const uint64_t u_lo = x.f & 0xFFFFFFFF;
7250  const uint64_t u_hi = x.f >> 32;
7251  const uint64_t v_lo = y.f & 0xFFFFFFFF;
7252  const uint64_t v_hi = y.f >> 32;
7253 
7254  const uint64_t p0 = u_lo * v_lo;
7255  const uint64_t p1 = u_lo * v_hi;
7256  const uint64_t p2 = u_hi * v_lo;
7257  const uint64_t p3 = u_hi * v_hi;
7258 
7259  const uint64_t p0_hi = p0 >> 32;
7260  const uint64_t p1_lo = p1 & 0xFFFFFFFF;
7261  const uint64_t p1_hi = p1 >> 32;
7262  const uint64_t p2_lo = p2 & 0xFFFFFFFF;
7263  const uint64_t p2_hi = p2 >> 32;
7264 
7265  uint64_t Q = p0_hi + p1_lo + p2_lo;
7266 
7267  // The full product might now be computed as
7268  //
7269  // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
7270  // p_lo = p0_lo + (Q << 32)
7271  //
7272  // But in this particular case here, the full p_lo is not required.
7273  // Effectively we only need to add the highest bit in p_lo to p_hi (and
7274  // Q_hi + 1 does not overflow).
7275 
7276  Q += uint64_t{1} << (64 - 32 - 1); // round, ties up
7277 
7278  const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);
7279 
7280  return diyfp(h, x.e + y.e + 64);
7281  }
7282 
7283  /*!
7284  @brief normalize x such that the significand is >= 2^(q-1)
7285  @pre x.f != 0
7286  */
7287  static diyfp normalize(diyfp x) noexcept
7288  {
7289  assert(x.f != 0);
7290 
7291  while ((x.f >> 63) == 0)
7292  {
7293  x.f <<= 1;
7294  x.e--;
7295  }
7296 
7297  return x;
7298  }
7299 
7300  /*!
7301  @brief normalize x such that the result has the exponent E
7302  @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
7303  */
7304  static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
7305  {
7306  const int delta = x.e - target_exponent;
7307 
7308  assert(delta >= 0);
7309  assert(((x.f << delta) >> delta) == x.f);
7310 
7311  return diyfp(x.f << delta, target_exponent);
7312  }
7313 };
7314 
7315 struct boundaries
7316 {
7317  diyfp w;
7318  diyfp minus;
7319  diyfp plus;
7320 };
7321 
7322 /*!
7323 Compute the (normalized) diyfp representing the input number 'value' and its
7324 boundaries.
7325 
7326 @pre value must be finite and positive
7327 */
7328 template <typename FloatType>
7329 boundaries compute_boundaries(FloatType value)
7330 {
7331  assert(std::isfinite(value));
7332  assert(value > 0);
7333 
7334  // Convert the IEEE representation into a diyfp.
7335  //
7336  // If v is denormal:
7337  // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
7338  // If v is normalized:
7339  // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
7340 
7341  static_assert(std::numeric_limits<FloatType>::is_iec559,
7342  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
7343 
7344  constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
7345  constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
7346  constexpr int kMinExp = 1 - kBias;
7347  constexpr uint64_t kHiddenBit = uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
7348 
7349  using bits_type = typename std::conditional< kPrecision == 24, uint32_t, uint64_t >::type;
7350 
7351  const uint64_t bits = reinterpret_bits<bits_type>(value);
7352  const uint64_t E = bits >> (kPrecision - 1);
7353  const uint64_t F = bits & (kHiddenBit - 1);
7354 
7355  const bool is_denormal = (E == 0);
7356  const diyfp v = is_denormal
7357  ? diyfp(F, kMinExp)
7358  : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
7359 
7360  // Compute the boundaries m- and m+ of the floating-point value
7361  // v = f * 2^e.
7362  //
7363  // Determine v- and v+, the floating-point predecessor and successor if v,
7364  // respectively.
7365  //
7366  // v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
7367  // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
7368  //
7369  // v+ = v + 2^e
7370  //
7371  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
7372  // between m- and m+ round to v, regardless of how the input rounding
7373  // algorithm breaks ties.
7374  //
7375  // ---+-------------+-------------+-------------+-------------+--- (A)
7376  // v- m- v m+ v+
7377  //
7378  // -----------------+------+------+-------------+-------------+--- (B)
7379  // v- m- v m+ v+
7380 
7381  const bool lower_boundary_is_closer = (F == 0 and E > 1);
7382  const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
7383  const diyfp m_minus = lower_boundary_is_closer
7384  ? diyfp(4 * v.f - 1, v.e - 2) // (B)
7385  : diyfp(2 * v.f - 1, v.e - 1); // (A)
7386 
7387  // Determine the normalized w+ = m+.
7388  const diyfp w_plus = diyfp::normalize(m_plus);
7389 
7390  // Determine w- = m- such that e_(w-) = e_(w+).
7391  const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
7392 
7393  return {diyfp::normalize(v), w_minus, w_plus};
7394 }
7395 
7396 // Given normalized diyfp w, Grisu needs to find a (normalized) cached
7397 // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
7398 // within a certain range [alpha, gamma] (Definition 3.2 from [1])
7399 //
7400 // alpha <= e = e_c + e_w + q <= gamma
7401 //
7402 // or
7403 //
7404 // f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
7405 // <= f_c * f_w * 2^gamma
7406 //
7407 // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
7408 //
7409 // 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
7410 //
7411 // or
7412 //
7413 // 2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
7414 //
7415 // The choice of (alpha,gamma) determines the size of the table and the form of
7416 // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
7417 // in practice:
7418 //
7419 // The idea is to cut the number c * w = f * 2^e into two parts, which can be
7420 // processed independently: An integral part p1, and a fractional part p2:
7421 //
7422 // f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
7423 // = (f div 2^-e) + (f mod 2^-e) * 2^e
7424 // = p1 + p2 * 2^e
7425 //
7426 // The conversion of p1 into decimal form requires a series of divisions and
7427 // modulos by (a power of) 10. These operations are faster for 32-bit than for
7428 // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
7429 // achieved by choosing
7430 //
7431 // -e >= 32 or e <= -32 := gamma
7432 //
7433 // In order to convert the fractional part
7434 //
7435 // p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
7436 //
7437 // into decimal form, the fraction is repeatedly multiplied by 10 and the digits
7438 // d[-i] are extracted in order:
7439 //
7440 // (10 * p2) div 2^-e = d[-1]
7441 // (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
7442 //
7443 // The multiplication by 10 must not overflow. It is sufficient to choose
7444 //
7445 // 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
7446 //
7447 // Since p2 = f mod 2^-e < 2^-e,
7448 //
7449 // -e <= 60 or e >= -60 := alpha
7450 
7451 constexpr int kAlpha = -60;
7452 constexpr int kGamma = -32;
7453 
7454 struct cached_power // c = f * 2^e ~= 10^k
7455 {
7456  uint64_t f;
7457  int e;
7458  int k;
7459 };
7460 
7461 /*!
7462 For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
7463 power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
7464 satisfies (Definition 3.2 from [1])
7465 
7466  alpha <= e_c + e + q <= gamma.
7467 */
7468 inline cached_power get_cached_power_for_binary_exponent(int e)
7469 {
7470  // Now
7471  //
7472  // alpha <= e_c + e + q <= gamma (1)
7473  // ==> f_c * 2^alpha <= c * 2^e * 2^q
7474  //
7475  // and since the c's are normalized, 2^(q-1) <= f_c,
7476  //
7477  // ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
7478  // ==> 2^(alpha - e - 1) <= c
7479  //
7480  // If c were an exakt power of ten, i.e. c = 10^k, one may determine k as
7481  //
7482  // k = ceil( log_10( 2^(alpha - e - 1) ) )
7483  // = ceil( (alpha - e - 1) * log_10(2) )
7484  //
7485  // From the paper:
7486  // "In theory the result of the procedure could be wrong since c is rounded,
7487  // and the computation itself is approximated [...]. In practice, however,
7488  // this simple function is sufficient."
7489  //
7490  // For IEEE double precision floating-point numbers converted into
7491  // normalized diyfp's w = f * 2^e, with q = 64,
7492  //
7493  // e >= -1022 (min IEEE exponent)
7494  // -52 (p - 1)
7495  // -52 (p - 1, possibly normalize denormal IEEE numbers)
7496  // -11 (normalize the diyfp)
7497  // = -1137
7498  //
7499  // and
7500  //
7501  // e <= +1023 (max IEEE exponent)
7502  // -52 (p - 1)
7503  // -11 (normalize the diyfp)
7504  // = 960
7505  //
7506  // This binary exponent range [-1137,960] results in a decimal exponent
7507  // range [-307,324]. One does not need to store a cached power for each
7508  // k in this range. For each such k it suffices to find a cached power
7509  // such that the exponent of the product lies in [alpha,gamma].
7510  // This implies that the difference of the decimal exponents of adjacent
7511  // table entries must be less than or equal to
7512  //
7513  // floor( (gamma - alpha) * log_10(2) ) = 8.
7514  //
7515  // (A smaller distance gamma-alpha would require a larger table.)
7516 
7517  // NB:
7518  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
7519 
7520  constexpr int kCachedPowersSize = 79;
7521  constexpr int kCachedPowersMinDecExp = -300;
7522  constexpr int kCachedPowersDecStep = 8;
7523 
7524  static constexpr cached_power kCachedPowers[] =
7525  {
7526  { 0xAB70FE17C79AC6CA, -1060, -300 },
7527  { 0xFF77B1FCBEBCDC4F, -1034, -292 },
7528  { 0xBE5691EF416BD60C, -1007, -284 },
7529  { 0x8DD01FAD907FFC3C, -980, -276 },
7530  { 0xD3515C2831559A83, -954, -268 },
7531  { 0x9D71AC8FADA6C9B5, -927, -260 },
7532  { 0xEA9C227723EE8BCB, -901, -252 },
7533  { 0xAECC49914078536D, -874, -244 },
7534  { 0x823C12795DB6CE57, -847, -236 },
7535  { 0xC21094364DFB5637, -821, -228 },
7536  { 0x9096EA6F3848984F, -794, -220 },
7537  { 0xD77485CB25823AC7, -768, -212 },
7538  { 0xA086CFCD97BF97F4, -741, -204 },
7539  { 0xEF340A98172AACE5, -715, -196 },
7540  { 0xB23867FB2A35B28E, -688, -188 },
7541  { 0x84C8D4DFD2C63F3B, -661, -180 },
7542  { 0xC5DD44271AD3CDBA, -635, -172 },
7543  { 0x936B9FCEBB25C996, -608, -164 },
7544  { 0xDBAC6C247D62A584, -582, -156 },
7545  { 0xA3AB66580D5FDAF6, -555, -148 },
7546  { 0xF3E2F893DEC3F126, -529, -140 },
7547  { 0xB5B5ADA8AAFF80B8, -502, -132 },
7548  { 0x87625F056C7C4A8B, -475, -124 },
7549  { 0xC9BCFF6034C13053, -449, -116 },
7550  { 0x964E858C91BA2655, -422, -108 },
7551  { 0xDFF9772470297EBD, -396, -100 },
7552  { 0xA6DFBD9FB8E5B88F, -369, -92 },
7553  { 0xF8A95FCF88747D94, -343, -84 },
7554  { 0xB94470938FA89BCF, -316, -76 },
7555  { 0x8A08F0F8BF0F156B, -289, -68 },
7556  { 0xCDB02555653131B6, -263, -60 },
7557  { 0x993FE2C6D07B7FAC, -236, -52 },
7558  { 0xE45C10C42A2B3B06, -210, -44 },
7559  { 0xAA242499697392D3, -183, -36 },
7560  { 0xFD87B5F28300CA0E, -157, -28 },
7561  { 0xBCE5086492111AEB, -130, -20 },
7562  { 0x8CBCCC096F5088CC, -103, -12 },
7563  { 0xD1B71758E219652C, -77, -4 },
7564  { 0x9C40000000000000, -50, 4 },
7565  { 0xE8D4A51000000000, -24, 12 },
7566  { 0xAD78EBC5AC620000, 3, 20 },
7567  { 0x813F3978F8940984, 30, 28 },
7568  { 0xC097CE7BC90715B3, 56, 36 },
7569  { 0x8F7E32CE7BEA5C70, 83, 44 },
7570  { 0xD5D238A4ABE98068, 109, 52 },
7571  { 0x9F4F2726179A2245, 136, 60 },
7572  { 0xED63A231D4C4FB27, 162, 68 },
7573  { 0xB0DE65388CC8ADA8, 189, 76 },
7574  { 0x83C7088E1AAB65DB, 216, 84 },
7575  { 0xC45D1DF942711D9A, 242, 92 },
7576  { 0x924D692CA61BE758, 269, 100 },
7577  { 0xDA01EE641A708DEA, 295, 108 },
7578  { 0xA26DA3999AEF774A, 322, 116 },
7579  { 0xF209787BB47D6B85, 348, 124 },
7580  { 0xB454E4A179DD1877, 375, 132 },
7581  { 0x865B86925B9BC5C2, 402, 140 },
7582  { 0xC83553C5C8965D3D, 428, 148 },
7583  { 0x952AB45CFA97A0B3, 455, 156 },
7584  { 0xDE469FBD99A05FE3, 481, 164 },
7585  { 0xA59BC234DB398C25, 508, 172 },
7586  { 0xF6C69A72A3989F5C, 534, 180 },
7587  { 0xB7DCBF5354E9BECE, 561, 188 },
7588  { 0x88FCF317F22241E2, 588, 196 },
7589  { 0xCC20CE9BD35C78A5, 614, 204 },
7590  { 0x98165AF37B2153DF, 641, 212 },
7591  { 0xE2A0B5DC971F303A, 667, 220 },
7592  { 0xA8D9D1535CE3B396, 694, 228 },
7593  { 0xFB9B7CD9A4A7443C, 720, 236 },
7594  { 0xBB764C4CA7A44410, 747, 244 },
7595  { 0x8BAB8EEFB6409C1A, 774, 252 },
7596  { 0xD01FEF10A657842C, 800, 260 },
7597  { 0x9B10A4E5E9913129, 827, 268 },
7598  { 0xE7109BFBA19C0C9D, 853, 276 },
7599  { 0xAC2820D9623BF429, 880, 284 },
7600  { 0x80444B5E7AA7CF85, 907, 292 },
7601  { 0xBF21E44003ACDD2D, 933, 300 },
7602  { 0x8E679C2F5E44FF8F, 960, 308 },
7603  { 0xD433179D9C8CB841, 986, 316 },
7604  { 0x9E19DB92B4E31BA9, 1013, 324 },
7605  };
7606 
7607  // This computation gives exactly the same results for k as
7608  // k = ceil((kAlpha - e - 1) * 0.30102999566398114)
7609  // for |e| <= 1500, but doesn't require floating-point operations.
7610  // NB: log_10(2) ~= 78913 / 2^18
7611  assert(e >= -1500);
7612  assert(e <= 1500);
7613  const int f = kAlpha - e - 1;
7614  const int k = (f * 78913) / (1 << 18) + (f > 0);
7615 
7616  const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
7617  assert(index >= 0);
7618  assert(index < kCachedPowersSize);
7619  static_cast<void>(kCachedPowersSize); // Fix warning.
7620 
7621  const cached_power cached = kCachedPowers[index];
7622  assert(kAlpha <= cached.e + e + 64);
7623  assert(kGamma >= cached.e + e + 64);
7624 
7625  return cached;
7626 }
7627 
7628 /*!
7629 For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
7630 For n == 0, returns 1 and sets pow10 := 1.
7631 */
7632 inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
7633 {
7634  // LCOV_EXCL_START
7635  if (n >= 1000000000)
7636  {
7637  pow10 = 1000000000;
7638  return 10;
7639  }
7640  // LCOV_EXCL_STOP
7641  else if (n >= 100000000)
7642  {
7643  pow10 = 100000000;
7644  return 9;
7645  }
7646  else if (n >= 10000000)
7647  {
7648  pow10 = 10000000;
7649  return 8;
7650  }
7651  else if (n >= 1000000)
7652  {
7653  pow10 = 1000000;
7654  return 7;
7655  }
7656  else if (n >= 100000)
7657  {
7658  pow10 = 100000;
7659  return 6;
7660  }
7661  else if (n >= 10000)
7662  {
7663  pow10 = 10000;
7664  return 5;
7665  }
7666  else if (n >= 1000)
7667  {
7668  pow10 = 1000;
7669  return 4;
7670  }
7671  else if (n >= 100)
7672  {
7673  pow10 = 100;
7674  return 3;
7675  }
7676  else if (n >= 10)
7677  {
7678  pow10 = 10;
7679  return 2;
7680  }
7681  else
7682  {
7683  pow10 = 1;
7684  return 1;
7685  }
7686 }
7687 
7688 inline void grisu2_round(char* buf, int len, uint64_t dist, uint64_t delta,
7689  uint64_t rest, uint64_t ten_k)
7690 {
7691  assert(len >= 1);
7692  assert(dist <= delta);
7693  assert(rest <= delta);
7694  assert(ten_k > 0);
7695 
7696  // <--------------------------- delta ---->
7697  // <---- dist --------->
7698  // --------------[------------------+-------------------]--------------
7699  // M- w M+
7700  //
7701  // ten_k
7702  // <------>
7703  // <---- rest ---->
7704  // --------------[------------------+----+--------------]--------------
7705  // w V
7706  // = buf * 10^k
7707  //
7708  // ten_k represents a unit-in-the-last-place in the decimal representation
7709  // stored in buf.
7710  // Decrement buf by ten_k while this takes buf closer to w.
7711 
7712  // The tests are written in this order to avoid overflow in unsigned
7713  // integer arithmetic.
7714 
7715  while (rest < dist
7716  and delta - rest >= ten_k
7717  and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))
7718  {
7719  assert(buf[len - 1] != '0');
7720  buf[len - 1]--;
7721  rest += ten_k;
7722  }
7723 }
7724 
7725 /*!
7726 Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
7727 M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
7728 */
7729 inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
7730  diyfp M_minus, diyfp w, diyfp M_plus)
7731 {
7732  static_assert(kAlpha >= -60, "internal error");
7733  static_assert(kGamma <= -32, "internal error");
7734 
7735  // Generates the digits (and the exponent) of a decimal floating-point
7736  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
7737  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
7738  //
7739  // <--------------------------- delta ---->
7740  // <---- dist --------->
7741  // --------------[------------------+-------------------]--------------
7742  // M- w M+
7743  //
7744  // Grisu2 generates the digits of M+ from left to right and stops as soon as
7745  // V is in [M-,M+].
7746 
7747  assert(M_plus.e >= kAlpha);
7748  assert(M_plus.e <= kGamma);
7749 
7750  uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
7751  uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
7752 
7753  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
7754  //
7755  // M+ = f * 2^e
7756  // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
7757  // = ((p1 ) * 2^-e + (p2 )) * 2^e
7758  // = p1 + p2 * 2^e
7759 
7760  const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);
7761 
7762  uint32_t p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
7763  uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
7764 
7765  // 1)
7766  //
7767  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
7768 
7769  assert(p1 > 0);
7770 
7771  uint32_t pow10;
7772  const int k = find_largest_pow10(p1, pow10);
7773 
7774  // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
7775  //
7776  // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
7777  // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
7778  //
7779  // M+ = p1 + p2 * 2^e
7780  // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
7781  // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
7782  // = d[k-1] * 10^(k-1) + ( rest) * 2^e
7783  //
7784  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
7785  //
7786  // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
7787  //
7788  // but stop as soon as
7789  //
7790  // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
7791 
7792  int n = k;
7793  while (n > 0)
7794  {
7795  // Invariants:
7796  // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
7797  // pow10 = 10^(n-1) <= p1 < 10^n
7798  //
7799  const uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
7800  const uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
7801  //
7802  // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
7803  // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
7804  //
7805  assert(d <= 9);
7806  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
7807  //
7808  // M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
7809  //
7810  p1 = r;
7811  n--;
7812  //
7813  // M+ = buffer * 10^n + (p1 + p2 * 2^e)
7814  // pow10 = 10^n
7815  //
7816 
7817  // Now check if enough digits have been generated.
7818  // Compute
7819  //
7820  // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
7821  //
7822  // Note:
7823  // Since rest and delta share the same exponent e, it suffices to
7824  // compare the significands.
7825  const uint64_t rest = (uint64_t{p1} << -one.e) + p2;
7826  if (rest <= delta)
7827  {
7828  // V = buffer * 10^n, with M- <= V <= M+.
7829 
7830  decimal_exponent += n;
7831 
7832  // We may now just stop. But instead look if the buffer could be
7833  // decremented to bring V closer to w.
7834  //
7835  // pow10 = 10^n is now 1 ulp in the decimal representation V.
7836  // The rounding procedure works with diyfp's with an implicit
7837  // exponent of e.
7838  //
7839  // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
7840  //
7841  const uint64_t ten_n = uint64_t{pow10} << -one.e;
7842  grisu2_round(buffer, length, dist, delta, rest, ten_n);
7843 
7844  return;
7845  }
7846 
7847  pow10 /= 10;
7848  //
7849  // pow10 = 10^(n-1) <= p1 < 10^n
7850  // Invariants restored.
7851  }
7852 
7853  // 2)
7854  //
7855  // The digits of the integral part have been generated:
7856  //
7857  // M+ = d[k-1]...d[1]d[0] + p2 * 2^e
7858  // = buffer + p2 * 2^e
7859  //
7860  // Now generate the digits of the fractional part p2 * 2^e.
7861  //
7862  // Note:
7863  // No decimal point is generated: the exponent is adjusted instead.
7864  //
7865  // p2 actually represents the fraction
7866  //
7867  // p2 * 2^e
7868  // = p2 / 2^-e
7869  // = d[-1] / 10^1 + d[-2] / 10^2 + ...
7870  //
7871  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
7872  //
7873  // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
7874  // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
7875  //
7876  // using
7877  //
7878  // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
7879  // = ( d) * 2^-e + ( r)
7880  //
7881  // or
7882  // 10^m * p2 * 2^e = d + r * 2^e
7883  //
7884  // i.e.
7885  //
7886  // M+ = buffer + p2 * 2^e
7887  // = buffer + 10^-m * (d + r * 2^e)
7888  // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
7889  //
7890  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
7891 
7892  assert(p2 > delta);
7893 
7894  int m = 0;
7895  for (;;)
7896  {
7897  // Invariant:
7898  // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
7899  // = buffer * 10^-m + 10^-m * (p2 ) * 2^e
7900  // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
7901  // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
7902  //
7903  assert(p2 <= UINT64_MAX / 10);
7904  p2 *= 10;
7905  const uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
7906  const uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
7907  //
7908  // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
7909  // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
7910  // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
7911  //
7912  assert(d <= 9);
7913  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
7914  //
7915  // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
7916  //
7917  p2 = r;
7918  m++;
7919  //
7920  // M+ = buffer * 10^-m + 10^-m * p2 * 2^e
7921  // Invariant restored.
7922 
7923  // Check if enough digits have been generated.
7924  //
7925  // 10^-m * p2 * 2^e <= delta * 2^e
7926  // p2 * 2^e <= 10^m * delta * 2^e
7927  // p2 <= 10^m * delta
7928  delta *= 10;
7929  dist *= 10;
7930  if (p2 <= delta)
7931  {
7932  break;
7933  }
7934  }
7935 
7936  // V = buffer * 10^-m, with M- <= V <= M+.
7937 
7938  decimal_exponent -= m;
7939 
7940  // 1 ulp in the decimal representation is now 10^-m.
7941  // Since delta and dist are now scaled by 10^m, we need to do the
7942  // same with ulp in order to keep the units in sync.
7943  //
7944  // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
7945  //
7946  const uint64_t ten_m = one.f;
7947  grisu2_round(buffer, length, dist, delta, p2, ten_m);
7948 
7949  // By construction this algorithm generates the shortest possible decimal
7950  // number (Loitsch, Theorem 6.2) which rounds back to w.
7951  // For an input number of precision p, at least
7952  //
7953  // N = 1 + ceil(p * log_10(2))
7954  //
7955  // decimal digits are sufficient to identify all binary floating-point
7956  // numbers (Matula, "In-and-Out conversions").
7957  // This implies that the algorithm does not produce more than N decimal
7958  // digits.
7959  //
7960  // N = 17 for p = 53 (IEEE double precision)
7961  // N = 9 for p = 24 (IEEE single precision)
7962 }
7963 
7964 /*!
7965 v = buf * 10^decimal_exponent
7966 len is the length of the buffer (number of decimal digits)
7967 The buffer must be large enough, i.e. >= max_digits10.
7968 */
7969 inline void grisu2(char* buf, int& len, int& decimal_exponent,
7970  diyfp m_minus, diyfp v, diyfp m_plus)
7971 {
7972  assert(m_plus.e == m_minus.e);
7973  assert(m_plus.e == v.e);
7974 
7975  // --------(-----------------------+-----------------------)-------- (A)
7976  // m- v m+
7977  //
7978  // --------------------(-----------+-----------------------)-------- (B)
7979  // m- v m+
7980  //
7981  // First scale v (and m- and m+) such that the exponent is in the range
7982  // [alpha, gamma].
7983 
7984  const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
7985 
7986  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
7987 
7988  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
7989  const diyfp w = diyfp::mul(v, c_minus_k);
7990  const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
7991  const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
7992 
7993  // ----(---+---)---------------(---+---)---------------(---+---)----
7994  // w- w w+
7995  // = c*m- = c*v = c*m+
7996  //
7997  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
7998  // w+ are now off by a small amount.
7999  // In fact:
8000  //
8001  // w - v * 10^k < 1 ulp
8002  //
8003  // To account for this inaccuracy, add resp. subtract 1 ulp.
8004  //
8005  // --------+---[---------------(---+---)---------------]---+--------
8006  // w- M- w M+ w+
8007  //
8008  // Now any number in [M-, M+] (bounds included) will round to w when input,
8009  // regardless of how the input rounding algorithm breaks ties.
8010  //
8011  // And digit_gen generates the shortest possible such number in [M-, M+].
8012  // Note that this does not mean that Grisu2 always generates the shortest
8013  // possible number in the interval (m-, m+).
8014  const diyfp M_minus(w_minus.f + 1, w_minus.e);
8015  const diyfp M_plus (w_plus.f - 1, w_plus.e );
8016 
8017  decimal_exponent = -cached.k; // = -(-k) = k
8018 
8019  grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
8020 }
8021 
8022 /*!
8023 v = buf * 10^decimal_exponent
8024 len is the length of the buffer (number of decimal digits)
8025 The buffer must be large enough, i.e. >= max_digits10.
8026 */
8027 template <typename FloatType>
8028 void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
8029 {
8030  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
8031  "internal error: not enough precision");
8032 
8033  assert(std::isfinite(value));
8034  assert(value > 0);
8035 
8036  // If the neighbors (and boundaries) of 'value' are always computed for double-precision
8037  // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
8038  // decimal representations are not exactly "short".
8039  //
8040  // The documentation for 'std::to_chars' (http://en.cppreference.com/w/cpp/utility/to_chars)
8041  // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
8042  // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
8043  // does.
8044  // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
8045  // representation using the corresponding std::from_chars function recovers value exactly". That
8046  // indicates that single precision floating-point numbers should be recovered using
8047  // 'std::strtof'.
8048  //
8049  // NB: If the neighbors are computed for single-precision numbers, there is a single float
8050  // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
8051  // value is off by 1 ulp.
8052 #if 0
8053  const boundaries w = compute_boundaries(static_cast<double>(value));
8054 #else
8055  const boundaries w = compute_boundaries(value);
8056 #endif
8057 
8058  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
8059 }
8060 
8061 /*!
8062 @brief appends a decimal representation of e to buf
8063 @return a pointer to the element following the exponent.
8064 @pre -1000 < e < 1000
8065 */
8066 inline char* append_exponent(char* buf, int e)
8067 {
8068  assert(e > -1000);
8069  assert(e < 1000);
8070 
8071  if (e < 0)
8072  {
8073  e = -e;
8074  *buf++ = '-';
8075  }
8076  else
8077  {
8078  *buf++ = '+';
8079  }
8080 
8081  uint32_t k = static_cast<uint32_t>(e);
8082  if (k < 10)
8083  {
8084  // Always print at least two digits in the exponent.
8085  // This is for compatibility with printf("%g").
8086  *buf++ = '0';
8087  *buf++ = static_cast<char>('0' + k);
8088  }
8089  else if (k < 100)
8090  {
8091  *buf++ = static_cast<char>('0' + k / 10);
8092  k %= 10;
8093  *buf++ = static_cast<char>('0' + k);
8094  }
8095  else
8096  {
8097  *buf++ = static_cast<char>('0' + k / 100);
8098  k %= 100;
8099  *buf++ = static_cast<char>('0' + k / 10);
8100  k %= 10;
8101  *buf++ = static_cast<char>('0' + k);
8102  }
8103 
8104  return buf;
8105 }
8106 
8107 /*!
8108 @brief prettify v = buf * 10^decimal_exponent
8109 
8110 If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
8111 notation. Otherwise it will be printed in exponential notation.
8112 
8113 @pre min_exp < 0
8114 @pre max_exp > 0
8115 */
8116 inline char* format_buffer(char* buf, int len, int decimal_exponent,
8117  int min_exp, int max_exp)
8118 {
8119  assert(min_exp < 0);
8120  assert(max_exp > 0);
8121 
8122  const int k = len;
8123  const int n = len + decimal_exponent;
8124 
8125  // v = buf * 10^(n-k)
8126  // k is the length of the buffer (number of decimal digits)
8127  // n is the position of the decimal point relative to the start of the buffer.
8128 
8129  if (k <= n and n <= max_exp)
8130  {
8131  // digits[000]
8132  // len <= max_exp + 2
8133 
8134  std::memset(buf + k, '0', static_cast<size_t>(n - k));
8135  // Make it look like a floating-point number (#362, #378)
8136  buf[n + 0] = '.';
8137  buf[n + 1] = '0';
8138  return buf + (n + 2);
8139  }
8140 
8141  if (0 < n and n <= max_exp)
8142  {
8143  // dig.its
8144  // len <= max_digits10 + 1
8145 
8146  assert(k > n);
8147 
8148  std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
8149  buf[n] = '.';
8150  return buf + (k + 1);
8151  }
8152 
8153  if (min_exp < n and n <= 0)
8154  {
8155  // 0.[000]digits
8156  // len <= 2 + (-min_exp - 1) + max_digits10
8157 
8158  std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));
8159  buf[0] = '0';
8160  buf[1] = '.';
8161  std::memset(buf + 2, '0', static_cast<size_t>(-n));
8162  return buf + (2 + (-n) + k);
8163  }
8164 
8165  if (k == 1)
8166  {
8167  // dE+123
8168  // len <= 1 + 5
8169 
8170  buf += 1;
8171  }
8172  else
8173  {
8174  // d.igitsE+123
8175  // len <= max_digits10 + 1 + 5
8176 
8177  std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
8178  buf[1] = '.';
8179  buf += 1 + k;
8180  }
8181 
8182  *buf++ = 'e';
8183  return append_exponent(buf, n - 1);
8184 }
8185 
8186 } // namespace dtoa_impl
8187 
8188 /*!
8189 @brief generates a decimal representation of the floating-point number value in [first, last).
8190 
8191 The format of the resulting decimal representation is similar to printf's %g
8192 format. Returns an iterator pointing past-the-end of the decimal representation.
8193 
8194 @note The input number must be finite, i.e. NaN's and Inf's are not supported.
8195 @note The buffer must be large enough.
8196 @note The result is NOT null-terminated.
8197 */
8198 template <typename FloatType>
8199 char* to_chars(char* first, char* last, FloatType value)
8200 {
8201  static_cast<void>(last); // maybe unused - fix warning
8202  assert(std::isfinite(value));
8203 
8204  // Use signbit(value) instead of (value < 0) since signbit works for -0.
8205  if (std::signbit(value))
8206  {
8207  value = -value;
8208  *first++ = '-';
8209  }
8210 
8211  if (value == 0) // +-0
8212  {
8213  *first++ = '0';
8214  // Make it look like a floating-point number (#362, #378)
8215  *first++ = '.';
8216  *first++ = '0';
8217  return first;
8218  }
8219 
8220  assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
8221 
8222  // Compute v = buffer * 10^decimal_exponent.
8223  // The decimal digits are stored in the buffer, which needs to be interpreted
8224  // as an unsigned decimal integer.
8225  // len is the length of the buffer, i.e. the number of decimal digits.
8226  int len = 0;
8227  int decimal_exponent = 0;
8228  dtoa_impl::grisu2(first, len, decimal_exponent, value);
8229 
8230  assert(len <= std::numeric_limits<FloatType>::max_digits10);
8231 
8232  // Format the buffer like printf("%.*g", prec, value)
8233  constexpr int kMinExp = -4;
8234  // Use digits10 here to increase compatibility with version 2.
8235  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
8236 
8237  assert(last - first >= kMaxExp + 2);
8238  assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
8239  assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
8240 
8241  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
8242 }
8243 
8244 } // namespace detail
8245 } // namespace nlohmann
8246 
8247 // #include <nlohmann/detail/macro_scope.hpp>
8248 
8249 // #include <nlohmann/detail/meta.hpp>
8250 
8251 // #include <nlohmann/detail/output/output_adapters.hpp>
8252 
8253 // #include <nlohmann/detail/value_t.hpp>
8254 
8255 
8256 namespace nlohmann
8257 {
8258 namespace detail
8259 {
8260 ///////////////////
8261 // serialization //
8262 ///////////////////
8263 
8264 template<typename BasicJsonType>
8265 class serializer
8266 {
8267  using string_t = typename BasicJsonType::string_t;
8268  using number_float_t = typename BasicJsonType::number_float_t;
8269  using number_integer_t = typename BasicJsonType::number_integer_t;
8270  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8271  static constexpr uint8_t UTF8_ACCEPT = 0;
8272  static constexpr uint8_t UTF8_REJECT = 1;
8273 
8274  public:
8275  /*!
8276  @param[in] s output stream to serialize to
8277  @param[in] ichar indentation character to use
8278  */
8279  serializer(output_adapter_t<char> s, const char ichar)
8280  : o(std::move(s)), loc(std::localeconv()),
8281  thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep)),
8282  decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point)),
8283  indent_char(ichar), indent_string(512, indent_char)
8284  {}
8285 
8286  // delete because of pointer members
8287  serializer(const serializer&) = delete;
8288  serializer& operator=(const serializer&) = delete;
8289 
8290  /*!
8291  @brief internal implementation of the serialization function
8292 
8293  This function is called by the public member function dump and organizes
8294  the serialization internally. The indentation level is propagated as
8295  additional parameter. In case of arrays and objects, the function is
8296  called recursively.
8297 
8298  - strings and object keys are escaped using `escape_string()`
8299  - integer numbers are converted implicitly via `operator<<`
8300  - floating-point numbers are converted to a string using `"%g"` format
8301 
8302  @param[in] val value to serialize
8303  @param[in] pretty_print whether the output shall be pretty-printed
8304  @param[in] indent_step the indent level
8305  @param[in] current_indent the current indent level (only used internally)
8306  */
8307  void dump(const BasicJsonType& val, const bool pretty_print,
8308  const bool ensure_ascii,
8309  const unsigned int indent_step,
8310  const unsigned int current_indent = 0)
8311  {
8312  switch (val.m_type)
8313  {
8314  case value_t::object:
8315  {
8316  if (val.m_value.object->empty())
8317  {
8318  o->write_characters("{}", 2);
8319  return;
8320  }
8321 
8322  if (pretty_print)
8323  {
8324  o->write_characters("{\n", 2);
8325 
8326  // variable to hold indentation for recursive calls
8327  const auto new_indent = current_indent + indent_step;
8328  if (JSON_UNLIKELY(indent_string.size() < new_indent))
8329  {
8330  indent_string.resize(indent_string.size() * 2, ' ');
8331  }
8332 
8333  // first n-1 elements
8334  auto i = val.m_value.object->cbegin();
8335  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
8336  {
8337  o->write_characters(indent_string.c_str(), new_indent);
8338  o->write_character('\"');
8339  dump_escaped(i->first, ensure_ascii);
8340  o->write_characters("\": ", 3);
8341  dump(i->second, true, ensure_ascii, indent_step, new_indent);
8342  o->write_characters(",\n", 2);
8343  }
8344 
8345  // last element
8346  assert(i != val.m_value.object->cend());
8347  assert(std::next(i) == val.m_value.object->cend());
8348  o->write_characters(indent_string.c_str(), new_indent);
8349  o->write_character('\"');
8350  dump_escaped(i->first, ensure_ascii);
8351  o->write_characters("\": ", 3);
8352  dump(i->second, true, ensure_ascii, indent_step, new_indent);
8353 
8354  o->write_character('\n');
8355  o->write_characters(indent_string.c_str(), current_indent);
8356  o->write_character('}');
8357  }
8358  else
8359  {
8360  o->write_character('{');
8361 
8362  // first n-1 elements
8363  auto i = val.m_value.object->cbegin();
8364  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
8365  {
8366  o->write_character('\"');
8367  dump_escaped(i->first, ensure_ascii);
8368  o->write_characters("\":", 2);
8369  dump(i->second, false, ensure_ascii, indent_step, current_indent);
8370  o->write_character(',');
8371  }
8372 
8373  // last element
8374  assert(i != val.m_value.object->cend());
8375  assert(std::next(i) == val.m_value.object->cend());
8376  o->write_character('\"');
8377  dump_escaped(i->first, ensure_ascii);
8378  o->write_characters("\":", 2);
8379  dump(i->second, false, ensure_ascii, indent_step, current_indent);
8380 
8381  o->write_character('}');
8382  }
8383 
8384  return;
8385  }
8386 
8387  case value_t::array:
8388  {
8389  if (val.m_value.array->empty())
8390  {
8391  o->write_characters("[]", 2);
8392  return;
8393  }
8394 
8395  if (pretty_print)
8396  {
8397  o->write_characters("[\n", 2);
8398 
8399  // variable to hold indentation for recursive calls
8400  const auto new_indent = current_indent + indent_step;
8401  if (JSON_UNLIKELY(indent_string.size() < new_indent))
8402  {
8403  indent_string.resize(indent_string.size() * 2, ' ');
8404  }
8405 
8406  // first n-1 elements
8407  for (auto i = val.m_value.array->cbegin();
8408  i != val.m_value.array->cend() - 1; ++i)
8409  {
8410  o->write_characters(indent_string.c_str(), new_indent);
8411  dump(*i, true, ensure_ascii, indent_step, new_indent);
8412  o->write_characters(",\n", 2);
8413  }
8414 
8415  // last element
8416  assert(not val.m_value.array->empty());
8417  o->write_characters(indent_string.c_str(), new_indent);
8418  dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
8419 
8420  o->write_character('\n');
8421  o->write_characters(indent_string.c_str(), current_indent);
8422  o->write_character(']');
8423  }
8424  else
8425  {
8426  o->write_character('[');
8427 
8428  // first n-1 elements
8429  for (auto i = val.m_value.array->cbegin();
8430  i != val.m_value.array->cend() - 1; ++i)
8431  {
8432  dump(*i, false, ensure_ascii, indent_step, current_indent);
8433  o->write_character(',');
8434  }
8435 
8436  // last element
8437  assert(not val.m_value.array->empty());
8438  dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
8439 
8440  o->write_character(']');
8441  }
8442 
8443  return;
8444  }
8445 
8446  case value_t::string:
8447  {
8448  o->write_character('\"');
8449  dump_escaped(*val.m_value.string, ensure_ascii);
8450  o->write_character('\"');
8451  return;
8452  }
8453 
8454  case value_t::boolean:
8455  {
8456  if (val.m_value.boolean)
8457  {
8458  o->write_characters("true", 4);
8459  }
8460  else
8461  {
8462  o->write_characters("false", 5);
8463  }
8464  return;
8465  }
8466 
8467  case value_t::number_integer:
8468  {
8469  dump_integer(val.m_value.number_integer);
8470  return;
8471  }
8472 
8473  case value_t::number_unsigned:
8474  {
8475  dump_integer(val.m_value.number_unsigned);
8476  return;
8477  }
8478 
8479  case value_t::number_float:
8480  {
8481  dump_float(val.m_value.number_float);
8482  return;
8483  }
8484 
8485  case value_t::discarded:
8486  {
8487  o->write_characters("<discarded>", 11);
8488  return;
8489  }
8490 
8491  case value_t::null:
8492  {
8493  o->write_characters("null", 4);
8494  return;
8495  }
8496  }
8497  }
8498 
8499  private:
8500  /*!
8501  @brief dump escaped string
8502 
8503  Escape a string by replacing certain special characters by a sequence of an
8504  escape character (backslash) and another character and other control
8505  characters by a sequence of "\u" followed by a four-digit hex
8506  representation. The escaped string is written to output stream @a o.
8507 
8508  @param[in] s the string to escape
8509  @param[in] ensure_ascii whether to escape non-ASCII characters with
8510  \uXXXX sequences
8511 
8512  @complexity Linear in the length of string @a s.
8513  */
8514  void dump_escaped(const string_t& s, const bool ensure_ascii)
8515  {
8516  uint32_t codepoint;
8517  uint8_t state = UTF8_ACCEPT;
8518  std::size_t bytes = 0; // number of bytes written to string_buffer
8519 
8520  for (std::size_t i = 0; i < s.size(); ++i)
8521  {
8522  const auto byte = static_cast<uint8_t>(s[i]);
8523 
8524  switch (decode(state, codepoint, byte))
8525  {
8526  case UTF8_ACCEPT: // decode found a new code point
8527  {
8528  switch (codepoint)
8529  {
8530  case 0x08: // backspace
8531  {
8532  string_buffer[bytes++] = '\\';
8533  string_buffer[bytes++] = 'b';
8534  break;
8535  }
8536 
8537  case 0x09: // horizontal tab
8538  {
8539  string_buffer[bytes++] = '\\';
8540  string_buffer[bytes++] = 't';
8541  break;
8542  }
8543 
8544  case 0x0A: // newline
8545  {
8546  string_buffer[bytes++] = '\\';
8547  string_buffer[bytes++] = 'n';
8548  break;
8549  }
8550 
8551  case 0x0C: // formfeed
8552  {
8553  string_buffer[bytes++] = '\\';
8554  string_buffer[bytes++] = 'f';
8555  break;
8556  }
8557 
8558  case 0x0D: // carriage return
8559  {
8560  string_buffer[bytes++] = '\\';
8561  string_buffer[bytes++] = 'r';
8562  break;
8563  }
8564 
8565  case 0x22: // quotation mark
8566  {
8567  string_buffer[bytes++] = '\\';
8568  string_buffer[bytes++] = '\"';
8569  break;
8570  }
8571 
8572  case 0x5C: // reverse solidus
8573  {
8574  string_buffer[bytes++] = '\\';
8575  string_buffer[bytes++] = '\\';
8576  break;
8577  }
8578 
8579  default:
8580  {
8581  // escape control characters (0x00..0x1F) or, if
8582  // ensure_ascii parameter is used, non-ASCII characters
8583  if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
8584  {
8585  if (codepoint <= 0xFFFF)
8586  {
8587  std::snprintf(string_buffer.data() + bytes, 7, "\\u%04x",
8588  static_cast<uint16_t>(codepoint));
8589  bytes += 6;
8590  }
8591  else
8592  {
8593  std::snprintf(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
8594  static_cast<uint16_t>(0xD7C0 + (codepoint >> 10)),
8595  static_cast<uint16_t>(0xDC00 + (codepoint & 0x3FF)));
8596  bytes += 12;
8597  }
8598  }
8599  else
8600  {
8601  // copy byte to buffer (all previous bytes
8602  // been copied have in default case above)
8603  string_buffer[bytes++] = s[i];
8604  }
8605  break;
8606  }
8607  }
8608 
8609  // write buffer and reset index; there must be 13 bytes
8610  // left, as this is the maximal number of bytes to be
8611  // written ("\uxxxx\uxxxx\0") for one code point
8612  if (string_buffer.size() - bytes < 13)
8613  {
8614  o->write_characters(string_buffer.data(), bytes);
8615  bytes = 0;
8616  }
8617  break;
8618  }
8619 
8620  case UTF8_REJECT: // decode found invalid UTF-8 byte
8621  {
8622  std::stringstream ss;
8623  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << static_cast<int>(byte);
8624  JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str()));
8625  }
8626 
8627  default: // decode found yet incomplete multi-byte code point
8628  {
8629  if (not ensure_ascii)
8630  {
8631  // code point will not be escaped - copy byte to buffer
8632  string_buffer[bytes++] = s[i];
8633  }
8634  break;
8635  }
8636  }
8637  }
8638 
8639  if (JSON_LIKELY(state == UTF8_ACCEPT))
8640  {
8641  // write buffer
8642  if (bytes > 0)
8643  {
8644  o->write_characters(string_buffer.data(), bytes);
8645  }
8646  }
8647  else
8648  {
8649  // we finish reading, but do not accept: string was incomplete
8650  std::stringstream ss;
8651  ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << static_cast<int>(static_cast<uint8_t>(s.back()));
8652  JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str()));
8653  }
8654  }
8655 
8656  /*!
8657  @brief dump an integer
8658 
8659  Dump a given integer to output stream @a o. Works internally with
8660  @a number_buffer.
8661 
8662  @param[in] x integer number (signed or unsigned) to dump
8663  @tparam NumberType either @a number_integer_t or @a number_unsigned_t
8664  */
8665  template<typename NumberType, detail::enable_if_t<
8666  std::is_same<NumberType, number_unsigned_t>::value or
8667  std::is_same<NumberType, number_integer_t>::value,
8668  int> = 0>
8669  void dump_integer(NumberType x)
8670  {
8671  // special case for "0"
8672  if (x == 0)
8673  {
8674  o->write_character('0');
8675  return;
8676  }
8677 
8678  const bool is_negative = (x <= 0) and (x != 0); // see issue #755
8679  std::size_t i = 0;
8680 
8681  while (x != 0)
8682  {
8683  // spare 1 byte for '\0'
8684  assert(i < number_buffer.size() - 1);
8685 
8686  const auto digit = std::labs(static_cast<long>(x % 10));
8687  number_buffer[i++] = static_cast<char>('0' + digit);
8688  x /= 10;
8689  }
8690 
8691  if (is_negative)
8692  {
8693  // make sure there is capacity for the '-'
8694  assert(i < number_buffer.size() - 2);
8695  number_buffer[i++] = '-';
8696  }
8697 
8698  std::reverse(number_buffer.begin(), number_buffer.begin() + i);
8699  o->write_characters(number_buffer.data(), i);
8700  }
8701 
8702  /*!
8703  @brief dump a floating-point number
8704 
8705  Dump a given floating-point number to output stream @a o. Works internally
8706  with @a number_buffer.
8707 
8708  @param[in] x floating-point number to dump
8709  */
8710  void dump_float(number_float_t x)
8711  {
8712  // NaN / inf
8713  if (not std::isfinite(x))
8714  {
8715  o->write_characters("null", 4);
8716  return;
8717  }
8718 
8719  // If number_float_t is an IEEE-754 single or double precision number,
8720  // use the Grisu2 algorithm to produce short numbers which are
8721  // guaranteed to round-trip, using strtof and strtod, resp.
8722  //
8723  // NB: The test below works if <long double> == <double>.
8724  static constexpr bool is_ieee_single_or_double
8725  = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
8726  (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
8727 
8728  dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
8729  }
8730 
8731  void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
8732  {
8733  char* begin = number_buffer.data();
8734  char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
8735 
8736  o->write_characters(begin, static_cast<size_t>(end - begin));
8737  }
8738 
8739  void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
8740  {
8741  // get number of digits for a float -> text -> float round-trip
8742  static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
8743 
8744  // the actual conversion
8745  std::ptrdiff_t len = snprintf(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
8746 
8747  // negative value indicates an error
8748  assert(len > 0);
8749  // check if buffer was large enough
8750  assert(static_cast<std::size_t>(len) < number_buffer.size());
8751 
8752  // erase thousands separator
8753  if (thousands_sep != '\0')
8754  {
8755  const auto end = std::remove(number_buffer.begin(),
8756  number_buffer.begin() + len, thousands_sep);
8757  std::fill(end, number_buffer.end(), '\0');
8758  assert((end - number_buffer.begin()) <= len);
8759  len = (end - number_buffer.begin());
8760  }
8761 
8762  // convert decimal point to '.'
8763  if (decimal_point != '\0' and decimal_point != '.')
8764  {
8765  const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
8766  if (dec_pos != number_buffer.end())
8767  {
8768  *dec_pos = '.';
8769  }
8770  }
8771 
8772  o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
8773 
8774  // determine if need to append ".0"
8775  const bool value_is_int_like =
8776  std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
8777  [](char c)
8778  {
8779  return (c == '.' or c == 'e');
8780  });
8781 
8782  if (value_is_int_like)
8783  {
8784  o->write_characters(".0", 2);
8785  }
8786  }
8787 
8788  /*!
8789  @brief check whether a string is UTF-8 encoded
8790 
8791  The function checks each byte of a string whether it is UTF-8 encoded. The
8792  result of the check is stored in the @a state parameter. The function must
8793  be called initially with state 0 (accept). State 1 means the string must
8794  be rejected, because the current byte is not allowed. If the string is
8795  completely processed, but the state is non-zero, the string ended
8796  prematurely; that is, the last byte indicated more bytes should have
8797  followed.
8798 
8799  @param[in,out] state the state of the decoding
8800  @param[in,out] codep codepoint (valid only if resulting state is UTF8_ACCEPT)
8801  @param[in] byte next byte to decode
8802  @return new state
8803 
8804  @note The function has been edited: a std::array is used.
8805 
8806  @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
8807  @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
8808  */
8809  static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept
8810  {
8811  static const std::array<uint8_t, 400> utf8d =
8812  {
8813  {
8814  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
8815  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
8816  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
8817  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
8818  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
8819  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
8820  8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
8821  0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
8822  0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
8823  0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
8824  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
8825  1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
8826  1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
8827  1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
8828  }
8829  };
8830 
8831  const uint8_t type = utf8d[byte];
8832 
8833  codep = (state != UTF8_ACCEPT)
8834  ? (byte & 0x3fu) | (codep << 6)
8835  : static_cast<uint32_t>(0xff >> type) & (byte);
8836 
8837  state = utf8d[256u + state * 16u + type];
8838  return state;
8839  }
8840 
8841  private:
8842  /// the output of the serializer
8843  output_adapter_t<char> o = nullptr;
8844 
8845  /// a (hopefully) large enough character buffer
8846  std::array<char, 64> number_buffer{{}};
8847 
8848  /// the locale
8849  const std::lconv* loc = nullptr;
8850  /// the locale's thousand separator character
8851  const char thousands_sep = '\0';
8852  /// the locale's decimal point character
8853  const char decimal_point = '\0';
8854 
8855  /// string buffer
8856  std::array<char, 512> string_buffer{{}};
8857 
8858  /// the indentation character
8859  const char indent_char;
8860  /// the indentation string
8861  string_t indent_string;
8862 };
8863 }
8864 }
8865 
8866 // #include <nlohmann/detail/json_ref.hpp>
8867 
8868 
8869 #include <initializer_list>
8870 #include <utility>
8871 
8872 namespace nlohmann
8873 {
8874 namespace detail
8875 {
8876 template<typename BasicJsonType>
8877 class json_ref
8878 {
8879  public:
8880  using value_type = BasicJsonType;
8881 
8882  json_ref(value_type&& value)
8883  : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
8884  {}
8885 
8886  json_ref(const value_type& value)
8887  : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
8888  {}
8889 
8890  json_ref(std::initializer_list<json_ref> init)
8891  : owned_value(init), value_ref(&owned_value), is_rvalue(true)
8892  {}
8893 
8894  template<class... Args>
8895  json_ref(Args&& ... args)
8896  : owned_value(std::forward<Args>(args)...), value_ref(&owned_value), is_rvalue(true)
8897  {}
8898 
8899  // class should be movable only
8900  json_ref(json_ref&&) = default;
8901  json_ref(const json_ref&) = delete;
8902  json_ref& operator=(const json_ref&) = delete;
8903 
8904  value_type moved_or_copied() const
8905  {
8906  if (is_rvalue)
8907  {
8908  return std::move(*value_ref);
8909  }
8910  return *value_ref;
8911  }
8912 
8913  value_type const& operator*() const
8914  {
8915  return *static_cast<value_type const*>(value_ref);
8916  }
8917 
8918  value_type const* operator->() const
8919  {
8920  return static_cast<value_type const*>(value_ref);
8921  }
8922 
8923  private:
8924  mutable value_type owned_value = nullptr;
8925  value_type* value_ref = nullptr;
8926  const bool is_rvalue;
8927 };
8928 }
8929 }
8930 
8931 // #include <nlohmann/detail/json_pointer.hpp>
8932 
8933 
8934 #include <cassert> // assert
8935 #include <numeric> // accumulate
8936 #include <string> // string
8937 #include <vector> // vector
8938 
8939 // #include <nlohmann/detail/macro_scope.hpp>
8940 
8941 // #include <nlohmann/detail/exceptions.hpp>
8942 
8943 // #include <nlohmann/detail/value_t.hpp>
8944 
8945 
8946 namespace nlohmann
8947 {
8948 template<typename BasicJsonType>
8949 class json_pointer
8950 {
8951  // allow basic_json to access private members
8953  friend class basic_json;
8954 
8955  public:
8956  /*!
8957  @brief create JSON pointer
8958 
8959  Create a JSON pointer according to the syntax described in
8960  [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
8961 
8962  @param[in] s string representing the JSON pointer; if omitted, the empty
8963  string is assumed which references the whole JSON value
8964 
8965  @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
8966  not begin with a slash (`/`); see example below
8967 
8968  @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
8969  not followed by `0` (representing `~`) or `1` (representing `/`); see
8970  example below
8971 
8972  @liveexample{The example shows the construction several valid JSON pointers
8973  as well as the exceptional behavior.,json_pointer}
8974 
8975  @since version 2.0.0
8976  */
8977  explicit json_pointer(const std::string& s = "")
8979  {}
8980 
8981  /*!
8982  @brief return a string representation of the JSON pointer
8983 
8984  @invariant For each JSON pointer `ptr`, it holds:
8985  @code {.cpp}
8986  ptr == json_pointer(ptr.to_string());
8987  @endcode
8988 
8989  @return a string representation of the JSON pointer
8990 
8991  @liveexample{The example shows the result of `to_string`.,
8992  json_pointer__to_string}
8993 
8994  @since version 2.0.0
8995  */
8996  std::string to_string() const noexcept
8997  {
8998  return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
8999  std::string{},
9000  [](const std::string & a, const std::string & b)
9001  {
9002  return a + "/" + escape(b);
9003  });
9004  }
9005 
9006  /// @copydoc to_string()
9007  operator std::string() const
9008  {
9009  return to_string();
9010  }
9011 
9012  /*!
9013  @param[in] s reference token to be converted into an array index
9014 
9015  @return integer representation of @a s
9016 
9017  @throw out_of_range.404 if string @a s could not be converted to an integer
9018  */
9019  static int array_index(const std::string& s)
9020  {
9021  std::size_t processed_chars = 0;
9022  const int res = std::stoi(s, &processed_chars);
9023 
9024  // check if the string was completely read
9025  if (JSON_UNLIKELY(processed_chars != s.size()))
9026  {
9027  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
9028  }
9029 
9030  return res;
9031  }
9032 
9033  private:
9034  /*!
9035  @brief remove and return last reference pointer
9036  @throw out_of_range.405 if JSON pointer has no parent
9037  */
9038  std::string pop_back()
9039  {
9040  if (JSON_UNLIKELY(is_root()))
9041  {
9042  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
9043  }
9044 
9045  auto last = reference_tokens.back();
9046  reference_tokens.pop_back();
9047  return last;
9048  }
9049 
9050  /// return whether pointer points to the root document
9051  bool is_root() const
9052  {
9053  return reference_tokens.empty();
9054  }
9055 
9056  json_pointer top() const
9057  {
9058  if (JSON_UNLIKELY(is_root()))
9059  {
9060  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
9061  }
9062 
9063  json_pointer result = *this;
9064  result.reference_tokens = {reference_tokens[0]};
9065  return result;
9066  }
9067 
9068  /*!
9069  @brief create and return a reference to the pointed to value
9070 
9071  @complexity Linear in the number of reference tokens.
9072 
9073  @throw parse_error.109 if array index is not a number
9074  @throw type_error.313 if value cannot be unflattened
9075  */
9076  BasicJsonType& get_and_create(BasicJsonType& j) const
9077  {
9078  using size_type = typename BasicJsonType::size_type;
9079  auto result = &j;
9080 
9081  // in case no reference tokens exist, return a reference to the JSON value
9082  // j which will be overwritten by a primitive value
9083  for (const auto& reference_token : reference_tokens)
9084  {
9085  switch (result->m_type)
9086  {
9087  case detail::value_t::null:
9088  {
9089  if (reference_token == "0")
9090  {
9091  // start a new array if reference token is 0
9092  result = &result->operator[](0);
9093  }
9094  else
9095  {
9096  // start a new object otherwise
9097  result = &result->operator[](reference_token);
9098  }
9099  break;
9100  }
9101 
9102  case detail::value_t::object:
9103  {
9104  // create an entry in the object
9105  result = &result->operator[](reference_token);
9106  break;
9107  }
9108 
9109  case detail::value_t::array:
9110  {
9111  // create an entry in the array
9112  JSON_TRY
9113  {
9114  result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
9115  }
9116  JSON_CATCH(std::invalid_argument&)
9117  {
9118  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
9119  }
9120  break;
9121  }
9122 
9123  /*
9124  The following code is only reached if there exists a reference
9125  token _and_ the current value is primitive. In this case, we have
9126  an error situation, because primitive values may only occur as
9127  single value; that is, with an empty list of reference tokens.
9128  */
9129  default:
9130  JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
9131  }
9132  }
9133 
9134  return *result;
9135  }
9136 
9137  /*!
9138  @brief return a reference to the pointed to value
9139 
9140  @note This version does not throw if a value is not present, but tries to
9141  create nested values instead. For instance, calling this function
9142  with pointer `"/this/that"` on a null value is equivalent to calling
9143  `operator[]("this").operator[]("that")` on that value, effectively
9144  changing the null value to an object.
9145 
9146  @param[in] ptr a JSON value
9147 
9148  @return reference to the JSON value pointed to by the JSON pointer
9149 
9150  @complexity Linear in the length of the JSON pointer.
9151 
9152  @throw parse_error.106 if an array index begins with '0'
9153  @throw parse_error.109 if an array index was not a number
9154  @throw out_of_range.404 if the JSON pointer can not be resolved
9155  */
9156  BasicJsonType& get_unchecked(BasicJsonType* ptr) const
9157  {
9158  using size_type = typename BasicJsonType::size_type;
9159  for (const auto& reference_token : reference_tokens)
9160  {
9161  // convert null values to arrays or objects before continuing
9162  if (ptr->m_type == detail::value_t::null)
9163  {
9164  // check if reference token is a number
9165  const bool nums =
9166  std::all_of(reference_token.begin(), reference_token.end(),
9167  [](const char x)
9168  {
9169  return (x >= '0' and x <= '9');
9170  });
9171 
9172  // change value to array for numbers or "-" or to object otherwise
9173  *ptr = (nums or reference_token == "-")
9174  ? detail::value_t::array
9175  : detail::value_t::object;
9176  }
9177 
9178  switch (ptr->m_type)
9179  {
9180  case detail::value_t::object:
9181  {
9182  // use unchecked object access
9183  ptr = &ptr->operator[](reference_token);
9184  break;
9185  }
9186 
9187  case detail::value_t::array:
9188  {
9189  // error condition (cf. RFC 6901, Sect. 4)
9190  if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
9191  {
9192  JSON_THROW(detail::parse_error::create(106, 0,
9193  "array index '" + reference_token +
9194  "' must not begin with '0'"));
9195  }
9196 
9197  if (reference_token == "-")
9198  {
9199  // explicitly treat "-" as index beyond the end
9200  ptr = &ptr->operator[](ptr->m_value.array->size());
9201  }
9202  else
9203  {
9204  // convert array index to number; unchecked access
9205  JSON_TRY
9206  {
9207  ptr = &ptr->operator[](
9208  static_cast<size_type>(array_index(reference_token)));
9209  }
9210  JSON_CATCH(std::invalid_argument&)
9211  {
9212  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
9213  }
9214  }
9215  break;
9216  }
9217 
9218  default:
9219  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
9220  }
9221  }
9222 
9223  return *ptr;
9224  }
9225 
9226  /*!
9227  @throw parse_error.106 if an array index begins with '0'
9228  @throw parse_error.109 if an array index was not a number
9229  @throw out_of_range.402 if the array index '-' is used
9230  @throw out_of_range.404 if the JSON pointer can not be resolved
9231  */
9232  BasicJsonType& get_checked(BasicJsonType* ptr) const
9233  {
9234  using size_type = typename BasicJsonType::size_type;
9235  for (const auto& reference_token : reference_tokens)
9236  {
9237  switch (ptr->m_type)
9238  {
9239  case detail::value_t::object:
9240  {
9241  // note: at performs range check
9242  ptr = &ptr->at(reference_token);
9243  break;
9244  }
9245 
9246  case detail::value_t::array:
9247  {
9248  if (JSON_UNLIKELY(reference_token == "-"))
9249  {
9250  // "-" always fails the range check
9251  JSON_THROW(detail::out_of_range::create(402,
9252  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
9253  ") is out of range"));
9254  }
9255 
9256  // error condition (cf. RFC 6901, Sect. 4)
9257  if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
9258  {
9259  JSON_THROW(detail::parse_error::create(106, 0,
9260  "array index '" + reference_token +
9261  "' must not begin with '0'"));
9262  }
9263 
9264  // note: at performs range check
9265  JSON_TRY
9266  {
9267  ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
9268  }
9269  JSON_CATCH(std::invalid_argument&)
9270  {
9271  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
9272  }
9273  break;
9274  }
9275 
9276  default:
9277  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
9278  }
9279  }
9280 
9281  return *ptr;
9282  }
9283 
9284  /*!
9285  @brief return a const reference to the pointed to value
9286 
9287  @param[in] ptr a JSON value
9288 
9289  @return const reference to the JSON value pointed to by the JSON
9290  pointer
9291 
9292  @throw parse_error.106 if an array index begins with '0'
9293  @throw parse_error.109 if an array index was not a number
9294  @throw out_of_range.402 if the array index '-' is used
9295  @throw out_of_range.404 if the JSON pointer can not be resolved
9296  */
9297  const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
9298  {
9299  using size_type = typename BasicJsonType::size_type;
9300  for (const auto& reference_token : reference_tokens)
9301  {
9302  switch (ptr->m_type)
9303  {
9304  case detail::value_t::object:
9305  {
9306  // use unchecked object access
9307  ptr = &ptr->operator[](reference_token);
9308  break;
9309  }
9310 
9311  case detail::value_t::array:
9312  {
9313  if (JSON_UNLIKELY(reference_token == "-"))
9314  {
9315  // "-" cannot be used for const access
9316  JSON_THROW(detail::out_of_range::create(402,
9317  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
9318  ") is out of range"));
9319  }
9320 
9321  // error condition (cf. RFC 6901, Sect. 4)
9322  if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
9323  {
9324  JSON_THROW(detail::parse_error::create(106, 0,
9325  "array index '" + reference_token +
9326  "' must not begin with '0'"));
9327  }
9328 
9329  // use unchecked array access
9330  JSON_TRY
9331  {
9332  ptr = &ptr->operator[](
9333  static_cast<size_type>(array_index(reference_token)));
9334  }
9335  JSON_CATCH(std::invalid_argument&)
9336  {
9337  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
9338  }
9339  break;
9340  }
9341 
9342  default:
9343  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
9344  }
9345  }
9346 
9347  return *ptr;
9348  }
9349 
9350  /*!
9351  @throw parse_error.106 if an array index begins with '0'
9352  @throw parse_error.109 if an array index was not a number
9353  @throw out_of_range.402 if the array index '-' is used
9354  @throw out_of_range.404 if the JSON pointer can not be resolved
9355  */
9356  const BasicJsonType& get_checked(const BasicJsonType* ptr) const
9357  {
9358  using size_type = typename BasicJsonType::size_type;
9359  for (const auto& reference_token : reference_tokens)
9360  {
9361  switch (ptr->m_type)
9362  {
9363  case detail::value_t::object:
9364  {
9365  // note: at performs range check
9366  ptr = &ptr->at(reference_token);
9367  break;
9368  }
9369 
9370  case detail::value_t::array:
9371  {
9372  if (JSON_UNLIKELY(reference_token == "-"))
9373  {
9374  // "-" always fails the range check
9375  JSON_THROW(detail::out_of_range::create(402,
9376  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
9377  ") is out of range"));
9378  }
9379 
9380  // error condition (cf. RFC 6901, Sect. 4)
9381  if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
9382  {
9383  JSON_THROW(detail::parse_error::create(106, 0,
9384  "array index '" + reference_token +
9385  "' must not begin with '0'"));
9386  }
9387 
9388  // note: at performs range check
9389  JSON_TRY
9390  {
9391  ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
9392  }
9393  JSON_CATCH(std::invalid_argument&)
9394  {
9395  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
9396  }
9397  break;
9398  }
9399 
9400  default:
9401  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
9402  }
9403  }
9404 
9405  return *ptr;
9406  }
9407 
9408  /*!
9409  @brief split the string input to reference tokens
9410 
9411  @note This function is only called by the json_pointer constructor.
9412  All exceptions below are documented there.
9413 
9414  @throw parse_error.107 if the pointer is not empty or begins with '/'
9415  @throw parse_error.108 if character '~' is not followed by '0' or '1'
9416  */
9417  static std::vector<std::string> split(const std::string& reference_string)
9418  {
9419  std::vector<std::string> result;
9420 
9421  // special case: empty reference string -> no reference tokens
9422  if (reference_string.empty())
9423  {
9424  return result;
9425  }
9426 
9427  // check if nonempty reference string begins with slash
9428  if (JSON_UNLIKELY(reference_string[0] != '/'))
9429  {
9430  JSON_THROW(detail::parse_error::create(107, 1,
9431  "JSON pointer must be empty or begin with '/' - was: '" +
9432  reference_string + "'"));
9433  }
9434 
9435  // extract the reference tokens:
9436  // - slash: position of the last read slash (or end of string)
9437  // - start: position after the previous slash
9438  for (
9439  // search for the first slash after the first character
9440  std::size_t slash = reference_string.find_first_of('/', 1),
9441  // set the beginning of the first reference token
9442  start = 1;
9443  // we can stop if start == string::npos+1 = 0
9444  start != 0;
9445  // set the beginning of the next reference token
9446  // (will eventually be 0 if slash == std::string::npos)
9447  start = slash + 1,
9448  // find next slash
9449  slash = reference_string.find_first_of('/', start))
9450  {
9451  // use the text between the beginning of the reference token
9452  // (start) and the last slash (slash).
9453  auto reference_token = reference_string.substr(start, slash - start);
9454 
9455  // check reference tokens are properly escaped
9456  for (std::size_t pos = reference_token.find_first_of('~');
9457  pos != std::string::npos;
9458  pos = reference_token.find_first_of('~', pos + 1))
9459  {
9460  assert(reference_token[pos] == '~');
9461 
9462  // ~ must be followed by 0 or 1
9463  if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
9464  (reference_token[pos + 1] != '0' and
9465  reference_token[pos + 1] != '1')))
9466  {
9467  JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
9468  }
9469  }
9470 
9471  // finally, store the reference token
9472  unescape(reference_token);
9473  result.push_back(reference_token);
9474  }
9475 
9476  return result;
9477  }
9478 
9479  /*!
9480  @brief replace all occurrences of a substring by another string
9481 
9482  @param[in,out] s the string to manipulate; changed so that all
9483  occurrences of @a f are replaced with @a t
9484  @param[in] f the substring to replace with @a t
9485  @param[in] t the string to replace @a f
9486 
9487  @pre The search string @a f must not be empty. **This precondition is
9488  enforced with an assertion.**
9489 
9490  @since version 2.0.0
9491  */
9492  static void replace_substring(std::string& s, const std::string& f,
9493  const std::string& t)
9494  {
9495  assert(not f.empty());
9496  for (auto pos = s.find(f); // find first occurrence of f
9497  pos != std::string::npos; // make sure f was found
9498  s.replace(pos, f.size(), t), // replace with t, and
9499  pos = s.find(f, pos + t.size())) // find next occurrence of f
9500  {}
9501  }
9502 
9503  /// escape "~"" to "~0" and "/" to "~1"
9504  static std::string escape(std::string s)
9505  {
9506  replace_substring(s, "~", "~0");
9507  replace_substring(s, "/", "~1");
9508  return s;
9509  }
9510 
9511  /// unescape "~1" to tilde and "~0" to slash (order is important!)
9512  static void unescape(std::string& s)
9513  {
9514  replace_substring(s, "~1", "/");
9515  replace_substring(s, "~0", "~");
9516  }
9517 
9518  /*!
9519  @param[in] reference_string the reference string to the current value
9520  @param[in] value the value to consider
9521  @param[in,out] result the result object to insert values to
9522 
9523  @note Empty objects or arrays are flattened to `null`.
9524  */
9525  static void flatten(const std::string& reference_string,
9526  const BasicJsonType& value,
9527  BasicJsonType& result)
9528  {
9529  switch (value.m_type)
9530  {
9531  case detail::value_t::array:
9532  {
9533  if (value.m_value.array->empty())
9534  {
9535  // flatten empty array as null
9536  result[reference_string] = nullptr;
9537  }
9538  else
9539  {
9540  // iterate array and use index as reference string
9541  for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
9542  {
9543  flatten(reference_string + "/" + std::to_string(i),
9544  value.m_value.array->operator[](i), result);
9545  }
9546  }
9547  break;
9548  }
9549 
9550  case detail::value_t::object:
9551  {
9552  if (value.m_value.object->empty())
9553  {
9554  // flatten empty object as null
9555  result[reference_string] = nullptr;
9556  }
9557  else
9558  {
9559  // iterate object and use keys as reference string
9560  for (const auto& element : *value.m_value.object)
9561  {
9562  flatten(reference_string + "/" + escape(element.first), element.second, result);
9563  }
9564  }
9565  break;
9566  }
9567 
9568  default:
9569  {
9570  // add primitive value with its reference string
9571  result[reference_string] = value;
9572  break;
9573  }
9574  }
9575  }
9576 
9577  /*!
9578  @param[in] value flattened JSON
9579 
9580  @return unflattened JSON
9581 
9582  @throw parse_error.109 if array index is not a number
9583  @throw type_error.314 if value is not an object
9584  @throw type_error.315 if object values are not primitive
9585  @throw type_error.313 if value cannot be unflattened
9586  */
9587  static BasicJsonType
9588  unflatten(const BasicJsonType& value)
9589  {
9590  if (JSON_UNLIKELY(not value.is_object()))
9591  {
9592  JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
9593  }
9594 
9595  BasicJsonType result;
9596 
9597  // iterate the JSON object values
9598  for (const auto& element : *value.m_value.object)
9599  {
9600  if (JSON_UNLIKELY(not element.second.is_primitive()))
9601  {
9602  JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
9603  }
9604 
9605  // assign value to reference pointed to by JSON pointer; Note that if
9606  // the JSON pointer is "" (i.e., points to the whole value), function
9607  // get_and_create returns a reference to result itself. An assignment
9608  // will then create a primitive value.
9609  json_pointer(element.first).get_and_create(result) = element.second;
9610  }
9611 
9612  return result;
9613  }
9614 
9615  friend bool operator==(json_pointer const& lhs,
9616  json_pointer const& rhs) noexcept
9617  {
9618  return (lhs.reference_tokens == rhs.reference_tokens);
9619  }
9621  friend bool operator!=(json_pointer const& lhs,
9622  json_pointer const& rhs) noexcept
9623  {
9624  return not (lhs == rhs);
9625  }
9627  /// the reference tokens
9628  std::vector<std::string> reference_tokens;
9629 };
9630 }
9631 
9632 // #include <nlohmann/adl_serializer.hpp>
9633 
9634 
9635 #include <utility>
9636 
9637 // #include <nlohmann/detail/conversions/from_json.hpp>
9638 
9639 // #include <nlohmann/detail/conversions/to_json.hpp>
9640 
9641 
9642 namespace nlohmann
9643 {
9644 template<typename, typename>
9645 struct adl_serializer
9646 {
9647  /*!
9648  @brief convert a JSON value to any value type
9649 
9650  This function is usually called by the `get()` function of the
9651  @ref basic_json class (either explicit or via conversion operators).
9652 
9653  @param[in] j JSON value to read from
9654  @param[in,out] val value to write to
9655  */
9656  template<typename BasicJsonType, typename ValueType>
9657  static void from_json(BasicJsonType&& j, ValueType& val) noexcept(
9658  noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
9659  {
9660  ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
9661  }
9663  /*!
9664  @brief convert any value type to a JSON value
9665 
9666  This function is usually called by the constructors of the @ref basic_json
9667  class.
9668 
9669  @param[in,out] j JSON value to write to
9670  @param[in] val value to read from
9671  */
9672  template<typename BasicJsonType, typename ValueType>
9673  static void to_json(BasicJsonType& j, ValueType&& val) noexcept(
9674  noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
9675  {
9676  ::nlohmann::to_json(j, std::forward<ValueType>(val));
9677  }
9678 };
9679 }
9680 
9681 
9682 /*!
9683 @brief namespace for Niels Lohmann
9684 @see https://github.com/nlohmann
9685 @since version 1.0.0
9686 */
9687 namespace nlohmann
9688 {
9689 
9690 /*!
9691 @brief a class to store JSON values
9692 
9693 @tparam ObjectType type for JSON objects (`std::map` by default; will be used
9694 in @ref object_t)
9695 @tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
9696 in @ref array_t)
9697 @tparam StringType type for JSON strings and object keys (`std::string` by
9698 default; will be used in @ref string_t)
9699 @tparam BooleanType type for JSON booleans (`bool` by default; will be used
9700 in @ref boolean_t)
9701 @tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
9702 default; will be used in @ref number_integer_t)
9703 @tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
9704 `uint64_t` by default; will be used in @ref number_unsigned_t)
9705 @tparam NumberFloatType type for JSON floating-point numbers (`double` by
9706 default; will be used in @ref number_float_t)
9707 @tparam AllocatorType type of the allocator to use (`std::allocator` by
9708 default)
9709 @tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
9710 and `from_json()` (@ref adl_serializer by default)
9711 
9712 @requirement The class satisfies the following concept requirements:
9713 - Basic
9714  - [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible):
9715  JSON values can be default constructed. The result will be a JSON null
9716  value.
9717  - [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible):
9718  A JSON value can be constructed from an rvalue argument.
9719  - [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible):
9720  A JSON value can be copy-constructed from an lvalue expression.
9721  - [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable):
9722  A JSON value van be assigned from an rvalue argument.
9723  - [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable):
9724  A JSON value can be copy-assigned from an lvalue expression.
9725  - [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible):
9726  JSON values can be destructed.
9727 - Layout
9728  - [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType):
9729  JSON values have
9730  [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
9731  All non-static data members are private and standard layout types, the
9732  class has no virtual functions or (virtual) base classes.
9733 - Library-wide
9734  - [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable):
9735  JSON values can be compared with `==`, see @ref
9736  operator==(const_reference,const_reference).
9737  - [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable):
9738  JSON values can be compared with `<`, see @ref
9739  operator<(const_reference,const_reference).
9740  - [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable):
9741  Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
9742  other compatible types, using unqualified function call @ref swap().
9743  - [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer):
9744  JSON values can be compared against `std::nullptr_t` objects which are used
9745  to model the `null` value.
9746 - Container
9747  - [Container](http://en.cppreference.com/w/cpp/concept/Container):
9748  JSON values can be used like STL containers and provide iterator access.
9749  - [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer);
9750  JSON values can be used like STL containers and provide reverse iterator
9751  access.
9752 
9753 @invariant The member variables @a m_value and @a m_type have the following
9754 relationship:
9755 - If `m_type == value_t::object`, then `m_value.object != nullptr`.
9756 - If `m_type == value_t::array`, then `m_value.array != nullptr`.
9757 - If `m_type == value_t::string`, then `m_value.string != nullptr`.
9758 The invariants are checked by member function assert_invariant().
9759 
9760 @internal
9761 @note ObjectType trick from http://stackoverflow.com/a/9860911
9762 @endinternal
9763 
9764 @see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
9765 Format](http://rfc7159.net/rfc7159)
9766 
9767 @since version 1.0.0
9768 
9769 @nosubgrouping
9770 */
9772 class basic_json
9773 {
9774  private:
9775  template<detail::value_t> friend struct detail::external_constructor;
9776  friend ::nlohmann::json_pointer<basic_json>;
9777  friend ::nlohmann::detail::parser<basic_json>;
9778  friend ::nlohmann::detail::serializer<basic_json>;
9779  template<typename BasicJsonType>
9780  friend class ::nlohmann::detail::iter_impl;
9781  template<typename BasicJsonType, typename CharType>
9782  friend class ::nlohmann::detail::binary_writer;
9783  template<typename BasicJsonType>
9784  friend class ::nlohmann::detail::binary_reader;
9785 
9786  /// workaround type for MSVC
9787  using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
9788 
9789  // convenience aliases for types residing in namespace detail;
9790  using lexer = ::nlohmann::detail::lexer<basic_json>;
9791  using parser = ::nlohmann::detail::parser<basic_json>;
9792 
9793  using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
9794  template<typename BasicJsonType>
9795  using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
9796  template<typename BasicJsonType>
9797  using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
9798  template<typename Iterator>
9799  using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
9800  template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
9801 
9802  template<typename CharType>
9803  using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
9804 
9805  using binary_reader = ::nlohmann::detail::binary_reader<basic_json>;
9806  template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
9807 
9808  using serializer = ::nlohmann::detail::serializer<basic_json>;
9809 
9810  public:
9811  using value_t = detail::value_t;
9812  /// @copydoc nlohmann::json_pointer
9813  using json_pointer = ::nlohmann::json_pointer<basic_json>;
9814  template<typename T, typename SFINAE>
9815  using json_serializer = JSONSerializer<T, SFINAE>;
9816  /// helper type for initializer lists of basic_json values
9817  using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
9819  ////////////////
9820  // exceptions //
9821  ////////////////
9823  /// @name exceptions
9824  /// Classes to implement user-defined exceptions.
9825  /// @{
9826 
9827  /// @copydoc detail::exception
9828  using exception = detail::exception;
9829  /// @copydoc detail::parse_error
9830  using parse_error = detail::parse_error;
9831  /// @copydoc detail::invalid_iterator
9832  using invalid_iterator = detail::invalid_iterator;
9833  /// @copydoc detail::type_error
9834  using type_error = detail::type_error;
9835  /// @copydoc detail::out_of_range
9836  using out_of_range = detail::out_of_range;
9837  /// @copydoc detail::other_error
9838  using other_error = detail::other_error;
9840  /// @}
9842 
9843  /////////////////////
9844  // container types //
9845  /////////////////////
9846 
9847  /// @name container types
9848  /// The canonic container types to use @ref basic_json like any other STL
9849  /// container.
9850  /// @{
9851 
9852  /// the type of elements in a basic_json container
9853  using value_type = basic_json;
9854 
9855  /// the type of an element reference
9856  using reference = value_type&;
9857  /// the type of an element const reference
9858  using const_reference = const value_type&;
9859 
9860  /// a type to represent differences between iterators
9861  using difference_type = std::ptrdiff_t;
9862  /// a type to represent container sizes
9863  using size_type = std::size_t;
9864 
9865  /// the allocator type
9866  using allocator_type = AllocatorType<basic_json>;
9867 
9868  /// the type of an element pointer
9869  using pointer = typename std::allocator_traits<allocator_type>::pointer;
9870  /// the type of an element const pointer
9871  using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
9872 
9873  /// an iterator for a basic_json container
9874  using iterator = iter_impl<basic_json>;
9875  /// a const iterator for a basic_json container
9876  using const_iterator = iter_impl<const basic_json>;
9877  /// a reverse iterator for a basic_json container
9878  using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
9879  /// a const reverse iterator for a basic_json container
9880  using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
9882  /// @}
9884 
9885  /*!
9886  @brief returns the allocator associated with the container
9887  */
9888  static allocator_type get_allocator()
9889  {
9890  return allocator_type();
9891  }
9892 
9893  /*!
9894  @brief returns version information on the library
9895 
9896  This function returns a JSON object with information about the library,
9897  including the version number and information on the platform and compiler.
9898 
9899  @return JSON object holding version information
9900  key | description
9901  ----------- | ---------------
9902  `compiler` | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
9903  `copyright` | The copyright line for the library as string.
9904  `name` | The name of the library as string.
9905  `platform` | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
9906  `url` | The URL of the project as string.
9907  `version` | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
9908 
9909  @liveexample{The following code shows an example output of the `meta()`
9910  function.,meta}
9911 
9912  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
9913  changes to any JSON value.
9914 
9915  @complexity Constant.
9916 
9917  @since 2.1.0
9918  */
9919  static basic_json meta()
9920  {
9921  basic_json result;
9922 
9923  result["copyright"] = "(C) 2013-2017 Niels Lohmann";
9924  result["name"] = "JSON for Modern C++";
9925  result["url"] = "https://github.com/nlohmann/json";
9926  result["version"]["string"] =
9927  std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
9928  std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
9929  std::to_string(NLOHMANN_JSON_VERSION_PATCH);
9930  result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
9931  result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
9932  result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
9933 
9934 #ifdef _WIN32
9935  result["platform"] = "win32";
9936 #elif defined __linux__
9937  result["platform"] = "linux";
9938 #elif defined __APPLE__
9939  result["platform"] = "apple";
9940 #elif defined __unix__
9941  result["platform"] = "unix";
9942 #else
9943  result["platform"] = "unknown";
9944 #endif
9945 
9946 #if defined(__ICC) || defined(__INTEL_COMPILER)
9947  result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
9948 #elif defined(__clang__)
9949  result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
9950 #elif defined(__GNUC__) || defined(__GNUG__)
9951  result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
9952 #elif defined(__HP_cc) || defined(__HP_aCC)
9953  result["compiler"] = "hp"
9954 #elif defined(__IBMCPP__)
9955  result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
9956 #elif defined(_MSC_VER)
9957  result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
9958 #elif defined(__PGI)
9959  result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
9960 #elif defined(__SUNPRO_CC)
9961  result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
9962 #else
9963  result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
9964 #endif
9965 
9966 #ifdef __cplusplus
9967  result["compiler"]["c++"] = std::to_string(__cplusplus);
9968 #else
9969  result["compiler"]["c++"] = "unknown";
9970 #endif
9971  return result;
9972  }
9973 
9974 
9975  ///////////////////////////
9976  // JSON value data types //
9977  ///////////////////////////
9978 
9979  /// @name JSON value data types
9980  /// The data types to store a JSON value. These types are derived from
9981  /// the template arguments passed to class @ref basic_json.
9982  /// @{
9983 
9984 #if defined(JSON_HAS_CPP_14)
9985  // Use transparent comparator if possible, combined with perfect forwarding
9986  // on find() and count() calls prevents unnecessary string construction.
9987  using object_comparator_t = std::less<>;
9988 #else
9989  using object_comparator_t = std::less<StringType>;
9990 #endif
9991 
9992  /*!
9993  @brief a type for an object
9995  [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
9996  > An object is an unordered collection of zero or more name/value pairs,
9997  > where a name is a string and a value is a string, number, boolean, null,
9998  > object, or array.
9999 
10000  To store objects in C++, a type is defined by the template parameters
10001  described below.
10002 
10003  @tparam ObjectType the container to store objects (e.g., `std::map` or
10004  `std::unordered_map`)
10005  @tparam StringType the type of the keys or names (e.g., `std::string`).
10006  The comparison function `std::less<StringType>` is used to order elements
10007  inside the container.
10008  @tparam AllocatorType the allocator to use for objects (e.g.,
10009  `std::allocator`)
10010 
10011  #### Default type
10012 
10013  With the default values for @a ObjectType (`std::map`), @a StringType
10014  (`std::string`), and @a AllocatorType (`std::allocator`), the default
10015  value for @a object_t is:
10016 
10017  @code {.cpp}
10018  std::map<
10019  std::string, // key_type
10020  basic_json, // value_type
10021  std::less<std::string>, // key_compare
10022  std::allocator<std::pair<const std::string, basic_json>> // allocator_type
10023  >
10024  @endcode
10025 
10026  #### Behavior
10027 
10028  The choice of @a object_t influences the behavior of the JSON class. With
10029  the default type, objects have the following behavior:
10030 
10031  - When all names are unique, objects will be interoperable in the sense
10032  that all software implementations receiving that object will agree on
10033  the name-value mappings.
10034  - When the names within an object are not unique, it is unspecified which
10035  one of the values for a given key will be chosen. For instance,
10036  `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
10037  `{"key": 2}`.
10038  - Internally, name/value pairs are stored in lexicographical order of the
10039  names. Objects will also be serialized (see @ref dump) in this order.
10040  For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
10041  and serialized as `{"a": 2, "b": 1}`.
10042  - When comparing objects, the order of the name/value pairs is irrelevant.
10043  This makes objects interoperable in the sense that they will not be
10044  affected by these differences. For instance, `{"b": 1, "a": 2}` and
10045  `{"a": 2, "b": 1}` will be treated as equal.
10046 
10047  #### Limits
10048 
10049  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
10050  > An implementation may set limits on the maximum depth of nesting.
10051 
10052  In this class, the object's limit of nesting is not explicitly constrained.
10053  However, a maximum depth of nesting may be introduced by the compiler or
10054  runtime environment. A theoretical limit can be queried by calling the
10055  @ref max_size function of a JSON object.
10056 
10057  #### Storage
10058 
10059  Objects are stored as pointers in a @ref basic_json type. That is, for any
10060  access to object values, a pointer of type `object_t*` must be
10061  dereferenced.
10062 
10063  @sa @ref array_t -- type for an array value
10064 
10065  @since version 1.0.0
10066 
10067  @note The order name/value pairs are added to the object is *not*
10068  preserved by the library. Therefore, iterating an object may return
10069  name/value pairs in a different order than they were originally stored. In
10070  fact, keys will be traversed in alphabetical order as `std::map` with
10071  `std::less` is used by default. Please note this behavior conforms to [RFC
10072  7159](http://rfc7159.net/rfc7159), because any order implements the
10073  specified "unordered" nature of JSON objects.
10074  */
10075  using object_t = ObjectType<StringType,
10076  basic_json,
10077  object_comparator_t,
10078  AllocatorType<std::pair<const StringType,
10079  basic_json>>>;
10080 
10081  /*!
10082  @brief a type for an array
10083 
10084  [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
10085  > An array is an ordered sequence of zero or more values.
10086 
10087  To store objects in C++, a type is defined by the template parameters
10088  explained below.
10089 
10090  @tparam ArrayType container type to store arrays (e.g., `std::vector` or
10091  `std::list`)
10092  @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
10093 
10094  #### Default type
10095 
10096  With the default values for @a ArrayType (`std::vector`) and @a
10097  AllocatorType (`std::allocator`), the default value for @a array_t is:
10098 
10099  @code {.cpp}
10100  std::vector<
10101  basic_json, // value_type
10102  std::allocator<basic_json> // allocator_type
10103  >
10104  @endcode
10105 
10106  #### Limits
10107 
10108  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
10109  > An implementation may set limits on the maximum depth of nesting.
10110 
10111  In this class, the array's limit of nesting is not explicitly constrained.
10112  However, a maximum depth of nesting may be introduced by the compiler or
10113  runtime environment. A theoretical limit can be queried by calling the
10114  @ref max_size function of a JSON array.
10115 
10116  #### Storage
10117 
10118  Arrays are stored as pointers in a @ref basic_json type. That is, for any
10119  access to array values, a pointer of type `array_t*` must be dereferenced.
10120 
10121  @sa @ref object_t -- type for an object value
10122 
10123  @since version 1.0.0
10124  */
10125  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
10126 
10127  /*!
10128  @brief a type for a string
10129 
10130  [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
10131  > A string is a sequence of zero or more Unicode characters.
10132 
10133  To store objects in C++, a type is defined by the template parameter
10134  described below. Unicode values are split by the JSON class into
10135  byte-sized characters during deserialization.
10136 
10137  @tparam StringType the container to store strings (e.g., `std::string`).
10138  Note this container is used for keys/names in objects, see @ref object_t.
10139 
10140  #### Default type
10141 
10142  With the default values for @a StringType (`std::string`), the default
10143  value for @a string_t is:
10144 
10145  @code {.cpp}
10146  std::string
10147  @endcode
10148 
10149  #### Encoding
10150 
10151  Strings are stored in UTF-8 encoding. Therefore, functions like
10152  `std::string::size()` or `std::string::length()` return the number of
10153  bytes in the string rather than the number of characters or glyphs.
10154 
10155  #### String comparison
10156 
10157  [RFC 7159](http://rfc7159.net/rfc7159) states:
10158  > Software implementations are typically required to test names of object
10159  > members for equality. Implementations that transform the textual
10160  > representation into sequences of Unicode code units and then perform the
10161  > comparison numerically, code unit by code unit, are interoperable in the
10162  > sense that implementations will agree in all cases on equality or
10163  > inequality of two strings. For example, implementations that compare
10164  > strings with escaped characters unconverted may incorrectly find that
10165  > `"a\\b"` and `"a\u005Cb"` are not equal.
10166 
10167  This implementation is interoperable as it does compare strings code unit
10168  by code unit.
10169 
10170  #### Storage
10171 
10172  String values are stored as pointers in a @ref basic_json type. That is,
10173  for any access to string values, a pointer of type `string_t*` must be
10174  dereferenced.
10175 
10176  @since version 1.0.0
10177  */
10178  using string_t = StringType;
10179 
10180  /*!
10181  @brief a type for a boolean
10182 
10183  [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
10184  type which differentiates the two literals `true` and `false`.
10185 
10186  To store objects in C++, a type is defined by the template parameter @a
10187  BooleanType which chooses the type to use.
10188 
10189  #### Default type
10190 
10191  With the default values for @a BooleanType (`bool`), the default value for
10192  @a boolean_t is:
10193 
10194  @code {.cpp}
10195  bool
10196  @endcode
10197 
10198  #### Storage
10199 
10200  Boolean values are stored directly inside a @ref basic_json type.
10201 
10202  @since version 1.0.0
10203  */
10204  using boolean_t = BooleanType;
10205 
10206  /*!
10207  @brief a type for a number (integer)
10208 
10209  [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
10210  > The representation of numbers is similar to that used in most
10211  > programming languages. A number is represented in base 10 using decimal
10212  > digits. It contains an integer component that may be prefixed with an
10213  > optional minus sign, which may be followed by a fraction part and/or an
10214  > exponent part. Leading zeros are not allowed. (...) Numeric values that
10215  > cannot be represented in the grammar below (such as Infinity and NaN)
10216  > are not permitted.
10217 
10218  This description includes both integer and floating-point numbers.
10219  However, C++ allows more precise storage if it is known whether the number
10220  is a signed integer, an unsigned integer or a floating-point number.
10221  Therefore, three different types, @ref number_integer_t, @ref
10222  number_unsigned_t and @ref number_float_t are used.
10223 
10224  To store integer numbers in C++, a type is defined by the template
10225  parameter @a NumberIntegerType which chooses the type to use.
10226 
10227  #### Default type
10228 
10229  With the default values for @a NumberIntegerType (`int64_t`), the default
10230  value for @a number_integer_t is:
10231 
10232  @code {.cpp}
10233  int64_t
10234  @endcode
10235 
10236  #### Default behavior
10237 
10238  - The restrictions about leading zeros is not enforced in C++. Instead,
10239  leading zeros in integer literals lead to an interpretation as octal
10240  number. Internally, the value will be stored as decimal number. For
10241  instance, the C++ integer literal `010` will be serialized to `8`.
10242  During deserialization, leading zeros yield an error.
10243  - Not-a-number (NaN) values will be serialized to `null`.
10244 
10245  #### Limits
10246 
10247  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
10248  > An implementation may set limits on the range and precision of numbers.
10249 
10250  When the default type is used, the maximal integer number that can be
10251  stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
10252  that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
10253  that are out of range will yield over/underflow when used in a
10254  constructor. During deserialization, too large or small integer numbers
10255  will be automatically be stored as @ref number_unsigned_t or @ref
10256  number_float_t.
10257 
10258  [RFC 7159](http://rfc7159.net/rfc7159) further states:
10259  > Note that when such software is used, numbers that are integers and are
10260  > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
10261  > that implementations will agree exactly on their numeric values.
10262 
10263  As this range is a subrange of the exactly supported range [INT64_MIN,
10264  INT64_MAX], this class's integer type is interoperable.
10265 
10266  #### Storage
10267 
10268  Integer number values are stored directly inside a @ref basic_json type.
10269 
10270  @sa @ref number_float_t -- type for number values (floating-point)
10271 
10272  @sa @ref number_unsigned_t -- type for number values (unsigned integer)
10273 
10274  @since version 1.0.0
10275  */
10276  using number_integer_t = NumberIntegerType;
10277 
10278  /*!
10279  @brief a type for a number (unsigned)
10280 
10281  [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
10282  > The representation of numbers is similar to that used in most
10283  > programming languages. A number is represented in base 10 using decimal
10284  > digits. It contains an integer component that may be prefixed with an
10285  > optional minus sign, which may be followed by a fraction part and/or an
10286  > exponent part. Leading zeros are not allowed. (...) Numeric values that
10287  > cannot be represented in the grammar below (such as Infinity and NaN)
10288  > are not permitted.
10289 
10290  This description includes both integer and floating-point numbers.
10291  However, C++ allows more precise storage if it is known whether the number
10292  is a signed integer, an unsigned integer or a floating-point number.
10293  Therefore, three different types, @ref number_integer_t, @ref
10294  number_unsigned_t and @ref number_float_t are used.
10295 
10296  To store unsigned integer numbers in C++, a type is defined by the
10297  template parameter @a NumberUnsignedType which chooses the type to use.
10298 
10299  #### Default type
10300 
10301  With the default values for @a NumberUnsignedType (`uint64_t`), the
10302  default value for @a number_unsigned_t is:
10303 
10304  @code {.cpp}
10305  uint64_t
10306  @endcode
10307 
10308  #### Default behavior
10309 
10310  - The restrictions about leading zeros is not enforced in C++. Instead,
10311  leading zeros in integer literals lead to an interpretation as octal
10312  number. Internally, the value will be stored as decimal number. For
10313  instance, the C++ integer literal `010` will be serialized to `8`.
10314  During deserialization, leading zeros yield an error.
10315  - Not-a-number (NaN) values will be serialized to `null`.
10316 
10317  #### Limits
10318 
10319  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
10320  > An implementation may set limits on the range and precision of numbers.
10321 
10322  When the default type is used, the maximal integer number that can be
10323  stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
10324  number that can be stored is `0`. Integer numbers that are out of range
10325  will yield over/underflow when used in a constructor. During
10326  deserialization, too large or small integer numbers will be automatically
10327  be stored as @ref number_integer_t or @ref number_float_t.
10328 
10329  [RFC 7159](http://rfc7159.net/rfc7159) further states:
10330  > Note that when such software is used, numbers that are integers and are
10331  > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
10332  > that implementations will agree exactly on their numeric values.
10333 
10334  As this range is a subrange (when considered in conjunction with the
10335  number_integer_t type) of the exactly supported range [0, UINT64_MAX],
10336  this class's integer type is interoperable.
10337 
10338  #### Storage
10339 
10340  Integer number values are stored directly inside a @ref basic_json type.
10341 
10342  @sa @ref number_float_t -- type for number values (floating-point)
10343  @sa @ref number_integer_t -- type for number values (integer)
10344 
10345  @since version 2.0.0
10346  */
10347  using number_unsigned_t = NumberUnsignedType;
10348 
10349  /*!
10350  @brief a type for a number (floating-point)
10351 
10352  [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
10353  > The representation of numbers is similar to that used in most
10354  > programming languages. A number is represented in base 10 using decimal
10355  > digits. It contains an integer component that may be prefixed with an
10356  > optional minus sign, which may be followed by a fraction part and/or an
10357  > exponent part. Leading zeros are not allowed. (...) Numeric values that
10358  > cannot be represented in the grammar below (such as Infinity and NaN)
10359  > are not permitted.
10360 
10361  This description includes both integer and floating-point numbers.
10362  However, C++ allows more precise storage if it is known whether the number
10363  is a signed integer, an unsigned integer or a floating-point number.
10364  Therefore, three different types, @ref number_integer_t, @ref
10365  number_unsigned_t and @ref number_float_t are used.
10366 
10367  To store floating-point numbers in C++, a type is defined by the template
10368  parameter @a NumberFloatType which chooses the type to use.
10369 
10370  #### Default type
10371 
10372  With the default values for @a NumberFloatType (`double`), the default
10373  value for @a number_float_t is:
10374 
10375  @code {.cpp}
10376  double
10377  @endcode
10378 
10379  #### Default behavior
10380 
10381  - The restrictions about leading zeros is not enforced in C++. Instead,
10382  leading zeros in floating-point literals will be ignored. Internally,
10383  the value will be stored as decimal number. For instance, the C++
10384  floating-point literal `01.2` will be serialized to `1.2`. During
10385  deserialization, leading zeros yield an error.
10386  - Not-a-number (NaN) values will be serialized to `null`.
10387 
10388  #### Limits
10389 
10390  [RFC 7159](http://rfc7159.net/rfc7159) states:
10391  > This specification allows implementations to set limits on the range and
10392  > precision of numbers accepted. Since software that implements IEEE
10393  > 754-2008 binary64 (double precision) numbers is generally available and
10394  > widely used, good interoperability can be achieved by implementations
10395  > that expect no more precision or range than these provide, in the sense
10396  > that implementations will approximate JSON numbers within the expected
10397  > precision.
10398 
10399  This implementation does exactly follow this approach, as it uses double
10400  precision floating-point numbers. Note values smaller than
10401  `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
10402  will be stored as NaN internally and be serialized to `null`.
10403 
10404  #### Storage
10405 
10406  Floating-point number values are stored directly inside a @ref basic_json
10407  type.
10408 
10409  @sa @ref number_integer_t -- type for number values (integer)
10410 
10411  @sa @ref number_unsigned_t -- type for number values (unsigned integer)
10412 
10413  @since version 1.0.0
10414  */
10415  using number_float_t = NumberFloatType;
10416 
10417  /// @}
10418 
10419  private:
10421  /// helper for exception-safe object creation
10422  template<typename T, typename... Args>
10423  static T* create(Args&& ... args)
10424  {
10425  AllocatorType<T> alloc;
10426  using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
10427 
10428  auto deleter = [&](T * object)
10429  {
10430  AllocatorTraits::deallocate(alloc, object, 1);
10431  };
10432  std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
10433  AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
10434  assert(object != nullptr);
10435  return object.release();
10436  }
10437 
10438  ////////////////////////
10439  // JSON value storage //
10440  ////////////////////////
10441 
10442  /*!
10443  @brief a JSON value
10444 
10445  The actual storage for a JSON value of the @ref basic_json class. This
10446  union combines the different storage types for the JSON value types
10447  defined in @ref value_t.
10448 
10449  JSON type | value_t type | used type
10450  --------- | --------------- | ------------------------
10451  object | object | pointer to @ref object_t
10452  array | array | pointer to @ref array_t
10453  string | string | pointer to @ref string_t
10454  boolean | boolean | @ref boolean_t
10455  number | number_integer | @ref number_integer_t
10456  number | number_unsigned | @ref number_unsigned_t
10457  number | number_float | @ref number_float_t
10458  null | null | *no value is stored*
10459 
10460  @note Variable-length types (objects, arrays, and strings) are stored as
10461  pointers. The size of the union should not exceed 64 bits if the default
10462  value types are used.
10463 
10464  @since version 1.0.0
10465  */
10466  union json_value
10467  {
10468  /// object (stored with pointer to save storage)
10469  object_t* object;
10470  /// array (stored with pointer to save storage)
10471  array_t* array;
10472  /// string (stored with pointer to save storage)
10473  string_t* string;
10474  /// boolean
10475  boolean_t boolean;
10476  /// number (integer)
10477  number_integer_t number_integer;
10478  /// number (unsigned integer)
10479  number_unsigned_t number_unsigned;
10480  /// number (floating-point)
10481  number_float_t number_float;
10482 
10483  /// default constructor (for null values)
10484  json_value() = default;
10485  /// constructor for booleans
10486  json_value(boolean_t v) noexcept : boolean(v) {}
10487  /// constructor for numbers (integer)
10488  json_value(number_integer_t v) noexcept : number_integer(v) {}
10489  /// constructor for numbers (unsigned)
10490  json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
10491  /// constructor for numbers (floating-point)
10492  json_value(number_float_t v) noexcept : number_float(v) {}
10493  /// constructor for empty values of a given type
10494  json_value(value_t t)
10495  {
10496  switch (t)
10497  {
10498  case value_t::object:
10499  {
10500  object = create<object_t>();
10501  break;
10502  }
10503 
10504  case value_t::array:
10505  {
10506  array = create<array_t>();
10507  break;
10508  }
10509 
10510  case value_t::string:
10511  {
10512  string = create<string_t>("");
10513  break;
10514  }
10515 
10516  case value_t::boolean:
10517  {
10518  boolean = boolean_t(false);
10519  break;
10520  }
10521 
10522  case value_t::number_integer:
10523  {
10524  number_integer = number_integer_t(0);
10525  break;
10526  }
10527 
10528  case value_t::number_unsigned:
10529  {
10530  number_unsigned = number_unsigned_t(0);
10531  break;
10532  }
10533 
10534  case value_t::number_float:
10535  {
10536  number_float = number_float_t(0.0);
10537  break;
10538  }
10539 
10540  case value_t::null:
10541  {
10542  object = nullptr; // silence warning, see #821
10543  break;
10544  }
10545 
10546  default:
10547  {
10548  object = nullptr; // silence warning, see #821
10549  if (JSON_UNLIKELY(t == value_t::null))
10550  {
10551  JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.1.2")); // LCOV_EXCL_LINE
10552  }
10553  break;
10554  }
10555  }
10556  }
10557 
10558  /// constructor for strings
10559  json_value(const string_t& value)
10560  {
10561  string = create<string_t>(value);
10562  }
10563 
10564  /// constructor for rvalue strings
10565  json_value(string_t&& value)
10566  {
10567  string = create<string_t>(std::move(value));
10568  }
10569 
10570  /// constructor for objects
10571  json_value(const object_t& value)
10572  {
10573  object = create<object_t>(value);
10574  }
10575 
10576  /// constructor for rvalue objects
10577  json_value(object_t&& value)
10578  {
10579  object = create<object_t>(std::move(value));
10580  }
10581 
10582  /// constructor for arrays
10583  json_value(const array_t& value)
10584  {
10585  array = create<array_t>(value);
10586  }
10587 
10588  /// constructor for rvalue arrays
10589  json_value(array_t&& value)
10590  {
10591  array = create<array_t>(std::move(value));
10592  }
10593 
10594  void destroy(value_t t) noexcept
10595  {
10596  switch (t)
10597  {
10598  case value_t::object:
10599  {
10600  AllocatorType<object_t> alloc;
10601  std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
10602  std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
10603  break;
10604  }
10605 
10606  case value_t::array:
10607  {
10608  AllocatorType<array_t> alloc;
10609  std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
10610  std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
10611  break;
10612  }
10613 
10614  case value_t::string:
10615  {
10616  AllocatorType<string_t> alloc;
10617  std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
10618  std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
10619  break;
10620  }
10621 
10622  default:
10623  {
10624  break;
10625  }
10626  }
10627  }
10628  };
10629 
10630  /*!
10631  @brief checks the class invariants
10632 
10633  This function asserts the class invariants. It needs to be called at the
10634  end of every constructor to make sure that created objects respect the
10635  invariant. Furthermore, it has to be called each time the type of a JSON
10636  value is changed, because the invariant expresses a relationship between
10637  @a m_type and @a m_value.
10638  */
10639  void assert_invariant() const noexcept
10640  {
10641  assert(m_type != value_t::object or m_value.object != nullptr);
10642  assert(m_type != value_t::array or m_value.array != nullptr);
10643  assert(m_type != value_t::string or m_value.string != nullptr);
10644  }
10645 
10646  public:
10647  //////////////////////////
10648  // JSON parser callback //
10649  //////////////////////////
10650 
10651  /*!
10652  @brief parser event types
10653 
10654  The parser callback distinguishes the following events:
10655  - `object_start`: the parser read `{` and started to process a JSON object
10656  - `key`: the parser read a key of a value in an object
10657  - `object_end`: the parser read `}` and finished processing a JSON object
10658  - `array_start`: the parser read `[` and started to process a JSON array
10659  - `array_end`: the parser read `]` and finished processing a JSON array
10660  - `value`: the parser finished reading a JSON value
10661 
10662  @image html callback_events.png "Example when certain parse events are triggered"
10663 
10664  @sa @ref parser_callback_t for more information and examples
10665  */
10666  using parse_event_t = typename parser::parse_event_t;
10667 
10668  /*!
10669  @brief per-element parser callback type
10670 
10671  With a parser callback function, the result of parsing a JSON text can be
10672  influenced. When passed to @ref parse, it is called on certain events
10673  (passed as @ref parse_event_t via parameter @a event) with a set recursion
10674  depth @a depth and context JSON value @a parsed. The return value of the
10675  callback function is a boolean indicating whether the element that emitted
10676  the callback shall be kept or not.
10677 
10678  We distinguish six scenarios (determined by the event type) in which the
10679  callback function can be called. The following table describes the values
10680  of the parameters @a depth, @a event, and @a parsed.
10681 
10682  parameter @a event | description | parameter @a depth | parameter @a parsed
10683  ------------------ | ----------- | ------------------ | -------------------
10684  parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
10685  parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
10686  parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
10687  parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
10688  parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
10689  parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
10690 
10691  @image html callback_events.png "Example when certain parse events are triggered"
10692 
10693  Discarding a value (i.e., returning `false`) has different effects
10694  depending on the context in which function was called:
10695 
10696  - Discarded values in structured types are skipped. That is, the parser
10697  will behave as if the discarded value was never read.
10698  - In case a value outside a structured type is skipped, it is replaced
10699  with `null`. This case happens if the top-level element is skipped.
10700 
10701  @param[in] depth the depth of the recursion during parsing
10702 
10703  @param[in] event an event of type parse_event_t indicating the context in
10704  the callback function has been called
10705 
10706  @param[in,out] parsed the current intermediate parse result; note that
10707  writing to this value has no effect for parse_event_t::key events
10708 
10709  @return Whether the JSON value which called the function during parsing
10710  should be kept (`true`) or not (`false`). In the latter case, it is either
10711  skipped completely or replaced by an empty discarded object.
10712 
10713  @sa @ref parse for examples
10714 
10715  @since version 1.0.0
10716  */
10717  using parser_callback_t = typename parser::parser_callback_t;
10718 
10719 
10720  //////////////////
10721  // constructors //
10722  //////////////////
10723 
10724  /// @name constructors and destructors
10725  /// Constructors of class @ref basic_json, copy/move constructor, copy
10726  /// assignment, static functions creating objects, and the destructor.
10727  /// @{
10728 
10729  /*!
10730  @brief create an empty value with a given type
10731 
10732  Create an empty JSON value with a given type. The value will be default
10733  initialized with an empty value which depends on the type:
10734 
10735  Value type | initial value
10736  ----------- | -------------
10737  null | `null`
10738  boolean | `false`
10739  string | `""`
10740  number | `0`
10741  object | `{}`
10742  array | `[]`
10743 
10744  @param[in] v the type of the value to create
10745 
10746  @complexity Constant.
10747 
10748  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
10749  changes to any JSON value.
10750 
10751  @liveexample{The following code shows the constructor for different @ref
10752  value_t values,basic_json__value_t}
10753 
10754  @sa @ref clear() -- restores the postcondition of this constructor
10755 
10756  @since version 1.0.0
10757  */
10758  basic_json(const value_t v)
10759  : m_type(v), m_value(v)
10760  {
10761  assert_invariant();
10762  }
10764  /*!
10765  @brief create a null object
10766 
10767  Create a `null` JSON value. It either takes a null pointer as parameter
10768  (explicitly creating `null`) or no parameter (implicitly creating `null`).
10769  The passed null pointer itself is not read -- it is only used to choose
10770  the right constructor.
10771 
10772  @complexity Constant.
10773 
10774  @exceptionsafety No-throw guarantee: this constructor never throws
10775  exceptions.
10776 
10777  @liveexample{The following code shows the constructor with and without a
10778  null pointer parameter.,basic_json__nullptr_t}
10779 
10780  @since version 1.0.0
10781  */
10782  basic_json(std::nullptr_t = nullptr) noexcept
10783  : basic_json(value_t::null)
10784  {
10785  assert_invariant();
10786  }
10788  /*!
10789  @brief create a JSON value
10790 
10791  This is a "catch all" constructor for all compatible JSON types; that is,
10792  types for which a `to_json()` method exists. The constructor forwards the
10793  parameter @a val to that method (to `json_serializer<U>::to_json` method
10794  with `U = uncvref_t<CompatibleType>`, to be exact).
10795 
10796  Template type @a CompatibleType includes, but is not limited to, the
10797  following types:
10798  - **arrays**: @ref array_t and all kinds of compatible containers such as
10799  `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
10800  `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
10801  `std::multiset`, and `std::unordered_multiset` with a `value_type` from
10802  which a @ref basic_json value can be constructed.
10803  - **objects**: @ref object_t and all kinds of compatible associative
10804  containers such as `std::map`, `std::unordered_map`, `std::multimap`,
10805  and `std::unordered_multimap` with a `key_type` compatible to
10806  @ref string_t and a `value_type` from which a @ref basic_json value can
10807  be constructed.
10808  - **strings**: @ref string_t, string literals, and all compatible string
10809  containers can be used.
10810  - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
10811  @ref number_float_t, and all convertible number types such as `int`,
10812  `size_t`, `int64_t`, `float` or `double` can be used.
10813  - **boolean**: @ref boolean_t / `bool` can be used.
10814 
10815  See the examples below.
10816 
10817  @tparam CompatibleType a type such that:
10818  - @a CompatibleType is not derived from `std::istream`,
10819  - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
10820  constructors),
10821  - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
10822  - @a CompatibleType is not a @ref basic_json nested type (e.g.,
10823  @ref json_pointer, @ref iterator, etc ...)
10824  - @ref @ref json_serializer<U> has a
10825  `to_json(basic_json_t&, CompatibleType&&)` method
10826 
10827  @tparam U = `uncvref_t<CompatibleType>`
10828 
10829  @param[in] val the value to be forwarded to the respective constructor
10830 
10831  @complexity Usually linear in the size of the passed @a val, also
10832  depending on the implementation of the called `to_json()`
10833  method.
10834 
10835  @exceptionsafety Depends on the called constructor. For types directly
10836  supported by the library (i.e., all types for which no `to_json()` function
10837  was provided), strong guarantee holds: if an exception is thrown, there are
10838  no changes to any JSON value.
10839 
10840  @liveexample{The following code shows the constructor with several
10841  compatible types.,basic_json__CompatibleType}
10842 
10843  @since version 2.1.0
10844  */
10845  template <typename CompatibleType,
10846  typename U = detail::uncvref_t<CompatibleType>,
10847  detail::enable_if_t<
10848  detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
10849  basic_json(CompatibleType && val) noexcept(noexcept(
10850  JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
10851  std::forward<CompatibleType>(val))))
10852  {
10853  JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
10854  assert_invariant();
10855  }
10856 
10857  /*!
10858  @brief create a JSON value from an existing one
10859 
10860  This is a constructor for existing @ref basic_json types.
10861  It does not hijack copy/move constructors, since the parameter has different
10862  template arguments than the current ones.
10863 
10864  The constructor tries to convert the internal @ref m_value of the parameter.
10865 
10866  @tparam BasicJsonType a type such that:
10867  - @a BasicJsonType is a @ref basic_json type.
10868  - @a BasicJsonType has different template arguments than @ref basic_json_t.
10869 
10870  @param[in] val the @ref basic_json value to be converted.
10871 
10872  @complexity Usually linear in the size of the passed @a val, also
10873  depending on the implementation of the called `to_json()`
10874  method.
10875 
10876  @exceptionsafety Depends on the called constructor. For types directly
10877  supported by the library (i.e., all types for which no `to_json()` function
10878  was provided), strong guarantee holds: if an exception is thrown, there are
10879  no changes to any JSON value.
10880 
10881  @since version 3.1.2
10882  */
10883  template <typename BasicJsonType,
10884  detail::enable_if_t<
10885  detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>
10886  basic_json(const BasicJsonType& val)
10887  {
10888  using other_boolean_t = typename BasicJsonType::boolean_t;
10889  using other_number_float_t = typename BasicJsonType::number_float_t;
10890  using other_number_integer_t = typename BasicJsonType::number_integer_t;
10891  using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
10892  using other_string_t = typename BasicJsonType::string_t;
10893  using other_object_t = typename BasicJsonType::object_t;
10894  using other_array_t = typename BasicJsonType::array_t;
10895 
10896  switch (val.type())
10897  {
10898  case value_t::boolean:
10899  JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
10900  break;
10901  case value_t::number_float:
10902  JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
10903  break;
10904  case value_t::number_integer:
10905  JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
10906  break;
10907  case value_t::number_unsigned:
10908  JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
10909  break;
10910  case value_t::string:
10911  JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
10912  break;
10913  case value_t::object:
10914  JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
10915  break;
10916  case value_t::array:
10917  JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
10918  break;
10919  case value_t::null:
10920  *this = nullptr;
10921  break;
10922  case value_t::discarded:
10923  m_type = value_t::discarded;
10924  break;
10925  }
10926  assert_invariant();
10927  }
10928 
10929  /*!
10930  @brief create a container (array or object) from an initializer list
10931 
10932  Creates a JSON value of type array or object from the passed initializer
10933  list @a init. In case @a type_deduction is `true` (default), the type of
10934  the JSON value to be created is deducted from the initializer list @a init
10935  according to the following rules:
10936 
10937  1. If the list is empty, an empty JSON object value `{}` is created.
10938  2. If the list consists of pairs whose first element is a string, a JSON
10939  object value is created where the first elements of the pairs are
10940  treated as keys and the second elements are as values.
10941  3. In all other cases, an array is created.
10942 
10943  The rules aim to create the best fit between a C++ initializer list and
10944  JSON values. The rationale is as follows:
10945 
10946  1. The empty initializer list is written as `{}` which is exactly an empty
10947  JSON object.
10948  2. C++ has no way of describing mapped types other than to list a list of
10949  pairs. As JSON requires that keys must be of type string, rule 2 is the
10950  weakest constraint one can pose on initializer lists to interpret them
10951  as an object.
10952  3. In all other cases, the initializer list could not be interpreted as
10953  JSON object type, so interpreting it as JSON array type is safe.
10954 
10955  With the rules described above, the following JSON values cannot be
10956  expressed by an initializer list:
10957 
10958  - the empty array (`[]`): use @ref array(initializer_list_t)
10959  with an empty initializer list in this case
10960  - arrays whose elements satisfy rule 2: use @ref
10961  array(initializer_list_t) with the same initializer list
10962  in this case
10963 
10964  @note When used without parentheses around an empty initializer list, @ref
10965  basic_json() is called instead of this function, yielding the JSON null
10966  value.
10967 
10968  @param[in] init initializer list with JSON values
10969 
10970  @param[in] type_deduction internal parameter; when set to `true`, the type
10971  of the JSON value is deducted from the initializer list @a init; when set
10972  to `false`, the type provided via @a manual_type is forced. This mode is
10973  used by the functions @ref array(initializer_list_t) and
10974  @ref object(initializer_list_t).
10975 
10976  @param[in] manual_type internal parameter; when @a type_deduction is set
10977  to `false`, the created JSON value will use the provided type (only @ref
10978  value_t::array and @ref value_t::object are valid); when @a type_deduction
10979  is set to `true`, this parameter has no effect
10980 
10981  @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
10982  `value_t::object`, but @a init contains an element which is not a pair
10983  whose first element is a string. In this case, the constructor could not
10984  create an object. If @a type_deduction would have be `true`, an array
10985  would have been created. See @ref object(initializer_list_t)
10986  for an example.
10987 
10988  @complexity Linear in the size of the initializer list @a init.
10989 
10990  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
10991  changes to any JSON value.
10992 
10993  @liveexample{The example below shows how JSON values are created from
10994  initializer lists.,basic_json__list_init_t}
10995 
10996  @sa @ref array(initializer_list_t) -- create a JSON array
10997  value from an initializer list
10998  @sa @ref object(initializer_list_t) -- create a JSON object
10999  value from an initializer list
11000 
11001  @since version 1.0.0
11002  */
11003  basic_json(initializer_list_t init,
11004  bool type_deduction = true,
11005  value_t manual_type = value_t::array)
11006  {
11007  // check if each element is an array with two elements whose first
11008  // element is a string
11009  bool is_an_object = std::all_of(init.begin(), init.end(),
11010  [](const detail::json_ref<basic_json>& element_ref)
11011  {
11012  return (element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string());
11013  });
11014 
11015  // adjust type if type deduction is not wanted
11016  if (not type_deduction)
11017  {
11018  // if array is wanted, do not create an object though possible
11019  if (manual_type == value_t::array)
11020  {
11021  is_an_object = false;
11022  }
11023 
11024  // if object is wanted but impossible, throw an exception
11025  if (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object))
11026  {
11027  JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
11028  }
11029  }
11030 
11031  if (is_an_object)
11032  {
11033  // the initializer list is a list of pairs -> create object
11034  m_type = value_t::object;
11035  m_value = value_t::object;
11036 
11037  std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
11038  {
11039  auto element = element_ref.moved_or_copied();
11040  m_value.object->emplace(
11041  std::move(*((*element.m_value.array)[0].m_value.string)),
11042  std::move((*element.m_value.array)[1]));
11043  });
11044  }
11045  else
11046  {
11047  // the initializer list describes an array -> create array
11048  m_type = value_t::array;
11049  m_value.array = create<array_t>(init.begin(), init.end());
11050  }
11051 
11052  assert_invariant();
11053  }
11054 
11055  /*!
11056  @brief explicitly create an array from an initializer list
11057 
11058  Creates a JSON array value from a given initializer list. That is, given a
11059  list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
11060  initializer list is empty, the empty array `[]` is created.
11061 
11062  @note This function is only needed to express two edge cases that cannot
11063  be realized with the initializer list constructor (@ref
11064  basic_json(initializer_list_t, bool, value_t)). These cases
11065  are:
11066  1. creating an array whose elements are all pairs whose first element is a
11067  string -- in this case, the initializer list constructor would create an
11068  object, taking the first elements as keys
11069  2. creating an empty array -- passing the empty initializer list to the
11070  initializer list constructor yields an empty object
11071 
11072  @param[in] init initializer list with JSON values to create an array from
11073  (optional)
11074 
11075  @return JSON array value
11076 
11077  @complexity Linear in the size of @a init.
11078 
11079  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
11080  changes to any JSON value.
11081 
11082  @liveexample{The following code shows an example for the `array`
11083  function.,array}
11084 
11085  @sa @ref basic_json(initializer_list_t, bool, value_t) --
11086  create a JSON value from an initializer list
11087  @sa @ref object(initializer_list_t) -- create a JSON object
11088  value from an initializer list
11089 
11090  @since version 1.0.0
11091  */
11092  static basic_json array(initializer_list_t init = {})
11093  {
11094  return basic_json(init, false, value_t::array);
11095  }
11096 
11097  /*!
11098  @brief explicitly create an object from an initializer list
11099 
11100  Creates a JSON object value from a given initializer list. The initializer
11101  lists elements must be pairs, and their first elements must be strings. If
11102  the initializer list is empty, the empty object `{}` is created.
11103 
11104  @note This function is only added for symmetry reasons. In contrast to the
11105  related function @ref array(initializer_list_t), there are
11106  no cases which can only be expressed by this function. That is, any
11107  initializer list @a init can also be passed to the initializer list
11108  constructor @ref basic_json(initializer_list_t, bool, value_t).
11109 
11110  @param[in] init initializer list to create an object from (optional)
11111 
11112  @return JSON object value
11113 
11114  @throw type_error.301 if @a init is not a list of pairs whose first
11115  elements are strings. In this case, no object can be created. When such a
11116  value is passed to @ref basic_json(initializer_list_t, bool, value_t),
11117  an array would have been created from the passed initializer list @a init.
11118  See example below.
11119 
11120  @complexity Linear in the size of @a init.
11121 
11122  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
11123  changes to any JSON value.
11124 
11125  @liveexample{The following code shows an example for the `object`
11126  function.,object}
11127 
11128  @sa @ref basic_json(initializer_list_t, bool, value_t) --
11129  create a JSON value from an initializer list
11130  @sa @ref array(initializer_list_t) -- create a JSON array
11131  value from an initializer list
11132 
11133  @since version 1.0.0
11134  */
11135  static basic_json object(initializer_list_t init = {})
11136  {
11137  return basic_json(init, false, value_t::object);
11138  }
11139 
11140  /*!
11141  @brief construct an array with count copies of given value
11142 
11143  Constructs a JSON array value by creating @a cnt copies of a passed value.
11144  In case @a cnt is `0`, an empty array is created.
11145 
11146  @param[in] cnt the number of JSON copies of @a val to create
11147  @param[in] val the JSON value to copy
11148 
11149  @post `std::distance(begin(),end()) == cnt` holds.
11150 
11151  @complexity Linear in @a cnt.
11152 
11153  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
11154  changes to any JSON value.
11155 
11156  @liveexample{The following code shows examples for the @ref
11157  basic_json(size_type\, const basic_json&)
11158  constructor.,basic_json__size_type_basic_json}
11159 
11160  @since version 1.0.0
11161  */
11162  basic_json(size_type cnt, const basic_json& val)
11163  : m_type(value_t::array)
11164  {
11165  m_value.array = create<array_t>(cnt, val);
11166  assert_invariant();
11167  }
11168 
11169  /*!
11170  @brief construct a JSON container given an iterator range
11171 
11172  Constructs the JSON value with the contents of the range `[first, last)`.
11173  The semantics depends on the different types a JSON value can have:
11174  - In case of a null type, invalid_iterator.206 is thrown.
11175  - In case of other primitive types (number, boolean, or string), @a first
11176  must be `begin()` and @a last must be `end()`. In this case, the value is
11177  copied. Otherwise, invalid_iterator.204 is thrown.
11178  - In case of structured types (array, object), the constructor behaves as
11179  similar versions for `std::vector` or `std::map`; that is, a JSON array
11180  or object is constructed from the values in the range.
11181 
11182  @tparam InputIT an input iterator type (@ref iterator or @ref
11183  const_iterator)
11184 
11185  @param[in] first begin of the range to copy from (included)
11186  @param[in] last end of the range to copy from (excluded)
11187 
11188  @pre Iterators @a first and @a last must be initialized. **This
11189  precondition is enforced with an assertion (see warning).** If
11190  assertions are switched off, a violation of this precondition yields
11191  undefined behavior.
11192 
11193  @pre Range `[first, last)` is valid. Usually, this precondition cannot be
11194  checked efficiently. Only certain edge cases are detected; see the
11195  description of the exceptions below. A violation of this precondition
11196  yields undefined behavior.
11197 
11198  @warning A precondition is enforced with a runtime assertion that will
11199  result in calling `std::abort` if this precondition is not met.
11200  Assertions can be disabled by defining `NDEBUG` at compile time.
11201  See http://en.cppreference.com/w/cpp/error/assert for more
11202  information.
11203 
11204  @throw invalid_iterator.201 if iterators @a first and @a last are not
11205  compatible (i.e., do not belong to the same JSON value). In this case,
11206  the range `[first, last)` is undefined.
11207  @throw invalid_iterator.204 if iterators @a first and @a last belong to a
11208  primitive type (number, boolean, or string), but @a first does not point
11209  to the first element any more. In this case, the range `[first, last)` is
11210  undefined. See example code below.
11211  @throw invalid_iterator.206 if iterators @a first and @a last belong to a
11212  null value. In this case, the range `[first, last)` is undefined.
11213 
11214  @complexity Linear in distance between @a first and @a last.
11215 
11216  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
11217  changes to any JSON value.
11218 
11219  @liveexample{The example below shows several ways to create JSON values by
11220  specifying a subrange with iterators.,basic_json__InputIt_InputIt}
11221 
11222  @since version 1.0.0
11223  */
11224  template<class InputIT, typename std::enable_if<
11225  std::is_same<InputIT, typename basic_json_t::iterator>::value or
11226  std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
11227  basic_json(InputIT first, InputIT last)
11228  {
11229  assert(first.m_object != nullptr);
11230  assert(last.m_object != nullptr);
11231 
11232  // make sure iterator fits the current value
11233  if (JSON_UNLIKELY(first.m_object != last.m_object))
11234  {
11235  JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
11236  }
11237 
11238  // copy type from first iterator
11239  m_type = first.m_object->m_type;
11240 
11241  // check if iterator range is complete for primitive values
11242  switch (m_type)
11243  {
11244  case value_t::boolean:
11245  case value_t::number_float:
11246  case value_t::number_integer:
11247  case value_t::number_unsigned:
11248  case value_t::string:
11249  {
11250  if (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
11251  or not last.m_it.primitive_iterator.is_end()))
11252  {
11253  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
11254  }
11255  break;
11256  }
11257 
11258  default:
11259  break;
11260  }
11261 
11262  switch (m_type)
11263  {
11264  case value_t::number_integer:
11265  {
11266  m_value.number_integer = first.m_object->m_value.number_integer;
11267  break;
11268  }
11269 
11270  case value_t::number_unsigned:
11271  {
11272  m_value.number_unsigned = first.m_object->m_value.number_unsigned;
11273  break;
11274  }
11275 
11276  case value_t::number_float:
11277  {
11278  m_value.number_float = first.m_object->m_value.number_float;
11279  break;
11280  }
11281 
11282  case value_t::boolean:
11283  {
11284  m_value.boolean = first.m_object->m_value.boolean;
11285  break;
11286  }
11287 
11288  case value_t::string:
11289  {
11290  m_value = *first.m_object->m_value.string;
11291  break;
11292  }
11293 
11294  case value_t::object:
11295  {
11296  m_value.object = create<object_t>(first.m_it.object_iterator,
11297  last.m_it.object_iterator);
11298  break;
11299  }
11300 
11301  case value_t::array:
11302  {
11303  m_value.array = create<array_t>(first.m_it.array_iterator,
11304  last.m_it.array_iterator);
11305  break;
11306  }
11307 
11308  default:
11309  JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
11310  std::string(first.m_object->type_name())));
11311  }
11312 
11313  assert_invariant();
11314  }
11315 
11316 
11317  ///////////////////////////////////////
11318  // other constructors and destructor //
11319  ///////////////////////////////////////
11320 
11321  /// @private
11322  basic_json(const detail::json_ref<basic_json>& ref)
11323  : basic_json(ref.moved_or_copied())
11324  {}
11325 
11326  /*!
11327  @brief copy constructor
11328 
11329  Creates a copy of a given JSON value.
11330 
11331  @param[in] other the JSON value to copy
11332 
11333  @post `*this == other`
11334 
11335  @complexity Linear in the size of @a other.
11336 
11337  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
11338  changes to any JSON value.
11339 
11340  @requirement This function helps `basic_json` satisfying the
11341  [Container](http://en.cppreference.com/w/cpp/concept/Container)
11342  requirements:
11343  - The complexity is linear.
11344  - As postcondition, it holds: `other == basic_json(other)`.
11345 
11346  @liveexample{The following code shows an example for the copy
11347  constructor.,basic_json__basic_json}
11348 
11349  @since version 1.0.0
11350  */
11351  basic_json(const basic_json& other)
11352  : m_type(other.m_type)
11353  {
11354  // check of passed value is valid
11355  other.assert_invariant();
11357  switch (m_type)
11358  {
11359  case value_t::object:
11360  {
11361  m_value = *other.m_value.object;
11362  break;
11363  }
11364 
11365  case value_t::array:
11366  {
11367  m_value = *other.m_value.array;
11368  break;
11369  }
11370 
11371  case value_t::string:
11372  {
11373  m_value = *other.m_value.string;
11374  break;
11375  }
11376 
11377  case value_t::boolean:
11378  {
11379  m_value = other.m_value.boolean;
11380  break;
11381  }
11382 
11383  case value_t::number_integer:
11384  {
11385  m_value = other.m_value.number_integer;
11386  break;
11387  }
11388 
11389  case value_t::number_unsigned:
11390  {
11391  m_value = other.m_value.number_unsigned;
11392  break;
11393  }
11394 
11395  case value_t::number_float:
11396  {
11397  m_value = other.m_value.number_float;
11398  break;
11399  }
11400 
11401  default:
11402  break;
11403  }
11404 
11405  assert_invariant();
11406  }
11407 
11408  /*!
11409  @brief move constructor
11410 
11411  Move constructor. Constructs a JSON value with the contents of the given
11412  value @a other using move semantics. It "steals" the resources from @a
11413  other and leaves it as JSON null value.
11414 
11415  @param[in,out] other value to move to this object
11416 
11417  @post `*this` has the same value as @a other before the call.
11418  @post @a other is a JSON null value.
11419 
11420  @complexity Constant.
11421 
11422  @exceptionsafety No-throw guarantee: this constructor never throws
11423  exceptions.
11424 
11425  @requirement This function helps `basic_json` satisfying the
11426  [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible)
11427  requirements.
11428 
11429  @liveexample{The code below shows the move constructor explicitly called
11430  via std::move.,basic_json__moveconstructor}
11431 
11432  @since version 1.0.0
11433  */
11434  basic_json(basic_json&& other) noexcept
11435  : m_type(std::move(other.m_type)),
11436  m_value(std::move(other.m_value))
11437  {
11438  // check that passed value is valid
11439  other.assert_invariant();
11440 
11441  // invalidate payload
11442  other.m_type = value_t::null;
11443  other.m_value = {};
11444 
11445  assert_invariant();
11446  }
11447 
11448  /*!
11449  @brief copy assignment
11450 
11451  Copy assignment operator. Copies a JSON value via the "copy and swap"
11452  strategy: It is expressed in terms of the copy constructor, destructor,
11453  and the `swap()` member function.
11454 
11455  @param[in] other value to copy from
11456 
11457  @complexity Linear.
11458 
11459  @requirement This function helps `basic_json` satisfying the
11460  [Container](http://en.cppreference.com/w/cpp/concept/Container)
11461  requirements:
11462  - The complexity is linear.
11463 
11464  @liveexample{The code below shows and example for the copy assignment. It
11465  creates a copy of value `a` which is then swapped with `b`. Finally\, the
11466  copy of `a` (which is the null value after the swap) is
11467  destroyed.,basic_json__copyassignment}
11468 
11469  @since version 1.0.0
11470  */
11471  reference& operator=(basic_json other) noexcept (
11472  std::is_nothrow_move_constructible<value_t>::value and
11473  std::is_nothrow_move_assignable<value_t>::value and
11474  std::is_nothrow_move_constructible<json_value>::value and
11475  std::is_nothrow_move_assignable<json_value>::value
11476  )
11477  {
11478  // check that passed value is valid
11479  other.assert_invariant();
11480 
11481  using std::swap;
11482  swap(m_type, other.m_type);
11483  swap(m_value, other.m_value);
11484 
11485  assert_invariant();
11486  return *this;
11487  }
11488 
11489  /*!
11490  @brief destructor
11491 
11492  Destroys the JSON value and frees all allocated memory.
11493 
11494  @complexity Linear.
11495 
11496  @requirement This function helps `basic_json` satisfying the
11497  [Container](http://en.cppreference.com/w/cpp/concept/Container)
11498  requirements:
11499  - The complexity is linear.
11500  - All stored elements are destroyed and all memory is freed.
11501 
11502  @since version 1.0.0
11503  */
11504  ~basic_json() noexcept
11505  {
11506  assert_invariant();
11507  m_value.destroy(m_type);
11508  }
11510  /// @}
11511 
11512  public:
11513  ///////////////////////
11514  // object inspection //
11515  ///////////////////////
11516 
11517  /// @name object inspection
11518  /// Functions to inspect the type of a JSON value.
11519  /// @{
11520 
11521  /*!
11522  @brief serialization
11523 
11524  Serialization function for JSON values. The function tries to mimic
11525  Python's `json.dumps()` function, and currently supports its @a indent
11526  and @a ensure_ascii parameters.
11527 
11528  @param[in] indent If indent is nonnegative, then array elements and object
11529  members will be pretty-printed with that indent level. An indent level of
11530  `0` will only insert newlines. `-1` (the default) selects the most compact
11531  representation.
11532  @param[in] indent_char The character to use for indentation if @a indent is
11533  greater than `0`. The default is ` ` (space).
11534  @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
11535  in the output are escaped with `\uXXXX` sequences, and the result consists
11536  of ASCII characters only.
11537 
11538  @return string containing the serialization of the JSON value
11539 
11540  @throw type_error.316 if a string stored inside the JSON value is not
11541  UTF-8 encoded
11542 
11543  @complexity Linear.
11544 
11545  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
11546  changes in the JSON value.
11547 
11548  @liveexample{The following example shows the effect of different @a indent\,
11549  @a indent_char\, and @a ensure_ascii parameters to the result of the
11550  serialization.,dump}
11551 
11552  @see https://docs.python.org/2/library/json.html#json.dump
11553 
11554  @since version 1.0.0; indentation character @a indent_char, option
11555  @a ensure_ascii and exceptions added in version 3.0.0
11556  */
11557  string_t dump(const int indent = -1, const char indent_char = ' ',
11558  const bool ensure_ascii = false) const
11559  {
11560  string_t result;
11561  serializer s(detail::output_adapter<char, string_t>(result), indent_char);
11563  if (indent >= 0)
11564  {
11565  s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
11566  }
11567  else
11568  {
11569  s.dump(*this, false, ensure_ascii, 0);
11570  }
11571 
11572  return result;
11573  }
11574 
11575  /*!
11576  @brief return the type of the JSON value (explicit)
11577 
11578  Return the type of the JSON value as a value from the @ref value_t
11579  enumeration.
11580 
11581  @return the type of the JSON value
11582  Value type | return value
11583  ------------------------- | -------------------------
11584  null | value_t::null
11585  boolean | value_t::boolean
11586  string | value_t::string
11587  number (integer) | value_t::number_integer
11588  number (unsigned integer) | value_t::number_unsigned
11589  number (floating-point) | value_t::number_float
11590  object | value_t::object
11591  array | value_t::array
11592  discarded | value_t::discarded
11593 
11594  @complexity Constant.
11595 
11596  @exceptionsafety No-throw guarantee: this member function never throws
11597  exceptions.
11598 
11599  @liveexample{The following code exemplifies `type()` for all JSON
11600  types.,type}
11601 
11602  @sa @ref operator value_t() -- return the type of the JSON value (implicit)
11603  @sa @ref type_name() -- return the type as string
11604 
11605  @since version 1.0.0
11606  */
11607  constexpr value_t type() const noexcept
11608  {
11609  return m_type;
11610  }
11611 
11612  /*!
11613  @brief return whether type is primitive
11614 
11615  This function returns true if and only if the JSON type is primitive
11616  (string, number, boolean, or null).
11617 
11618  @return `true` if type is primitive (string, number, boolean, or null),
11619  `false` otherwise.
11620 
11621  @complexity Constant.
11622 
11623  @exceptionsafety No-throw guarantee: this member function never throws
11624  exceptions.
11625 
11626  @liveexample{The following code exemplifies `is_primitive()` for all JSON
11627  types.,is_primitive}
11628 
11629  @sa @ref is_structured() -- returns whether JSON value is structured
11630  @sa @ref is_null() -- returns whether JSON value is `null`
11631  @sa @ref is_string() -- returns whether JSON value is a string
11632  @sa @ref is_boolean() -- returns whether JSON value is a boolean
11633  @sa @ref is_number() -- returns whether JSON value is a number
11634 
11635  @since version 1.0.0
11636  */
11637  constexpr bool is_primitive() const noexcept
11638  {
11639  return is_null() or is_string() or is_boolean() or is_number();
11640  }
11641 
11642  /*!
11643  @brief return whether type is structured
11644 
11645  This function returns true if and only if the JSON type is structured
11646  (array or object).
11647 
11648  @return `true` if type is structured (array or object), `false` otherwise.
11649 
11650  @complexity Constant.
11651 
11652  @exceptionsafety No-throw guarantee: this member function never throws
11653  exceptions.
11654 
11655  @liveexample{The following code exemplifies `is_structured()` for all JSON
11656  types.,is_structured}
11657 
11658  @sa @ref is_primitive() -- returns whether value is primitive
11659  @sa @ref is_array() -- returns whether value is an array
11660  @sa @ref is_object() -- returns whether value is an object
11661 
11662  @since version 1.0.0
11663  */
11664  constexpr bool is_structured() const noexcept
11665  {
11666  return is_array() or is_object();
11667  }
11668 
11669  /*!
11670  @brief return whether value is null
11671 
11672  This function returns true if and only if the JSON value is null.
11673 
11674  @return `true` if type is null, `false` otherwise.
11675 
11676  @complexity Constant.
11677 
11678  @exceptionsafety No-throw guarantee: this member function never throws
11679  exceptions.
11680 
11681  @liveexample{The following code exemplifies `is_null()` for all JSON
11682  types.,is_null}
11683 
11684  @since version 1.0.0
11685  */
11686  constexpr bool is_null() const noexcept
11687  {
11688  return (m_type == value_t::null);
11689  }
11690 
11691  /*!
11692  @brief return whether value is a boolean
11693 
11694  This function returns true if and only if the JSON value is a boolean.
11695 
11696  @return `true` if type is boolean, `false` otherwise.
11697 
11698  @complexity Constant.
11699 
11700  @exceptionsafety No-throw guarantee: this member function never throws
11701  exceptions.
11702 
11703  @liveexample{The following code exemplifies `is_boolean()` for all JSON
11704  types.,is_boolean}
11705 
11706  @since version 1.0.0
11707  */
11708  constexpr bool is_boolean() const noexcept
11709  {
11710  return (m_type == value_t::boolean);
11711  }
11712 
11713  /*!
11714  @brief return whether value is a number
11715 
11716  This function returns true if and only if the JSON value is a number. This
11717  includes both integer (signed and unsigned) and floating-point values.
11718 
11719  @return `true` if type is number (regardless whether integer, unsigned
11720  integer or floating-type), `false` otherwise.
11721 
11722  @complexity Constant.
11723 
11724  @exceptionsafety No-throw guarantee: this member function never throws
11725  exceptions.
11726 
11727  @liveexample{The following code exemplifies `is_number()` for all JSON
11728  types.,is_number}
11729 
11730  @sa @ref is_number_integer() -- check if value is an integer or unsigned
11731  integer number
11732  @sa @ref is_number_unsigned() -- check if value is an unsigned integer
11733  number
11734  @sa @ref is_number_float() -- check if value is a floating-point number
11735 
11736  @since version 1.0.0
11737  */
11738  constexpr bool is_number() const noexcept
11739  {
11740  return is_number_integer() or is_number_float();
11741  }
11742 
11743  /*!
11744  @brief return whether value is an integer number
11745 
11746  This function returns true if and only if the JSON value is a signed or
11747  unsigned integer number. This excludes floating-point values.
11748 
11749  @return `true` if type is an integer or unsigned integer number, `false`
11750  otherwise.
11751 
11752  @complexity Constant.
11753 
11754  @exceptionsafety No-throw guarantee: this member function never throws
11755  exceptions.
11756 
11757  @liveexample{The following code exemplifies `is_number_integer()` for all
11758  JSON types.,is_number_integer}
11759 
11760  @sa @ref is_number() -- check if value is a number
11761  @sa @ref is_number_unsigned() -- check if value is an unsigned integer
11762  number
11763  @sa @ref is_number_float() -- check if value is a floating-point number
11764 
11765  @since version 1.0.0
11766  */
11767  constexpr bool is_number_integer() const noexcept
11768  {
11769  return (m_type == value_t::number_integer or m_type == value_t::number_unsigned);
11770  }
11771 
11772  /*!
11773  @brief return whether value is an unsigned integer number
11774 
11775  This function returns true if and only if the JSON value is an unsigned
11776  integer number. This excludes floating-point and signed integer values.
11777 
11778  @return `true` if type is an unsigned integer number, `false` otherwise.
11779 
11780  @complexity Constant.
11781 
11782  @exceptionsafety No-throw guarantee: this member function never throws
11783  exceptions.
11784 
11785  @liveexample{The following code exemplifies `is_number_unsigned()` for all
11786  JSON types.,is_number_unsigned}
11787 
11788  @sa @ref is_number() -- check if value is a number
11789  @sa @ref is_number_integer() -- check if value is an integer or unsigned
11790  integer number
11791  @sa @ref is_number_float() -- check if value is a floating-point number
11792 
11793  @since version 2.0.0
11794  */
11795  constexpr bool is_number_unsigned() const noexcept
11796  {
11797  return (m_type == value_t::number_unsigned);
11798  }
11799 
11800  /*!
11801  @brief return whether value is a floating-point number
11802 
11803  This function returns true if and only if the JSON value is a
11804  floating-point number. This excludes signed and unsigned integer values.
11805 
11806  @return `true` if type is a floating-point number, `false` otherwise.
11807 
11808  @complexity Constant.
11809 
11810  @exceptionsafety No-throw guarantee: this member function never throws
11811  exceptions.
11812 
11813  @liveexample{The following code exemplifies `is_number_float()` for all
11814  JSON types.,is_number_float}
11815 
11816  @sa @ref is_number() -- check if value is number
11817  @sa @ref is_number_integer() -- check if value is an integer number
11818  @sa @ref is_number_unsigned() -- check if value is an unsigned integer
11819  number
11820 
11821  @since version 1.0.0
11822  */
11823  constexpr bool is_number_float() const noexcept
11824  {
11825  return (m_type == value_t::number_float);
11826  }
11827 
11828  /*!
11829  @brief return whether value is an object
11830 
11831  This function returns true if and only if the JSON value is an object.
11832 
11833  @return `true` if type is object, `false` otherwise.
11834 
11835  @complexity Constant.
11836 
11837  @exceptionsafety No-throw guarantee: this member function never throws
11838  exceptions.
11839 
11840  @liveexample{The following code exemplifies `is_object()` for all JSON
11841  types.,is_object}
11842 
11843  @since version 1.0.0
11844  */
11845  constexpr bool is_object() const noexcept
11846  {
11847  return (m_type == value_t::object);
11848  }
11849 
11850  /*!
11851  @brief return whether value is an array
11852 
11853  This function returns true if and only if the JSON value is an array.
11854 
11855  @return `true` if type is array, `false` otherwise.
11856 
11857  @complexity Constant.
11858 
11859  @exceptionsafety No-throw guarantee: this member function never throws
11860  exceptions.
11861 
11862  @liveexample{The following code exemplifies `is_array()` for all JSON
11863  types.,is_array}
11864 
11865  @since version 1.0.0
11866  */
11867  constexpr bool is_array() const noexcept
11868  {
11869  return (m_type == value_t::array);
11870  }
11871 
11872  /*!
11873  @brief return whether value is a string
11874 
11875  This function returns true if and only if the JSON value is a string.
11876 
11877  @return `true` if type is string, `false` otherwise.
11878 
11879  @complexity Constant.
11880 
11881  @exceptionsafety No-throw guarantee: this member function never throws
11882  exceptions.
11883 
11884  @liveexample{The following code exemplifies `is_string()` for all JSON
11885  types.,is_string}
11886 
11887  @since version 1.0.0
11888  */
11889  constexpr bool is_string() const noexcept
11890  {
11891  return (m_type == value_t::string);
11892  }
11893 
11894  /*!
11895  @brief return whether value is discarded
11896 
11897  This function returns true if and only if the JSON value was discarded
11898  during parsing with a callback function (see @ref parser_callback_t).
11899 
11900  @note This function will always be `false` for JSON values after parsing.
11901  That is, discarded values can only occur during parsing, but will be
11902  removed when inside a structured value or replaced by null in other cases.
11903 
11904  @return `true` if type is discarded, `false` otherwise.
11905 
11906  @complexity Constant.
11907 
11908  @exceptionsafety No-throw guarantee: this member function never throws
11909  exceptions.
11910 
11911  @liveexample{The following code exemplifies `is_discarded()` for all JSON
11912  types.,is_discarded}
11913 
11914  @since version 1.0.0
11915  */
11916  constexpr bool is_discarded() const noexcept
11917  {
11918  return (m_type == value_t::discarded);
11919  }
11920 
11921  /*!
11922  @brief return the type of the JSON value (implicit)
11923 
11924  Implicitly return the type of the JSON value as a value from the @ref
11925  value_t enumeration.
11926 
11927  @return the type of the JSON value
11928 
11929  @complexity Constant.
11930 
11931  @exceptionsafety No-throw guarantee: this member function never throws
11932  exceptions.
11933 
11934  @liveexample{The following code exemplifies the @ref value_t operator for
11935  all JSON types.,operator__value_t}
11936 
11937  @sa @ref type() -- return the type of the JSON value (explicit)
11938  @sa @ref type_name() -- return the type as string
11939 
11940  @since version 1.0.0
11941  */
11942  constexpr operator value_t() const noexcept
11943  {
11944  return m_type;
11945  }
11946 
11947  /// @}
11948 
11949  private:
11950  //////////////////
11951  // value access //
11952  //////////////////
11953 
11954  /// get a boolean (explicit)
11955  boolean_t get_impl(boolean_t* /*unused*/) const
11956  {
11957  if (JSON_LIKELY(is_boolean()))
11958  {
11959  return m_value.boolean;
11960  }
11961 
11962  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
11963  }
11964 
11965  /// get a pointer to the value (object)
11966  object_t* get_impl_ptr(object_t* /*unused*/) noexcept
11967  {
11968  return is_object() ? m_value.object : nullptr;
11969  }
11970 
11971  /// get a pointer to the value (object)
11972  constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
11973  {
11974  return is_object() ? m_value.object : nullptr;
11975  }
11976 
11977  /// get a pointer to the value (array)
11978  array_t* get_impl_ptr(array_t* /*unused*/) noexcept
11979  {
11980  return is_array() ? m_value.array : nullptr;
11981  }
11982 
11983  /// get a pointer to the value (array)
11984  constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
11985  {
11986  return is_array() ? m_value.array : nullptr;
11987  }
11988 
11989  /// get a pointer to the value (string)
11990  string_t* get_impl_ptr(string_t* /*unused*/) noexcept
11991  {
11992  return is_string() ? m_value.string : nullptr;
11993  }
11994 
11995  /// get a pointer to the value (string)
11996  constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
11997  {
11998  return is_string() ? m_value.string : nullptr;
11999  }
12000 
12001  /// get a pointer to the value (boolean)
12002  boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
12003  {
12004  return is_boolean() ? &m_value.boolean : nullptr;
12005  }
12006 
12007  /// get a pointer to the value (boolean)
12008  constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
12009  {
12010  return is_boolean() ? &m_value.boolean : nullptr;
12011  }
12012 
12013  /// get a pointer to the value (integer number)
12014  number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
12015  {
12016  return is_number_integer() ? &m_value.number_integer : nullptr;
12017  }
12018 
12019  /// get a pointer to the value (integer number)
12020  constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
12021  {
12022  return is_number_integer() ? &m_value.number_integer : nullptr;
12023  }
12024 
12025  /// get a pointer to the value (unsigned number)
12026  number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
12027  {
12028  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
12029  }
12030 
12031  /// get a pointer to the value (unsigned number)
12032  constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
12033  {
12034  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
12035  }
12036 
12037  /// get a pointer to the value (floating-point number)
12038  number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
12039  {
12040  return is_number_float() ? &m_value.number_float : nullptr;
12041  }
12042 
12043  /// get a pointer to the value (floating-point number)
12044  constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
12045  {
12046  return is_number_float() ? &m_value.number_float : nullptr;
12047  }
12048 
12049  /*!
12050  @brief helper function to implement get_ref()
12051 
12052  This function helps to implement get_ref() without code duplication for
12053  const and non-const overloads
12054 
12055  @tparam ThisType will be deduced as `basic_json` or `const basic_json`
12056 
12057  @throw type_error.303 if ReferenceType does not match underlying value
12058  type of the current JSON
12059  */
12060  template<typename ReferenceType, typename ThisType>
12061  static ReferenceType get_ref_impl(ThisType& obj)
12062  {
12063  // delegate the call to get_ptr<>()
12064  auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
12065 
12066  if (JSON_LIKELY(ptr != nullptr))
12067  {
12068  return *ptr;
12069  }
12070 
12071  JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
12072  }
12073 
12074  public:
12075  /// @name value access
12076  /// Direct access to the stored value of a JSON value.
12077  /// @{
12078 
12079  /*!
12080  @brief get special-case overload
12081 
12082  This overloads avoids a lot of template boilerplate, it can be seen as the
12083  identity method
12084 
12085  @tparam BasicJsonType == @ref basic_json
12086 
12087  @return a copy of *this
12088 
12089  @complexity Constant.
12090 
12091  @since version 2.1.0
12092  */
12093  template<typename BasicJsonType, detail::enable_if_t<
12094  std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
12095  int> = 0>
12096  basic_json get() const
12097  {
12098  return *this;
12099  }
12100 
12101  /*!
12102  @brief get special-case overload
12103 
12104  This overloads converts the current @ref basic_json in a different
12105  @ref basic_json type
12106 
12107  @tparam BasicJsonType == @ref basic_json
12108 
12109  @return a copy of *this, converted into @tparam BasicJsonType
12110 
12111  @complexity Depending on the implementation of the called `from_json()`
12112  method.
12113 
12114  @since version 3.1.2
12115  */
12116  template<typename BasicJsonType, detail::enable_if_t<
12117  not std::is_same<BasicJsonType, basic_json>::value and
12118  detail::is_basic_json<BasicJsonType>::value, int> = 0>
12119  BasicJsonType get() const
12120  {
12121  return *this;
12122  }
12123 
12124  /*!
12125  @brief get a value (explicit)
12126 
12127  Explicit type conversion between the JSON value and a compatible value
12128  which is [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)
12129  and [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).
12130  The value is converted by calling the @ref json_serializer<ValueType>
12131  `from_json()` method.
12132 
12133  The function is equivalent to executing
12134  @code {.cpp}
12135  ValueType ret;
12136  JSONSerializer<ValueType>::from_json(*this, ret);
12137  return ret;
12138  @endcode
12139 
12140  This overloads is chosen if:
12141  - @a ValueType is not @ref basic_json,
12142  - @ref json_serializer<ValueType> has a `from_json()` method of the form
12143  `void from_json(const basic_json&, ValueType&)`, and
12144  - @ref json_serializer<ValueType> does not have a `from_json()` method of
12145  the form `ValueType from_json(const basic_json&)`
12146 
12147  @tparam ValueTypeCV the provided value type
12148  @tparam ValueType the returned value type
12149 
12150  @return copy of the JSON value, converted to @a ValueType
12151 
12152  @throw what @ref json_serializer<ValueType> `from_json()` method throws
12153 
12154  @liveexample{The example below shows several conversions from JSON values
12155  to other types. There a few things to note: (1) Floating-point numbers can
12156  be converted to integers\, (2) A JSON array can be converted to a standard
12157  `std::vector<short>`\, (3) A JSON object can be converted to C++
12158  associative containers such as `std::unordered_map<std::string\,
12159  json>`.,get__ValueType_const}
12160 
12161  @since version 2.1.0
12162  */
12163  template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
12164  detail::enable_if_t <
12165  not detail::is_basic_json<ValueType>::value and
12166  detail::has_from_json<basic_json_t, ValueType>::value and
12167  not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
12168  int> = 0>
12169  ValueType get() const noexcept(noexcept(
12170  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
12171  {
12172  // we cannot static_assert on ValueTypeCV being non-const, because
12173  // there is support for get<const basic_json_t>(), which is why we
12174  // still need the uncvref
12175  static_assert(not std::is_reference<ValueTypeCV>::value,
12176  "get() cannot be used with reference types, you might want to use get_ref()");
12177  static_assert(std::is_default_constructible<ValueType>::value,
12178  "types must be DefaultConstructible when used with get()");
12179 
12180  ValueType ret;
12181  JSONSerializer<ValueType>::from_json(*this, ret);
12182  return ret;
12183  }
12184 
12185  /*!
12186  @brief get a value (explicit); special case
12187 
12188  Explicit type conversion between the JSON value and a compatible value
12189  which is **not** [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)
12190  and **not** [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).
12191  The value is converted by calling the @ref json_serializer<ValueType>
12192  `from_json()` method.
12193 
12194  The function is equivalent to executing
12195  @code {.cpp}
12196  return JSONSerializer<ValueTypeCV>::from_json(*this);
12197  @endcode
12198 
12199  This overloads is chosen if:
12200  - @a ValueType is not @ref basic_json and
12201  - @ref json_serializer<ValueType> has a `from_json()` method of the form
12202  `ValueType from_json(const basic_json&)`
12203 
12204  @note If @ref json_serializer<ValueType> has both overloads of
12205  `from_json()`, this one is chosen.
12206 
12207  @tparam ValueTypeCV the provided value type
12208  @tparam ValueType the returned value type
12209 
12210  @return copy of the JSON value, converted to @a ValueType
12211 
12212  @throw what @ref json_serializer<ValueType> `from_json()` method throws
12213 
12214  @since version 2.1.0
12215  */
12216  template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
12217  detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
12218  detail::has_non_default_from_json<basic_json_t, ValueType>::value,
12219  int> = 0>
12220  ValueType get() const noexcept(noexcept(
12221  JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
12222  {
12223  static_assert(not std::is_reference<ValueTypeCV>::value,
12224  "get() cannot be used with reference types, you might want to use get_ref()");
12225  return JSONSerializer<ValueTypeCV>::from_json(*this);
12226  }
12227 
12228  /*!
12229  @brief get a pointer value (explicit)
12230 
12231  Explicit pointer access to the internally stored JSON value. No copies are
12232  made.
12233 
12234  @warning The pointer becomes invalid if the underlying JSON object
12235  changes.
12236 
12237  @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
12238  object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
12239  @ref number_unsigned_t, or @ref number_float_t.
12240 
12241  @return pointer to the internally stored JSON value if the requested
12242  pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
12243 
12244  @complexity Constant.
12245 
12246  @liveexample{The example below shows how pointers to internal values of a
12247  JSON value can be requested. Note that no type conversions are made and a
12248  `nullptr` is returned if the value and the requested pointer type does not
12249  match.,get__PointerType}
12250 
12251  @sa @ref get_ptr() for explicit pointer-member access
12252 
12253  @since version 1.0.0
12254  */
12255  template<typename PointerType, typename std::enable_if<
12256  std::is_pointer<PointerType>::value, int>::type = 0>
12257  PointerType get() noexcept
12258  {
12259  // delegate the call to get_ptr
12260  return get_ptr<PointerType>();
12261  }
12263  /*!
12264  @brief get a pointer value (explicit)
12265  @copydoc get()
12266  */
12267  template<typename PointerType, typename std::enable_if<
12268  std::is_pointer<PointerType>::value, int>::type = 0>
12269  constexpr const PointerType get() const noexcept
12270  {
12271  // delegate the call to get_ptr
12272  return get_ptr<PointerType>();
12273  }
12275  /*!
12276  @brief get a pointer value (implicit)
12277 
12278  Implicit pointer access to the internally stored JSON value. No copies are
12279  made.
12280 
12281  @warning Writing data to the pointee of the result yields an undefined
12282  state.
12283 
12284  @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
12285  object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
12286  @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
12287  assertion.
12288 
12289  @return pointer to the internally stored JSON value if the requested
12290  pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
12291 
12292  @complexity Constant.
12293 
12294  @liveexample{The example below shows how pointers to internal values of a
12295  JSON value can be requested. Note that no type conversions are made and a
12296  `nullptr` is returned if the value and the requested pointer type does not
12297  match.,get_ptr}
12298 
12299  @since version 1.0.0
12300  */
12301  template<typename PointerType, typename std::enable_if<
12302  std::is_pointer<PointerType>::value, int>::type = 0>
12303  PointerType get_ptr() noexcept
12304  {
12305  // get the type of the PointerType (remove pointer and const)
12306  using pointee_t = typename std::remove_const<typename
12307  std::remove_pointer<typename
12308  std::remove_const<PointerType>::type>::type>::type;
12309  // make sure the type matches the allowed types
12310  static_assert(
12311  std::is_same<object_t, pointee_t>::value
12312  or std::is_same<array_t, pointee_t>::value
12313  or std::is_same<string_t, pointee_t>::value
12314  or std::is_same<boolean_t, pointee_t>::value
12315  or std::is_same<number_integer_t, pointee_t>::value
12316  or std::is_same<number_unsigned_t, pointee_t>::value
12317  or std::is_same<number_float_t, pointee_t>::value
12318  , "incompatible pointer type");
12319 
12320  // delegate the call to get_impl_ptr<>()
12321  return get_impl_ptr(static_cast<PointerType>(nullptr));
12322  }
12323 
12324  /*!
12325  @brief get a pointer value (implicit)
12326  @copydoc get_ptr()
12327  */
12328  template<typename PointerType, typename std::enable_if<
12329  std::is_pointer<PointerType>::value and
12330  std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
12331  constexpr const PointerType get_ptr() const noexcept
12332  {
12333  // get the type of the PointerType (remove pointer and const)
12334  using pointee_t = typename std::remove_const<typename
12335  std::remove_pointer<typename
12336  std::remove_const<PointerType>::type>::type>::type;
12337  // make sure the type matches the allowed types
12338  static_assert(
12339  std::is_same<object_t, pointee_t>::value
12340  or std::is_same<array_t, pointee_t>::value
12341  or std::is_same<string_t, pointee_t>::value
12342  or std::is_same<boolean_t, pointee_t>::value
12343  or std::is_same<number_integer_t, pointee_t>::value
12344  or std::is_same<number_unsigned_t, pointee_t>::value
12345  or std::is_same<number_float_t, pointee_t>::value
12346  , "incompatible pointer type");
12347 
12348  // delegate the call to get_impl_ptr<>() const
12349  return get_impl_ptr(static_cast<PointerType>(nullptr));
12350  }
12351 
12352  /*!
12353  @brief get a reference value (implicit)
12354 
12355  Implicit reference access to the internally stored JSON value. No copies
12356  are made.
12357 
12358  @warning Writing data to the referee of the result yields an undefined
12359  state.
12360 
12361  @tparam ReferenceType reference type; must be a reference to @ref array_t,
12362  @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
12363  @ref number_float_t. Enforced by static assertion.
12364 
12365  @return reference to the internally stored JSON value if the requested
12366  reference type @a ReferenceType fits to the JSON value; throws
12367  type_error.303 otherwise
12368 
12369  @throw type_error.303 in case passed type @a ReferenceType is incompatible
12370  with the stored JSON value; see example below
12371 
12372  @complexity Constant.
12373 
12374  @liveexample{The example shows several calls to `get_ref()`.,get_ref}
12375 
12376  @since version 1.1.0
12377  */
12378  template<typename ReferenceType, typename std::enable_if<
12379  std::is_reference<ReferenceType>::value, int>::type = 0>
12380  ReferenceType get_ref()
12381  {
12382  // delegate call to get_ref_impl
12383  return get_ref_impl<ReferenceType>(*this);
12384  }
12386  /*!
12387  @brief get a reference value (implicit)
12388  @copydoc get_ref()
12389  */
12390  template<typename ReferenceType, typename std::enable_if<
12391  std::is_reference<ReferenceType>::value and
12392  std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
12393  ReferenceType get_ref() const
12394  {
12395  // delegate call to get_ref_impl
12396  return get_ref_impl<ReferenceType>(*this);
12397  }
12399  /*!
12400  @brief get a value (implicit)
12401 
12402  Implicit type conversion between the JSON value and a compatible value.
12403  The call is realized by calling @ref get() const.
12404 
12405  @tparam ValueType non-pointer type compatible to the JSON value, for
12406  instance `int` for JSON integer numbers, `bool` for JSON booleans, or
12407  `std::vector` types for JSON arrays. The character type of @ref string_t
12408  as well as an initializer list of this type is excluded to avoid
12409  ambiguities as these types implicitly convert to `std::string`.
12410 
12411  @return copy of the JSON value, converted to type @a ValueType
12412 
12413  @throw type_error.302 in case passed type @a ValueType is incompatible
12414  to the JSON value type (e.g., the JSON value is of type boolean, but a
12415  string is requested); see example below
12416 
12417  @complexity Linear in the size of the JSON value.
12418 
12419  @liveexample{The example below shows several conversions from JSON values
12420  to other types. There a few things to note: (1) Floating-point numbers can
12421  be converted to integers\, (2) A JSON array can be converted to a standard
12422  `std::vector<short>`\, (3) A JSON object can be converted to C++
12423  associative containers such as `std::unordered_map<std::string\,
12424  json>`.,operator__ValueType}
12425 
12426  @since version 1.0.0
12427  */
12428  template < typename ValueType, typename std::enable_if <
12429  not std::is_pointer<ValueType>::value and
12430  not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
12431  not std::is_same<ValueType, typename string_t::value_type>::value and
12432  not detail::is_basic_json<ValueType>::value
12433 #ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015
12434  and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
12435 #endif
12436 #if defined(JSON_HAS_CPP_17)
12437  and not std::is_same<ValueType, typename std::string_view>::value
12438 #endif
12439  , int >::type = 0 >
12440  operator ValueType() const
12441  {
12442  // delegate the call to get<>() const
12443  return get<ValueType>();
12444  }
12446  /// @}
12447 
12448 
12449  ////////////////////
12450  // element access //
12451  ////////////////////
12452 
12453  /// @name element access
12454  /// Access to the JSON value.
12455  /// @{
12456 
12457  /*!
12458  @brief access specified array element with bounds checking
12459 
12460  Returns a reference to the element at specified location @a idx, with
12461  bounds checking.
12462 
12463  @param[in] idx index of the element to access
12464 
12465  @return reference to the element at index @a idx
12466 
12467  @throw type_error.304 if the JSON value is not an array; in this case,
12468  calling `at` with an index makes no sense. See example below.
12469  @throw out_of_range.401 if the index @a idx is out of range of the array;
12470  that is, `idx >= size()`. See example below.
12471 
12472  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
12473  changes in the JSON value.
12474 
12475  @complexity Constant.
12476 
12477  @since version 1.0.0
12478 
12479  @liveexample{The example below shows how array elements can be read and
12480  written using `at()`. It also demonstrates the different exceptions that
12481  can be thrown.,at__size_type}
12482  */
12483  reference at(size_type idx)
12484  {
12485  // at only works for arrays
12486  if (JSON_LIKELY(is_array()))
12487  {
12489  {
12490  return m_value.array->at(idx);
12491  }
12492  JSON_CATCH (std::out_of_range&)
12493  {
12494  // create better exception explanation
12495  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
12496  }
12497  }
12498  else
12499  {
12500  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
12501  }
12502  }
12503 
12504  /*!
12505  @brief access specified array element with bounds checking
12506 
12507  Returns a const reference to the element at specified location @a idx,
12508  with bounds checking.
12509 
12510  @param[in] idx index of the element to access
12511 
12512  @return const reference to the element at index @a idx
12513 
12514  @throw type_error.304 if the JSON value is not an array; in this case,
12515  calling `at` with an index makes no sense. See example below.
12516  @throw out_of_range.401 if the index @a idx is out of range of the array;
12517  that is, `idx >= size()`. See example below.
12518 
12519  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
12520  changes in the JSON value.
12521 
12522  @complexity Constant.
12523 
12524  @since version 1.0.0
12525 
12526  @liveexample{The example below shows how array elements can be read using
12527  `at()`. It also demonstrates the different exceptions that can be thrown.,
12528  at__size_type_const}
12529  */
12530  const_reference at(size_type idx) const
12531  {
12532  // at only works for arrays
12533  if (JSON_LIKELY(is_array()))
12534  {
12535  JSON_TRY
12536  {
12537  return m_value.array->at(idx);
12538  }
12539  JSON_CATCH (std::out_of_range&)
12540  {
12541  // create better exception explanation
12542  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
12543  }
12544  }
12545  else
12546  {
12547  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
12548  }
12549  }
12550 
12551  /*!
12552  @brief access specified object element with bounds checking
12553 
12554  Returns a reference to the element at with specified key @a key, with
12555  bounds checking.
12556 
12557  @param[in] key key of the element to access
12558 
12559  @return reference to the element at key @a key
12560 
12561  @throw type_error.304 if the JSON value is not an object; in this case,
12562  calling `at` with a key makes no sense. See example below.
12563  @throw out_of_range.403 if the key @a key is is not stored in the object;
12564  that is, `find(key) == end()`. See example below.
12565 
12566  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
12567  changes in the JSON value.
12568 
12569  @complexity Logarithmic in the size of the container.
12570 
12571  @sa @ref operator[](const typename object_t::key_type&) for unchecked
12572  access by reference
12573  @sa @ref value() for access by value with a default value
12574 
12575  @since version 1.0.0
12576 
12577  @liveexample{The example below shows how object elements can be read and
12578  written using `at()`. It also demonstrates the different exceptions that
12579  can be thrown.,at__object_t_key_type}
12580  */
12581  reference at(const typename object_t::key_type& key)
12582  {
12583  // at only works for objects
12584  if (JSON_LIKELY(is_object()))
12585  {
12586  JSON_TRY
12587  {
12588  return m_value.object->at(key);
12589  }
12590  JSON_CATCH (std::out_of_range&)
12591  {
12592  // create better exception explanation
12593  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
12594  }
12595  }
12596  else
12597  {
12598  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
12599  }
12600  }
12601 
12602  /*!
12603  @brief access specified object element with bounds checking
12604 
12605  Returns a const reference to the element at with specified key @a key,
12606  with bounds checking.
12607 
12608  @param[in] key key of the element to access
12609 
12610  @return const reference to the element at key @a key
12611 
12612  @throw type_error.304 if the JSON value is not an object; in this case,
12613  calling `at` with a key makes no sense. See example below.
12614  @throw out_of_range.403 if the key @a key is is not stored in the object;
12615  that is, `find(key) == end()`. See example below.
12616 
12617  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
12618  changes in the JSON value.
12619 
12620  @complexity Logarithmic in the size of the container.
12621 
12622  @sa @ref operator[](const typename object_t::key_type&) for unchecked
12623  access by reference
12624  @sa @ref value() for access by value with a default value
12625 
12626  @since version 1.0.0
12627 
12628  @liveexample{The example below shows how object elements can be read using
12629  `at()`. It also demonstrates the different exceptions that can be thrown.,
12630  at__object_t_key_type_const}
12631  */
12632  const_reference at(const typename object_t::key_type& key) const
12633  {
12634  // at only works for objects
12635  if (JSON_LIKELY(is_object()))
12636  {
12637  JSON_TRY
12638  {
12639  return m_value.object->at(key);
12640  }
12641  JSON_CATCH (std::out_of_range&)
12642  {
12643  // create better exception explanation
12644  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
12645  }
12646  }
12647  else
12648  {
12649  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
12650  }
12651  }
12652 
12653  /*!
12654  @brief access specified array element
12655 
12656  Returns a reference to the element at specified location @a idx.
12657 
12658  @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
12659  then the array is silently filled up with `null` values to make `idx` a
12660  valid reference to the last stored element.
12661 
12662  @param[in] idx index of the element to access
12663 
12664  @return reference to the element at index @a idx
12665 
12666  @throw type_error.305 if the JSON value is not an array or null; in that
12667  cases, using the [] operator with an index makes no sense.
12668 
12669  @complexity Constant if @a idx is in the range of the array. Otherwise
12670  linear in `idx - size()`.
12671 
12672  @liveexample{The example below shows how array elements can be read and
12673  written using `[]` operator. Note the addition of `null`
12674  values.,operatorarray__size_type}
12675 
12676  @since version 1.0.0
12677  */
12678  reference operator[](size_type idx)
12679  {
12680  // implicitly convert null value to an empty array
12681  if (is_null())
12682  {
12683  m_type = value_t::array;
12684  m_value.array = create<array_t>();
12685  assert_invariant();
12686  }
12687 
12688  // operator[] only works for arrays
12689  if (JSON_LIKELY(is_array()))
12690  {
12691  // fill up array with null values if given idx is outside range
12692  if (idx >= m_value.array->size())
12693  {
12694  m_value.array->insert(m_value.array->end(),
12695  idx - m_value.array->size() + 1,
12696  basic_json());
12697  }
12698 
12699  return m_value.array->operator[](idx);
12700  }
12701 
12702  JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
12703  }
12704 
12705  /*!
12706  @brief access specified array element
12707 
12708  Returns a const reference to the element at specified location @a idx.
12709 
12710  @param[in] idx index of the element to access
12711 
12712  @return const reference to the element at index @a idx
12713 
12714  @throw type_error.305 if the JSON value is not an array; in that case,
12715  using the [] operator with an index makes no sense.
12716 
12717  @complexity Constant.
12718 
12719  @liveexample{The example below shows how array elements can be read using
12720  the `[]` operator.,operatorarray__size_type_const}
12721 
12722  @since version 1.0.0
12723  */
12724  const_reference operator[](size_type idx) const
12725  {
12726  // const operator[] only works for arrays
12727  if (JSON_LIKELY(is_array()))
12728  {
12729  return m_value.array->operator[](idx);
12730  }
12731 
12732  JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
12733  }
12734 
12735  /*!
12736  @brief access specified object element
12737 
12738  Returns a reference to the element at with specified key @a key.
12740  @note If @a key is not found in the object, then it is silently added to
12741  the object and filled with a `null` value to make `key` a valid reference.
12742  In case the value was `null` before, it is converted to an object.
12743 
12744  @param[in] key key of the element to access
12745 
12746  @return reference to the element at key @a key
12747 
12748  @throw type_error.305 if the JSON value is not an object or null; in that
12749  cases, using the [] operator with a key makes no sense.
12750 
12751  @complexity Logarithmic in the size of the container.
12752 
12753  @liveexample{The example below shows how object elements can be read and
12754  written using the `[]` operator.,operatorarray__key_type}
12755 
12756  @sa @ref at(const typename object_t::key_type&) for access by reference
12757  with range checking
12758  @sa @ref value() for access by value with a default value
12759 
12760  @since version 1.0.0
12761  */
12762  reference operator[](const typename object_t::key_type& key)
12763  {
12764  // implicitly convert null value to an empty object
12765  if (is_null())
12766  {
12767  m_type = value_t::object;
12768  m_value.object = create<object_t>();
12769  assert_invariant();
12770  }
12771 
12772  // operator[] only works for objects
12773  if (JSON_LIKELY(is_object()))
12774  {
12775  return m_value.object->operator[](key);
12776  }
12778  JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
12779  }
12780 
12781  /*!
12782  @brief read-only access specified object element
12783 
12784  Returns a const reference to the element at with specified key @a key. No
12785  bounds checking is performed.
12786 
12787  @warning If the element with key @a key does not exist, the behavior is
12788  undefined.
12789 
12790  @param[in] key key of the element to access
12791 
12792  @return const reference to the element at key @a key
12793 
12794  @pre The element with key @a key must exist. **This precondition is
12795  enforced with an assertion.**
12796 
12797  @throw type_error.305 if the JSON value is not an object; in that case,
12798  using the [] operator with a key makes no sense.
12799 
12800  @complexity Logarithmic in the size of the container.
12801 
12802  @liveexample{The example below shows how object elements can be read using
12803  the `[]` operator.,operatorarray__key_type_const}
12804 
12805  @sa @ref at(const typename object_t::key_type&) for access by reference
12806  with range checking
12807  @sa @ref value() for access by value with a default value
12808 
12809  @since version 1.0.0
12810  */
12811  const_reference operator[](const typename object_t::key_type& key) const
12812  {
12813  // const operator[] only works for objects
12814  if (JSON_LIKELY(is_object()))
12815  {
12816  assert(m_value.object->find(key) != m_value.object->end());
12817  return m_value.object->find(key)->second;
12818  }
12819 
12820  JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
12821  }
12822 
12823  /*!
12824  @brief access specified object element
12825 
12826  Returns a reference to the element at with specified key @a key.
12827 
12828  @note If @a key is not found in the object, then it is silently added to
12829  the object and filled with a `null` value to make `key` a valid reference.
12830  In case the value was `null` before, it is converted to an object.
12831 
12832  @param[in] key key of the element to access
12833 
12834  @return reference to the element at key @a key
12835 
12836  @throw type_error.305 if the JSON value is not an object or null; in that
12837  cases, using the [] operator with a key makes no sense.
12838 
12839  @complexity Logarithmic in the size of the container.
12840 
12841  @liveexample{The example below shows how object elements can be read and
12842  written using the `[]` operator.,operatorarray__key_type}
12843 
12844  @sa @ref at(const typename object_t::key_type&) for access by reference
12845  with range checking
12846  @sa @ref value() for access by value with a default value
12847 
12848  @since version 1.1.0
12849  */
12850  template<typename T>
12851  reference operator[](T* key)
12852  {
12853  // implicitly convert null to object
12854  if (is_null())
12855  {
12856  m_type = value_t::object;
12857  m_value = value_t::object;
12858  assert_invariant();
12859  }
12860 
12861  // at only works for objects
12862  if (JSON_LIKELY(is_object()))
12863  {
12864  return m_value.object->operator[](key);
12865  }
12867  JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
12868  }
12869 
12870  /*!
12871  @brief read-only access specified object element
12872 
12873  Returns a const reference to the element at with specified key @a key. No
12874  bounds checking is performed.
12875 
12876  @warning If the element with key @a key does not exist, the behavior is
12877  undefined.
12878 
12879  @param[in] key key of the element to access
12880 
12881  @return const reference to the element at key @a key
12882 
12883  @pre The element with key @a key must exist. **This precondition is
12884  enforced with an assertion.**
12885 
12886  @throw type_error.305 if the JSON value is not an object; in that case,
12887  using the [] operator with a key makes no sense.
12888 
12889  @complexity Logarithmic in the size of the container.
12890 
12891  @liveexample{The example below shows how object elements can be read using
12892  the `[]` operator.,operatorarray__key_type_const}
12893 
12894  @sa @ref at(const typename object_t::key_type&) for access by reference
12895  with range checking
12896  @sa @ref value() for access by value with a default value
12897 
12898  @since version 1.1.0
12899  */
12900  template<typename T>
12901  const_reference operator[](T* key) const
12902  {
12903  // at only works for objects
12904  if (JSON_LIKELY(is_object()))
12905  {
12906  assert(m_value.object->find(key) != m_value.object->end());
12907  return m_value.object->find(key)->second;
12908  }
12909 
12910  JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
12911  }
12912 
12913  /*!
12914  @brief access specified object element with default value
12915 
12916  Returns either a copy of an object's element at the specified key @a key
12917  or a given default value if no element with key @a key exists.
12918 
12919  The function is basically equivalent to executing
12920  @code {.cpp}
12921  try {
12922  return at(key);
12923  } catch(out_of_range) {
12924  return default_value;
12925  }
12926  @endcode
12927 
12928  @note Unlike @ref at(const typename object_t::key_type&), this function
12929  does not throw if the given key @a key was not found.
12930 
12931  @note Unlike @ref operator[](const typename object_t::key_type& key), this
12932  function does not implicitly add an element to the position defined by @a
12933  key. This function is furthermore also applicable to const objects.
12934 
12935  @param[in] key key of the element to access
12936  @param[in] default_value the value to return if @a key is not found
12937 
12938  @tparam ValueType type compatible to JSON values, for instance `int` for
12939  JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
12940  JSON arrays. Note the type of the expected value at @a key and the default
12941  value @a default_value must be compatible.
12942 
12943  @return copy of the element at key @a key or @a default_value if @a key
12944  is not found
12945 
12946  @throw type_error.306 if the JSON value is not an object; in that case,
12947  using `value()` with a key makes no sense.
12948 
12949  @complexity Logarithmic in the size of the container.
12950 
12951  @liveexample{The example below shows how object elements can be queried
12952  with a default value.,basic_json__value}
12953 
12954  @sa @ref at(const typename object_t::key_type&) for access by reference
12955  with range checking
12956  @sa @ref operator[](const typename object_t::key_type&) for unchecked
12957  access by reference
12958 
12959  @since version 1.0.0
12960  */
12961  template<class ValueType, typename std::enable_if<
12962  std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
12963  ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
12964  {
12965  // at only works for objects
12966  if (JSON_LIKELY(is_object()))
12967  {
12968  // if key is found, return value and given default value otherwise
12969  const auto it = find(key);
12970  if (it != end())
12971  {
12972  return *it;
12973  }
12974 
12975  return default_value;
12976  }
12977 
12978  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
12979  }
12980 
12981  /*!
12982  @brief overload for a default value of type const char*
12983  @copydoc basic_json::value(const typename object_t::key_type&, ValueType) const
12984  */
12985  string_t value(const typename object_t::key_type& key, const char* default_value) const
12986  {
12987  return value(key, string_t(default_value));
12988  }
12989 
12990  /*!
12991  @brief access specified object element via JSON Pointer with default value
12992 
12993  Returns either a copy of an object's element at the specified key @a key
12994  or a given default value if no element with key @a key exists.
12995 
12996  The function is basically equivalent to executing
12997  @code {.cpp}
12998  try {
12999  return at(ptr);
13000  } catch(out_of_range) {
13001  return default_value;
13002  }
13003  @endcode
13004 
13005  @note Unlike @ref at(const json_pointer&), this function does not throw
13006  if the given key @a key was not found.
13007 
13008  @param[in] ptr a JSON pointer to the element to access
13009  @param[in] default_value the value to return if @a ptr found no value
13010 
13011  @tparam ValueType type compatible to JSON values, for instance `int` for
13012  JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
13013  JSON arrays. Note the type of the expected value at @a key and the default
13014  value @a default_value must be compatible.
13015 
13016  @return copy of the element at key @a key or @a default_value if @a key
13017  is not found
13018 
13019  @throw type_error.306 if the JSON value is not an objec; in that case,
13020  using `value()` with a key makes no sense.
13021 
13022  @complexity Logarithmic in the size of the container.
13023 
13024  @liveexample{The example below shows how object elements can be queried
13025  with a default value.,basic_json__value_ptr}
13026 
13027  @sa @ref operator[](const json_pointer&) for unchecked access by reference
13028 
13029  @since version 2.0.2
13030  */
13031  template<class ValueType, typename std::enable_if<
13032  std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
13033  ValueType value(const json_pointer& ptr, const ValueType& default_value) const
13034  {
13035  // at only works for objects
13036  if (JSON_LIKELY(is_object()))
13037  {
13038  // if pointer resolves a value, return it or use default value
13039  JSON_TRY
13040  {
13041  return ptr.get_checked(this);
13042  }
13043  JSON_CATCH (out_of_range&)
13044  {
13045  return default_value;
13046  }
13047  }
13049  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
13050  }
13051 
13052  /*!
13053  @brief overload for a default value of type const char*
13054  @copydoc basic_json::value(const json_pointer&, ValueType) const
13055  */
13056  string_t value(const json_pointer& ptr, const char* default_value) const
13057  {
13058  return value(ptr, string_t(default_value));
13059  }
13060 
13061  /*!
13062  @brief access the first element
13063 
13064  Returns a reference to the first element in the container. For a JSON
13065  container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
13066 
13067  @return In case of a structured type (array or object), a reference to the
13068  first element is returned. In case of number, string, or boolean values, a
13069  reference to the value is returned.
13070 
13071  @complexity Constant.
13072 
13073  @pre The JSON value must not be `null` (would throw `std::out_of_range`)
13074  or an empty array or object (undefined behavior, **guarded by
13075  assertions**).
13076  @post The JSON value remains unchanged.
13077 
13078  @throw invalid_iterator.214 when called on `null` value
13079 
13080  @liveexample{The following code shows an example for `front()`.,front}
13081 
13082  @sa @ref back() -- access the last element
13083 
13084  @since version 1.0.0
13085  */
13086  reference front()
13087  {
13088  return *begin();
13089  }
13090 
13091  /*!
13092  @copydoc basic_json::front()
13093  */
13094  const_reference front() const
13095  {
13096  return *cbegin();
13097  }
13098 
13099  /*!
13100  @brief access the last element
13102  Returns a reference to the last element in the container. For a JSON
13103  container `c`, the expression `c.back()` is equivalent to
13104  @code {.cpp}
13105  auto tmp = c.end();
13106  --tmp;
13107  return *tmp;
13108  @endcode
13110  @return In case of a structured type (array or object), a reference to the
13111  last element is returned. In case of number, string, or boolean values, a
13112  reference to the value is returned.
13113 
13114  @complexity Constant.
13115 
13116  @pre The JSON value must not be `null` (would throw `std::out_of_range`)
13117  or an empty array or object (undefined behavior, **guarded by
13118  assertions**).
13119  @post The JSON value remains unchanged.
13120 
13121  @throw invalid_iterator.214 when called on a `null` value. See example
13122  below.
13123 
13124  @liveexample{The following code shows an example for `back()`.,back}
13125 
13126  @sa @ref front() -- access the first element
13127 
13128  @since version 1.0.0
13129  */
13130  reference back()
13131  {
13132  auto tmp = end();
13133  --tmp;
13134  return *tmp;
13135  }
13136 
13137  /*!
13138  @copydoc basic_json::back()
13139  */
13140  const_reference back() const
13141  {
13142  auto tmp = cend();
13143  --tmp;
13144  return *tmp;
13145  }
13146 
13147  /*!
13148  @brief remove element given an iterator
13149 
13150  Removes the element specified by iterator @a pos. The iterator @a pos must
13151  be valid and dereferenceable. Thus the `end()` iterator (which is valid,
13152  but is not dereferenceable) cannot be used as a value for @a pos.
13153 
13154  If called on a primitive type other than `null`, the resulting JSON value
13155  will be `null`.
13156 
13157  @param[in] pos iterator to the element to remove
13158  @return Iterator following the last removed element. If the iterator @a
13159  pos refers to the last element, the `end()` iterator is returned.
13160 
13161  @tparam IteratorType an @ref iterator or @ref const_iterator
13162 
13163  @post Invalidates iterators and references at or after the point of the
13164  erase, including the `end()` iterator.
13165 
13166  @throw type_error.307 if called on a `null` value; example: `"cannot use
13167  erase() with null"`
13168  @throw invalid_iterator.202 if called on an iterator which does not belong
13169  to the current JSON value; example: `"iterator does not fit current
13170  value"`
13171  @throw invalid_iterator.205 if called on a primitive type with invalid
13172  iterator (i.e., any iterator which is not `begin()`); example: `"iterator
13173  out of range"`
13174 
13175  @complexity The complexity depends on the type:
13176  - objects: amortized constant
13177  - arrays: linear in distance between @a pos and the end of the container
13178  - strings: linear in the length of the string
13179  - other types: constant
13180 
13181  @liveexample{The example shows the result of `erase()` for different JSON
13182  types.,erase__IteratorType}
13183 
13184  @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
13185  the given range
13186  @sa @ref erase(const typename object_t::key_type&) -- removes the element
13187  from an object at the given key
13188  @sa @ref erase(const size_type) -- removes the element from an array at
13189  the given index
13190 
13191  @since version 1.0.0
13192  */
13193  template<class IteratorType, typename std::enable_if<
13194  std::is_same<IteratorType, typename basic_json_t::iterator>::value or
13195  std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
13196  = 0>
13197  IteratorType erase(IteratorType pos)
13198  {
13199  // make sure iterator fits the current value
13200  if (JSON_UNLIKELY(this != pos.m_object))
13201  {
13202  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
13203  }
13204 
13205  IteratorType result = end();
13206 
13207  switch (m_type)
13208  {
13209  case value_t::boolean:
13210  case value_t::number_float:
13211  case value_t::number_integer:
13212  case value_t::number_unsigned:
13213  case value_t::string:
13214  {
13215  if (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
13216  {
13217  JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
13218  }
13219 
13220  if (is_string())
13221  {
13222  AllocatorType<string_t> alloc;
13223  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
13224  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
13225  m_value.string = nullptr;
13226  }
13227 
13228  m_type = value_t::null;
13229  assert_invariant();
13230  break;
13231  }
13232 
13233  case value_t::object:
13234  {
13235  result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
13236  break;
13237  }
13238 
13239  case value_t::array:
13240  {
13241  result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
13242  break;
13243  }
13244 
13245  default:
13246  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
13247  }
13248 
13249  return result;
13250  }
13251 
13252  /*!
13253  @brief remove elements given an iterator range
13254 
13255  Removes the element specified by the range `[first; last)`. The iterator
13256  @a first does not need to be dereferenceable if `first == last`: erasing
13257  an empty range is a no-op.
13258 
13259  If called on a primitive type other than `null`, the resulting JSON value
13260  will be `null`.
13261 
13262  @param[in] first iterator to the beginning of the range to remove
13263  @param[in] last iterator past the end of the range to remove
13264  @return Iterator following the last removed element. If the iterator @a
13265  second refers to the last element, the `end()` iterator is returned.
13266 
13267  @tparam IteratorType an @ref iterator or @ref const_iterator
13268 
13269  @post Invalidates iterators and references at or after the point of the
13270  erase, including the `end()` iterator.
13271 
13272  @throw type_error.307 if called on a `null` value; example: `"cannot use
13273  erase() with null"`
13274  @throw invalid_iterator.203 if called on iterators which does not belong
13275  to the current JSON value; example: `"iterators do not fit current value"`
13276  @throw invalid_iterator.204 if called on a primitive type with invalid
13277  iterators (i.e., if `first != begin()` and `last != end()`); example:
13278  `"iterators out of range"`
13279 
13280  @complexity The complexity depends on the type:
13281  - objects: `log(size()) + std::distance(first, last)`
13282  - arrays: linear in the distance between @a first and @a last, plus linear
13283  in the distance between @a last and end of the container
13284  - strings: linear in the length of the string
13285  - other types: constant
13286 
13287  @liveexample{The example shows the result of `erase()` for different JSON
13288  types.,erase__IteratorType_IteratorType}
13289 
13290  @sa @ref erase(IteratorType) -- removes the element at a given position
13291  @sa @ref erase(const typename object_t::key_type&) -- removes the element
13292  from an object at the given key
13293  @sa @ref erase(const size_type) -- removes the element from an array at
13294  the given index
13295 
13296  @since version 1.0.0
13297  */
13298  template<class IteratorType, typename std::enable_if<
13299  std::is_same<IteratorType, typename basic_json_t::iterator>::value or
13300  std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
13301  = 0>
13302  IteratorType erase(IteratorType first, IteratorType last)
13303  {
13304  // make sure iterator fits the current value
13305  if (JSON_UNLIKELY(this != first.m_object or this != last.m_object))
13306  {
13307  JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
13308  }
13309 
13310  IteratorType result = end();
13311 
13312  switch (m_type)
13313  {
13314  case value_t::boolean:
13315  case value_t::number_float:
13316  case value_t::number_integer:
13317  case value_t::number_unsigned:
13318  case value_t::string:
13319  {
13320  if (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin()
13321  or not last.m_it.primitive_iterator.is_end()))
13322  {
13323  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
13324  }
13325 
13326  if (is_string())
13327  {
13328  AllocatorType<string_t> alloc;
13329  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
13330  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
13331  m_value.string = nullptr;
13332  }
13333 
13334  m_type = value_t::null;
13335  assert_invariant();
13336  break;
13337  }
13338 
13339  case value_t::object:
13340  {
13341  result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
13342  last.m_it.object_iterator);
13343  break;
13344  }
13345 
13346  case value_t::array:
13347  {
13348  result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
13349  last.m_it.array_iterator);
13350  break;
13351  }
13352 
13353  default:
13354  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
13355  }
13356 
13357  return result;
13358  }
13359 
13360  /*!
13361  @brief remove element from a JSON object given a key
13362 
13363  Removes elements from a JSON object with the key value @a key.
13364 
13365  @param[in] key value of the elements to remove
13366 
13367  @return Number of elements removed. If @a ObjectType is the default
13368  `std::map` type, the return value will always be `0` (@a key was not
13369  found) or `1` (@a key was found).
13370 
13371  @post References and iterators to the erased elements are invalidated.
13372  Other references and iterators are not affected.
13373 
13374  @throw type_error.307 when called on a type other than JSON object;
13375  example: `"cannot use erase() with null"`
13376 
13377  @complexity `log(size()) + count(key)`
13378 
13379  @liveexample{The example shows the effect of `erase()`.,erase__key_type}
13380 
13381  @sa @ref erase(IteratorType) -- removes the element at a given position
13382  @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
13383  the given range
13384  @sa @ref erase(const size_type) -- removes the element from an array at
13385  the given index
13386 
13387  @since version 1.0.0
13388  */
13389  size_type erase(const typename object_t::key_type& key)
13390  {
13391  // this erase only works for objects
13392  if (JSON_LIKELY(is_object()))
13393  {
13394  return m_value.object->erase(key);
13395  }
13396 
13397  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
13398  }
13399 
13400  /*!
13401  @brief remove element from a JSON array given an index
13402 
13403  Removes element from a JSON array at the index @a idx.
13405  @param[in] idx index of the element to remove
13406 
13407  @throw type_error.307 when called on a type other than JSON object;
13408  example: `"cannot use erase() with null"`
13409  @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
13410  is out of range"`
13411 
13412  @complexity Linear in distance between @a idx and the end of the container.
13413 
13414  @liveexample{The example shows the effect of `erase()`.,erase__size_type}
13415 
13416  @sa @ref erase(IteratorType) -- removes the element at a given position
13417  @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
13418  the given range
13419  @sa @ref erase(const typename object_t::key_type&) -- removes the element
13420  from an object at the given key
13421 
13422  @since version 1.0.0
13423  */
13424  void erase(const size_type idx)
13425  {
13426  // this erase only works for arrays
13427  if (JSON_LIKELY(is_array()))
13428  {
13429  if (JSON_UNLIKELY(idx >= size()))
13430  {
13431  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
13432  }
13433 
13434  m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
13435  }
13436  else
13437  {
13438  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
13439  }
13440  }
13441 
13442  /// @}
13443 
13444 
13445  ////////////
13446  // lookup //
13447  ////////////
13448 
13449  /// @name lookup
13450  /// @{
13451 
13452  /*!
13453  @brief find an element in a JSON object
13454 
13455  Finds an element in a JSON object with key equivalent to @a key. If the
13456  element is not found or the JSON value is not an object, end() is
13457  returned.
13458 
13459  @note This method always returns @ref end() when executed on a JSON type
13460  that is not an object.
13461 
13462  @param[in] key key value of the element to search for.
13463 
13464  @return Iterator to an element with key equivalent to @a key. If no such
13465  element is found or the JSON value is not an object, past-the-end (see
13466  @ref end()) iterator is returned.
13467 
13468  @complexity Logarithmic in the size of the JSON object.
13469 
13470  @liveexample{The example shows how `find()` is used.,find__key_type}
13471 
13472  @since version 1.0.0
13473  */
13474  template<typename KeyT>
13475  iterator find(KeyT&& key)
13476  {
13477  auto result = end();
13478 
13479  if (is_object())
13480  {
13481  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
13482  }
13483 
13484  return result;
13485  }
13486 
13487  /*!
13488  @brief find an element in a JSON object
13489  @copydoc find(KeyT&&)
13490  */
13491  template<typename KeyT>
13492  const_iterator find(KeyT&& key) const
13493  {
13494  auto result = cend();
13495 
13496  if (is_object())
13497  {
13498  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
13499  }
13500 
13501  return result;
13502  }
13503 
13504  /*!
13505  @brief returns the number of occurrences of a key in a JSON object
13506 
13507  Returns the number of elements with key @a key. If ObjectType is the
13508  default `std::map` type, the return value will always be `0` (@a key was
13509  not found) or `1` (@a key was found).
13510 
13511  @note This method always returns `0` when executed on a JSON type that is
13512  not an object.
13513 
13514  @param[in] key key value of the element to count
13515 
13516  @return Number of elements with key @a key. If the JSON value is not an
13517  object, the return value will be `0`.
13518 
13519  @complexity Logarithmic in the size of the JSON object.
13520 
13521  @liveexample{The example shows how `count()` is used.,count}
13522 
13523  @since version 1.0.0
13524  */
13525  template<typename KeyT>
13526  size_type count(KeyT&& key) const
13527  {
13528  // return 0 for all nonobject types
13529  return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
13530  }
13531 
13532  /// @}
13533 
13534 
13535  ///////////////
13536  // iterators //
13537  ///////////////
13538 
13539  /// @name iterators
13540  /// @{
13542  /*!
13543  @brief returns an iterator to the first element
13544 
13545  Returns an iterator to the first element.
13546 
13547  @image html range-begin-end.svg "Illustration from cppreference.com"
13548 
13549  @return iterator to the first element
13550 
13551  @complexity Constant.
13552 
13553  @requirement This function helps `basic_json` satisfying the
13554  [Container](http://en.cppreference.com/w/cpp/concept/Container)
13555  requirements:
13556  - The complexity is constant.
13557 
13558  @liveexample{The following code shows an example for `begin()`.,begin}
13559 
13560  @sa @ref cbegin() -- returns a const iterator to the beginning
13561  @sa @ref end() -- returns an iterator to the end
13562  @sa @ref cend() -- returns a const iterator to the end
13563 
13564  @since version 1.0.0
13565  */
13566  iterator begin() noexcept
13567  {
13568  iterator result(this);
13569  result.set_begin();
13570  return result;
13571  }
13572 
13573  /*!
13574  @copydoc basic_json::cbegin()
13575  */
13576  const_iterator begin() const noexcept
13577  {
13578  return cbegin();
13579  }
13580 
13581  /*!
13582  @brief returns a const iterator to the first element
13583 
13584  Returns a const iterator to the first element.
13585 
13586  @image html range-begin-end.svg "Illustration from cppreference.com"
13587 
13588  @return const iterator to the first element
13589 
13590  @complexity Constant.
13592  @requirement This function helps `basic_json` satisfying the
13593  [Container](http://en.cppreference.com/w/cpp/concept/Container)
13594  requirements:
13595  - The complexity is constant.
13596  - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
13597 
13598  @liveexample{The following code shows an example for `cbegin()`.,cbegin}
13599 
13600  @sa @ref begin() -- returns an iterator to the beginning
13601  @sa @ref end() -- returns an iterator to the end
13602  @sa @ref cend() -- returns a const iterator to the end
13603 
13604  @since version 1.0.0
13605  */
13606  const_iterator cbegin() const noexcept
13607  {
13608  const_iterator result(this);
13609  result.set_begin();
13610  return result;
13611  }
13612 
13613  /*!
13614  @brief returns an iterator to one past the last element
13615 
13616  Returns an iterator to one past the last element.
13617 
13618  @image html range-begin-end.svg "Illustration from cppreference.com"
13619 
13620  @return iterator one past the last element
13622  @complexity Constant.
13623 
13624  @requirement This function helps `basic_json` satisfying the
13625  [Container](http://en.cppreference.com/w/cpp/concept/Container)
13626  requirements:
13627  - The complexity is constant.
13628 
13629  @liveexample{The following code shows an example for `end()`.,end}
13630 
13631  @sa @ref cend() -- returns a const iterator to the end
13632  @sa @ref begin() -- returns an iterator to the beginning
13633  @sa @ref cbegin() -- returns a const iterator to the beginning
13634 
13635  @since version 1.0.0
13636  */
13637  iterator end() noexcept
13638  {
13639  iterator result(this);
13640  result.set_end();
13641  return result;
13642  }
13643 
13644  /*!
13645  @copydoc basic_json::cend()
13646  */
13647  const_iterator end() const noexcept
13648  {
13649  return cend();
13650  }
13651 
13652  /*!
13653  @brief returns a const iterator to one past the last element
13654 
13655  Returns a const iterator to one past the last element.
13656 
13657  @image html range-begin-end.svg "Illustration from cppreference.com"
13658 
13659  @return const iterator one past the last element
13660 
13661  @complexity Constant.
13663  @requirement This function helps `basic_json` satisfying the
13664  [Container](http://en.cppreference.com/w/cpp/concept/Container)
13665  requirements:
13666  - The complexity is constant.
13667  - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
13668 
13669  @liveexample{The following code shows an example for `cend()`.,cend}
13670 
13671  @sa @ref end() -- returns an iterator to the end
13672  @sa @ref begin() -- returns an iterator to the beginning
13673  @sa @ref cbegin() -- returns a const iterator to the beginning
13674 
13675  @since version 1.0.0
13676  */
13677  const_iterator cend() const noexcept
13678  {
13679  const_iterator result(this);
13680  result.set_end();
13681  return result;
13682  }
13683 
13684  /*!
13685  @brief returns an iterator to the reverse-beginning
13686 
13687  Returns an iterator to the reverse-beginning; that is, the last element.
13688 
13689  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
13690 
13691  @complexity Constant.
13693  @requirement This function helps `basic_json` satisfying the
13694  [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
13695  requirements:
13696  - The complexity is constant.
13697  - Has the semantics of `reverse_iterator(end())`.
13698 
13699  @liveexample{The following code shows an example for `rbegin()`.,rbegin}
13700 
13701  @sa @ref crbegin() -- returns a const reverse iterator to the beginning
13702  @sa @ref rend() -- returns a reverse iterator to the end
13703  @sa @ref crend() -- returns a const reverse iterator to the end
13704 
13705  @since version 1.0.0
13706  */
13707  reverse_iterator rbegin() noexcept
13708  {
13709  return reverse_iterator(end());
13710  }
13711 
13712  /*!
13713  @copydoc basic_json::crbegin()
13714  */
13715  const_reverse_iterator rbegin() const noexcept
13716  {
13717  return crbegin();
13718  }
13719 
13720  /*!
13721  @brief returns an iterator to the reverse-end
13723  Returns an iterator to the reverse-end; that is, one before the first
13724  element.
13725 
13726  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
13727 
13728  @complexity Constant.
13729 
13730  @requirement This function helps `basic_json` satisfying the
13731  [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
13732  requirements:
13733  - The complexity is constant.
13734  - Has the semantics of `reverse_iterator(begin())`.
13735 
13736  @liveexample{The following code shows an example for `rend()`.,rend}
13737 
13738  @sa @ref crend() -- returns a const reverse iterator to the end
13739  @sa @ref rbegin() -- returns a reverse iterator to the beginning
13740  @sa @ref crbegin() -- returns a const reverse iterator to the beginning
13741 
13742  @since version 1.0.0
13743  */
13744  reverse_iterator rend() noexcept
13745  {
13746  return reverse_iterator(begin());
13747  }
13748 
13749  /*!
13750  @copydoc basic_json::crend()
13751  */
13752  const_reverse_iterator rend() const noexcept
13753  {
13754  return crend();
13755  }
13756 
13757  /*!
13758  @brief returns a const reverse iterator to the last element
13760  Returns a const iterator to the reverse-beginning; that is, the last
13761  element.
13762 
13763  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
13764 
13765  @complexity Constant.
13766 
13767  @requirement This function helps `basic_json` satisfying the
13768  [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
13769  requirements:
13770  - The complexity is constant.
13771  - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
13772 
13773  @liveexample{The following code shows an example for `crbegin()`.,crbegin}
13774 
13775  @sa @ref rbegin() -- returns a reverse iterator to the beginning
13776  @sa @ref rend() -- returns a reverse iterator to the end
13777  @sa @ref crend() -- returns a const reverse iterator to the end
13778 
13779  @since version 1.0.0
13780  */
13781  const_reverse_iterator crbegin() const noexcept
13782  {
13783  return const_reverse_iterator(cend());
13784  }
13785 
13786  /*!
13787  @brief returns a const reverse iterator to one before the first
13788 
13789  Returns a const reverse iterator to the reverse-end; that is, one before
13790  the first element.
13791 
13792  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
13793 
13794  @complexity Constant.
13795 
13796  @requirement This function helps `basic_json` satisfying the
13797  [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
13798  requirements:
13799  - The complexity is constant.
13800  - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
13801 
13802  @liveexample{The following code shows an example for `crend()`.,crend}
13803 
13804  @sa @ref rend() -- returns a reverse iterator to the end
13805  @sa @ref rbegin() -- returns a reverse iterator to the beginning
13806  @sa @ref crbegin() -- returns a const reverse iterator to the beginning
13807 
13808  @since version 1.0.0
13809  */
13810  const_reverse_iterator crend() const noexcept
13811  {
13812  return const_reverse_iterator(cbegin());
13813  }
13814 
13815  public:
13816  /*!
13817  @brief wrapper to access iterator member functions in range-based for
13818 
13819  This function allows to access @ref iterator::key() and @ref
13820  iterator::value() during range-based for loops. In these loops, a
13821  reference to the JSON values is returned, so there is no access to the
13822  underlying iterator.
13823 
13824  For loop without iterator_wrapper:
13826  @code{cpp}
13827  for (auto it = j_object.begin(); it != j_object.end(); ++it)
13828  {
13829  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
13830  }
13831  @endcode
13832 
13833  Range-based for loop without iterator proxy:
13834 
13835  @code{cpp}
13836  for (auto it : j_object)
13837  {
13838  // "it" is of type json::reference and has no key() member
13839  std::cout << "value: " << it << '\n';
13840  }
13841  @endcode
13842 
13843  Range-based for loop with iterator proxy:
13844 
13845  @code{cpp}
13846  for (auto it : json::iterator_wrapper(j_object))
13847  {
13848  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
13849  }
13850  @endcode
13851 
13852  @note When iterating over an array, `key()` will return the index of the
13853  element as string (see example).
13854 
13855  @param[in] ref reference to a JSON value
13856  @return iteration proxy object wrapping @a ref with an interface to use in
13857  range-based for loops
13858 
13859  @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
13860 
13861  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
13862  changes in the JSON value.
13863 
13864  @complexity Constant.
13865 
13866  @note The name of this function is not yet final and may change in the
13867  future.
13868 
13869  @deprecated This stream operator is deprecated and will be removed in
13870  future 4.0.0 of the library. Please use @ref items() instead;
13871  that is, replace `json::iterator_wrapper(j)` with `j.items()`.
13872  */
13874  static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
13875  {
13876  return ref.items();
13877  }
13878 
13879  /*!
13880  @copydoc iterator_wrapper(reference)
13881  */
13883  static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
13884  {
13885  return ref.items();
13886  }
13887 
13888  /*!
13889  @brief helper to access iterator member functions in range-based for
13890 
13891  This function allows to access @ref iterator::key() and @ref
13892  iterator::value() during range-based for loops. In these loops, a
13893  reference to the JSON values is returned, so there is no access to the
13894  underlying iterator.
13895 
13896  For loop without `items()` function:
13897 
13898  @code{cpp}
13899  for (auto it = j_object.begin(); it != j_object.end(); ++it)
13900  {
13901  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
13902  }
13903  @endcode
13904 
13905  Range-based for loop without `items()` function:
13906 
13907  @code{cpp}
13908  for (auto it : j_object)
13909  {
13910  // "it" is of type json::reference and has no key() member
13911  std::cout << "value: " << it << '\n';
13912  }
13913  @endcode
13914 
13915  Range-based for loop with `items()` function:
13916 
13917  @code{cpp}
13918  for (auto it : j_object.items())
13919  {
13920  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
13921  }
13922  @endcode
13923 
13924  @note When iterating over an array, `key()` will return the index of the
13925  element as string (see example). For primitive types (e.g., numbers),
13926  `key()` returns an empty string.
13927 
13928  @return iteration proxy object wrapping @a ref with an interface to use in
13929  range-based for loops
13930 
13931  @liveexample{The following code shows how the function is used.,items}
13932 
13933  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
13934  changes in the JSON value.
13935 
13936  @complexity Constant.
13937 
13938  @since version 3.x.x.
13939  */
13940  iteration_proxy<iterator> items() noexcept
13941  {
13942  return iteration_proxy<iterator>(*this);
13943  }
13944 
13945  /*!
13946  @copydoc items()
13947  */
13948  iteration_proxy<const_iterator> items() const noexcept
13949  {
13950  return iteration_proxy<const_iterator>(*this);
13951  }
13952 
13953  /// @}
13954 
13956  //////////////
13957  // capacity //
13958  //////////////
13959 
13960  /// @name capacity
13961  /// @{
13962 
13963  /*!
13964  @brief checks whether the container is empty.
13965 
13966  Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
13967 
13968  @return The return value depends on the different types and is
13969  defined as follows:
13970  Value type | return value
13971  ----------- | -------------
13972  null | `true`
13973  boolean | `false`
13974  string | `false`
13975  number | `false`
13976  object | result of function `object_t::empty()`
13977  array | result of function `array_t::empty()`
13978 
13979  @liveexample{The following code uses `empty()` to check if a JSON
13980  object contains any elements.,empty}
13981 
13982  @complexity Constant, as long as @ref array_t and @ref object_t satisfy
13983  the Container concept; that is, their `empty()` functions have constant
13984  complexity.
13985 
13986  @iterators No changes.
13987 
13988  @exceptionsafety No-throw guarantee: this function never throws exceptions.
13989 
13990  @note This function does not return whether a string stored as JSON value
13991  is empty - it returns whether the JSON container itself is empty which is
13992  false in the case of a string.
13993 
13994  @requirement This function helps `basic_json` satisfying the
13995  [Container](http://en.cppreference.com/w/cpp/concept/Container)
13996  requirements:
13997  - The complexity is constant.
13998  - Has the semantics of `begin() == end()`.
13999 
14000  @sa @ref size() -- returns the number of elements
14001 
14002  @since version 1.0.0
14003  */
14004  bool empty() const noexcept
14005  {
14006  switch (m_type)
14007  {
14008  case value_t::null:
14009  {
14010  // null values are empty
14011  return true;
14012  }
14013 
14014  case value_t::array:
14015  {
14016  // delegate call to array_t::empty()
14017  return m_value.array->empty();
14018  }
14020  case value_t::object:
14021  {
14022  // delegate call to object_t::empty()
14023  return m_value.object->empty();
14024  }
14025 
14026  default:
14027  {
14028  // all other types are nonempty
14029  return false;
14030  }
14031  }
14032  }
14033 
14034  /*!
14035  @brief returns the number of elements
14036 
14037  Returns the number of elements in a JSON value.
14038 
14039  @return The return value depends on the different types and is
14040  defined as follows:
14041  Value type | return value
14042  ----------- | -------------
14043  null | `0`
14044  boolean | `1`
14045  string | `1`
14046  number | `1`
14047  object | result of function object_t::size()
14048  array | result of function array_t::size()
14049 
14050  @liveexample{The following code calls `size()` on the different value
14051  types.,size}
14052 
14053  @complexity Constant, as long as @ref array_t and @ref object_t satisfy
14054  the Container concept; that is, their size() functions have constant
14055  complexity.
14056 
14057  @iterators No changes.
14058 
14059  @exceptionsafety No-throw guarantee: this function never throws exceptions.
14060 
14061  @note This function does not return the length of a string stored as JSON
14062  value - it returns the number of elements in the JSON value which is 1 in
14063  the case of a string.
14064 
14065  @requirement This function helps `basic_json` satisfying the
14066  [Container](http://en.cppreference.com/w/cpp/concept/Container)
14067  requirements:
14068  - The complexity is constant.
14069  - Has the semantics of `std::distance(begin(), end())`.
14070 
14071  @sa @ref empty() -- checks whether the container is empty
14072  @sa @ref max_size() -- returns the maximal number of elements
14073 
14074  @since version 1.0.0
14075  */
14076  size_type size() const noexcept
14077  {
14078  switch (m_type)
14079  {
14080  case value_t::null:
14081  {
14082  // null values are empty
14083  return 0;
14084  }
14085 
14086  case value_t::array:
14087  {
14088  // delegate call to array_t::size()
14089  return m_value.array->size();
14090  }
14092  case value_t::object:
14093  {
14094  // delegate call to object_t::size()
14095  return m_value.object->size();
14096  }
14097 
14098  default:
14099  {
14100  // all other types have size 1
14101  return 1;
14102  }
14103  }
14104  }
14105 
14106  /*!
14107  @brief returns the maximum possible number of elements
14108 
14109  Returns the maximum number of elements a JSON value is able to hold due to
14110  system or library implementation limitations, i.e. `std::distance(begin(),
14111  end())` for the JSON value.
14112 
14113  @return The return value depends on the different types and is
14114  defined as follows:
14115  Value type | return value
14116  ----------- | -------------
14117  null | `0` (same as `size()`)
14118  boolean | `1` (same as `size()`)
14119  string | `1` (same as `size()`)
14120  number | `1` (same as `size()`)
14121  object | result of function `object_t::max_size()`
14122  array | result of function `array_t::max_size()`
14123 
14124  @liveexample{The following code calls `max_size()` on the different value
14125  types. Note the output is implementation specific.,max_size}
14126 
14127  @complexity Constant, as long as @ref array_t and @ref object_t satisfy
14128  the Container concept; that is, their `max_size()` functions have constant
14129  complexity.
14130 
14131  @iterators No changes.
14132 
14133  @exceptionsafety No-throw guarantee: this function never throws exceptions.
14134 
14135  @requirement This function helps `basic_json` satisfying the
14136  [Container](http://en.cppreference.com/w/cpp/concept/Container)
14137  requirements:
14138  - The complexity is constant.
14139  - Has the semantics of returning `b.size()` where `b` is the largest
14140  possible JSON value.
14141 
14142  @sa @ref size() -- returns the number of elements
14143 
14144  @since version 1.0.0
14145  */
14146  size_type max_size() const noexcept
14147  {
14148  switch (m_type)
14149  {
14150  case value_t::array:
14151  {
14152  // delegate call to array_t::max_size()
14153  return m_value.array->max_size();
14154  }
14155 
14156  case value_t::object:
14157  {
14158  // delegate call to object_t::max_size()
14159  return m_value.object->max_size();
14160  }
14162  default:
14163  {
14164  // all other types have max_size() == size()
14165  return size();
14166  }
14167  }
14168  }
14169 
14170  /// @}
14171 
14172 
14173  ///////////////
14174  // modifiers //
14175  ///////////////
14176 
14177  /// @name modifiers
14178  /// @{
14179 
14180  /*!
14181  @brief clears the contents
14182 
14183  Clears the content of a JSON value and resets it to the default value as
14184  if @ref basic_json(value_t) would have been called with the current value
14185  type from @ref type():
14186 
14187  Value type | initial value
14188  ----------- | -------------
14189  null | `null`
14190  boolean | `false`
14191  string | `""`
14192  number | `0`
14193  object | `{}`
14194  array | `[]`
14195 
14196  @post Has the same effect as calling
14197  @code {.cpp}
14198  *this = basic_json(type());
14199  @endcode
14200 
14201  @liveexample{The example below shows the effect of `clear()` to different
14202  JSON types.,clear}
14203 
14204  @complexity Linear in the size of the JSON value.
14205 
14206  @iterators All iterators, pointers and references related to this container
14207  are invalidated.
14208 
14209  @exceptionsafety No-throw guarantee: this function never throws exceptions.
14210 
14211  @sa @ref basic_json(value_t) -- constructor that creates an object with the
14212  same value than calling `clear()`
14213 
14214  @since version 1.0.0
14215  */
14216  void clear() noexcept
14217  {
14218  switch (m_type)
14219  {
14220  case value_t::number_integer:
14221  {
14222  m_value.number_integer = 0;
14223  break;
14224  }
14225 
14226  case value_t::number_unsigned:
14227  {
14228  m_value.number_unsigned = 0;
14229  break;
14230  }
14232  case value_t::number_float:
14233  {
14234  m_value.number_float = 0.0;
14235  break;
14236  }
14237 
14238  case value_t::boolean:
14239  {
14240  m_value.boolean = false;
14241  break;
14242  }
14243 
14244  case value_t::string:
14245  {
14246  m_value.string->clear();
14247  break;
14248  }
14249 
14250  case value_t::array:
14251  {
14252  m_value.array->clear();
14253  break;
14254  }
14255 
14256  case value_t::object:
14257  {
14258  m_value.object->clear();
14259  break;
14260  }
14261 
14262  default:
14263  break;
14264  }
14265  }
14266 
14267  /*!
14268  @brief add an object to an array
14269 
14270  Appends the given element @a val to the end of the JSON value. If the
14271  function is called on a JSON null value, an empty array is created before
14272  appending @a val.
14273 
14274  @param[in] val the value to add to the JSON array
14275 
14276  @throw type_error.308 when called on a type other than JSON array or
14277  null; example: `"cannot use push_back() with number"`
14278 
14279  @complexity Amortized constant.
14280 
14281  @liveexample{The example shows how `push_back()` and `+=` can be used to
14282  add elements to a JSON array. Note how the `null` value was silently
14283  converted to a JSON array.,push_back}
14284 
14285  @since version 1.0.0
14286  */
14287  void push_back(basic_json&& val)
14288  {
14289  // push_back only works for null objects or arrays
14290  if (JSON_UNLIKELY(not(is_null() or is_array())))
14291  {
14292  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
14293  }
14294 
14295  // transform null object into an array
14296  if (is_null())
14297  {
14298  m_type = value_t::array;
14299  m_value = value_t::array;
14300  assert_invariant();
14301  }
14303  // add element to array (move semantics)
14304  m_value.array->push_back(std::move(val));
14305  // invalidate object
14306  val.m_type = value_t::null;
14307  }
14308 
14309  /*!
14310  @brief add an object to an array
14311  @copydoc push_back(basic_json&&)
14312  */
14313  reference operator+=(basic_json&& val)
14314  {
14315  push_back(std::move(val));
14316  return *this;
14317  }
14318 
14319  /*!
14320  @brief add an object to an array
14321  @copydoc push_back(basic_json&&)
14322  */
14323  void push_back(const basic_json& val)
14324  {
14325  // push_back only works for null objects or arrays
14326  if (JSON_UNLIKELY(not(is_null() or is_array())))
14327  {
14328  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
14329  }
14330 
14331  // transform null object into an array
14332  if (is_null())
14333  {
14334  m_type = value_t::array;
14335  m_value = value_t::array;
14336  assert_invariant();
14337  }
14339  // add element to array
14340  m_value.array->push_back(val);
14341  }
14342 
14343  /*!
14344  @brief add an object to an array
14345  @copydoc push_back(basic_json&&)
14346  */
14347  reference operator+=(const basic_json& val)
14348  {
14349  push_back(val);
14350  return *this;
14351  }
14352 
14353  /*!
14354  @brief add an object to an object
14355 
14356  Inserts the given element @a val to the JSON object. If the function is
14357  called on a JSON null value, an empty object is created before inserting
14358  @a val.
14359 
14360  @param[in] val the value to add to the JSON object
14361 
14362  @throw type_error.308 when called on a type other than JSON object or
14363  null; example: `"cannot use push_back() with number"`
14364 
14365  @complexity Logarithmic in the size of the container, O(log(`size()`)).
14366 
14367  @liveexample{The example shows how `push_back()` and `+=` can be used to
14368  add elements to a JSON object. Note how the `null` value was silently
14369  converted to a JSON object.,push_back__object_t__value}
14370 
14371  @since version 1.0.0
14372  */
14373  void push_back(const typename object_t::value_type& val)
14374  {
14375  // push_back only works for null objects or objects
14376  if (JSON_UNLIKELY(not(is_null() or is_object())))
14377  {
14378  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
14379  }
14380 
14381  // transform null object into an object
14382  if (is_null())
14383  {
14384  m_type = value_t::object;
14385  m_value = value_t::object;
14386  assert_invariant();
14387  }
14389  // add element to array
14390  m_value.object->insert(val);
14391  }
14392 
14393  /*!
14394  @brief add an object to an object
14395  @copydoc push_back(const typename object_t::value_type&)
14396  */
14397  reference operator+=(const typename object_t::value_type& val)
14398  {
14399  push_back(val);
14400  return *this;
14401  }
14402 
14403  /*!
14404  @brief add an object to an object
14405 
14406  This function allows to use `push_back` with an initializer list. In case
14407 
14408  1. the current value is an object,
14409  2. the initializer list @a init contains only two elements, and
14410  3. the first element of @a init is a string,
14411 
14412  @a init is converted into an object element and added using
14413  @ref push_back(const typename object_t::value_type&). Otherwise, @a init
14414  is converted to a JSON value and added using @ref push_back(basic_json&&).
14415 
14416  @param[in] init an initializer list
14417 
14418  @complexity Linear in the size of the initializer list @a init.
14419 
14420  @note This function is required to resolve an ambiguous overload error,
14421  because pairs like `{"key", "value"}` can be both interpreted as
14422  `object_t::value_type` or `std::initializer_list<basic_json>`, see
14423  https://github.com/nlohmann/json/issues/235 for more information.
14424 
14425  @liveexample{The example shows how initializer lists are treated as
14426  objects when possible.,push_back__initializer_list}
14427  */
14428  void push_back(initializer_list_t init)
14429  {
14430  if (is_object() and init.size() == 2 and (*init.begin())->is_string())
14431  {
14432  basic_json&& key = init.begin()->moved_or_copied();
14433  push_back(typename object_t::value_type(
14434  std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
14435  }
14436  else
14437  {
14438  push_back(basic_json(init));
14439  }
14440  }
14441 
14442  /*!
14443  @brief add an object to an object
14444  @copydoc push_back(initializer_list_t)
14445  */
14446  reference operator+=(initializer_list_t init)
14447  {
14448  push_back(init);
14449  return *this;
14450  }
14451 
14452  /*!
14453  @brief add an object to an array
14454 
14455  Creates a JSON value from the passed parameters @a args to the end of the
14456  JSON value. If the function is called on a JSON null value, an empty array
14457  is created before appending the value created from @a args.
14458 
14459  @param[in] args arguments to forward to a constructor of @ref basic_json
14460  @tparam Args compatible types to create a @ref basic_json object
14462  @throw type_error.311 when called on a type other than JSON array or
14463  null; example: `"cannot use emplace_back() with number"`
14464 
14465  @complexity Amortized constant.
14466 
14467  @liveexample{The example shows how `push_back()` can be used to add
14468  elements to a JSON array. Note how the `null` value was silently converted
14469  to a JSON array.,emplace_back}
14470 
14471  @since version 2.0.8
14472  */
14473  template<class... Args>
14474  void emplace_back(Args&& ... args)
14475  {
14476  // emplace_back only works for null objects or arrays
14477  if (JSON_UNLIKELY(not(is_null() or is_array())))
14478  {
14479  JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
14480  }
14481 
14482  // transform null object into an array
14483  if (is_null())
14484  {
14485  m_type = value_t::array;
14486  m_value = value_t::array;
14487  assert_invariant();
14488  }
14490  // add element to array (perfect forwarding)
14491  m_value.array->emplace_back(std::forward<Args>(args)...);
14492  }
14493 
14494  /*!
14495  @brief add an object to an object if key does not exist
14496 
14497  Inserts a new element into a JSON object constructed in-place with the
14498  given @a args if there is no element with the key in the container. If the
14499  function is called on a JSON null value, an empty object is created before
14500  appending the value created from @a args.
14501 
14502  @param[in] args arguments to forward to a constructor of @ref basic_json
14503  @tparam Args compatible types to create a @ref basic_json object
14504 
14505  @return a pair consisting of an iterator to the inserted element, or the
14506  already-existing element if no insertion happened, and a bool
14507  denoting whether the insertion took place.
14508 
14509  @throw type_error.311 when called on a type other than JSON object or
14510  null; example: `"cannot use emplace() with number"`
14511 
14512  @complexity Logarithmic in the size of the container, O(log(`size()`)).
14513 
14514  @liveexample{The example shows how `emplace()` can be used to add elements
14515  to a JSON object. Note how the `null` value was silently converted to a
14516  JSON object. Further note how no value is added if there was already one
14517  value stored with the same key.,emplace}
14518 
14519  @since version 2.0.8
14520  */
14521  template<class... Args>
14522  std::pair<iterator, bool> emplace(Args&& ... args)
14523  {
14524  // emplace only works for null objects or arrays
14525  if (JSON_UNLIKELY(not(is_null() or is_object())))
14526  {
14527  JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
14528  }
14529 
14530  // transform null object into an object
14531  if (is_null())
14532  {
14533  m_type = value_t::object;
14534  m_value = value_t::object;
14535  assert_invariant();
14536  }
14538  // add element to array (perfect forwarding)
14539  auto res = m_value.object->emplace(std::forward<Args>(args)...);
14540  // create result iterator and set iterator to the result of emplace
14541  auto it = begin();
14542  it.m_it.object_iterator = res.first;
14543 
14544  // return pair of iterator and boolean
14545  return {it, res.second};
14546  }
14547 
14548  /*!
14549  @brief inserts element
14550 
14551  Inserts element @a val before iterator @a pos.
14552 
14553  @param[in] pos iterator before which the content will be inserted; may be
14554  the end() iterator
14555  @param[in] val element to insert
14556  @return iterator pointing to the inserted @a val.
14557 
14558  @throw type_error.309 if called on JSON values other than arrays;
14559  example: `"cannot use insert() with string"`
14560  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
14561  example: `"iterator does not fit current value"`
14562 
14563  @complexity Constant plus linear in the distance between @a pos and end of
14564  the container.
14565 
14566  @liveexample{The example shows how `insert()` is used.,insert}
14567 
14568  @since version 1.0.0
14569  */
14570  iterator insert(const_iterator pos, const basic_json& val)
14571  {
14572  // insert only works for arrays
14573  if (JSON_LIKELY(is_array()))
14574  {
14575  // check if iterator pos fits to this JSON value
14576  if (JSON_UNLIKELY(pos.m_object != this))
14577  {
14578  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
14579  }
14580 
14581  // insert to array and return iterator
14582  iterator result(this);
14583  result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
14584  return result;
14585  }
14586 
14587  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
14588  }
14589 
14590  /*!
14591  @brief inserts element
14592  @copydoc insert(const_iterator, const basic_json&)
14593  */
14594  iterator insert(const_iterator pos, basic_json&& val)
14595  {
14596  return insert(pos, val);
14597  }
14598 
14599  /*!
14600  @brief inserts elements
14601 
14602  Inserts @a cnt copies of @a val before iterator @a pos.
14603 
14604  @param[in] pos iterator before which the content will be inserted; may be
14605  the end() iterator
14606  @param[in] cnt number of copies of @a val to insert
14607  @param[in] val element to insert
14608  @return iterator pointing to the first element inserted, or @a pos if
14609  `cnt==0`
14610 
14611  @throw type_error.309 if called on JSON values other than arrays; example:
14612  `"cannot use insert() with string"`
14613  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
14614  example: `"iterator does not fit current value"`
14615 
14616  @complexity Linear in @a cnt plus linear in the distance between @a pos
14617  and end of the container.
14618 
14619  @liveexample{The example shows how `insert()` is used.,insert__count}
14620 
14621  @since version 1.0.0
14622  */
14623  iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
14624  {
14625  // insert only works for arrays
14626  if (JSON_LIKELY(is_array()))
14627  {
14628  // check if iterator pos fits to this JSON value
14629  if (JSON_UNLIKELY(pos.m_object != this))
14630  {
14631  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
14632  }
14633 
14634  // insert to array and return iterator
14635  iterator result(this);
14636  result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
14637  return result;
14638  }
14639 
14640  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
14641  }
14642 
14643  /*!
14644  @brief inserts elements
14645 
14646  Inserts elements from range `[first, last)` before iterator @a pos.
14647 
14648  @param[in] pos iterator before which the content will be inserted; may be
14649  the end() iterator
14650  @param[in] first begin of the range of elements to insert
14651  @param[in] last end of the range of elements to insert
14652 
14653  @throw type_error.309 if called on JSON values other than arrays; example:
14654  `"cannot use insert() with string"`
14655  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
14656  example: `"iterator does not fit current value"`
14657  @throw invalid_iterator.210 if @a first and @a last do not belong to the
14658  same JSON value; example: `"iterators do not fit"`
14659  @throw invalid_iterator.211 if @a first or @a last are iterators into
14660  container for which insert is called; example: `"passed iterators may not
14661  belong to container"`
14662 
14663  @return iterator pointing to the first element inserted, or @a pos if
14664  `first==last`
14665 
14666  @complexity Linear in `std::distance(first, last)` plus linear in the
14667  distance between @a pos and end of the container.
14668 
14669  @liveexample{The example shows how `insert()` is used.,insert__range}
14670 
14671  @since version 1.0.0
14672  */
14673  iterator insert(const_iterator pos, const_iterator first, const_iterator last)
14674  {
14675  // insert only works for arrays
14676  if (JSON_UNLIKELY(not is_array()))
14677  {
14678  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
14679  }
14680 
14681  // check if iterator pos fits to this JSON value
14682  if (JSON_UNLIKELY(pos.m_object != this))
14683  {
14684  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
14685  }
14686 
14687  // check if range iterators belong to the same JSON object
14688  if (JSON_UNLIKELY(first.m_object != last.m_object))
14689  {
14690  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
14691  }
14692 
14693  if (JSON_UNLIKELY(first.m_object == this))
14694  {
14695  JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
14696  }
14697 
14698  // insert to array and return iterator
14699  iterator result(this);
14700  result.m_it.array_iterator = m_value.array->insert(
14701  pos.m_it.array_iterator,
14702  first.m_it.array_iterator,
14703  last.m_it.array_iterator);
14704  return result;
14705  }
14706 
14707  /*!
14708  @brief inserts elements
14709 
14710  Inserts elements from initializer list @a ilist before iterator @a pos.
14711 
14712  @param[in] pos iterator before which the content will be inserted; may be
14713  the end() iterator
14714  @param[in] ilist initializer list to insert the values from
14715 
14716  @throw type_error.309 if called on JSON values other than arrays; example:
14717  `"cannot use insert() with string"`
14718  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
14719  example: `"iterator does not fit current value"`
14720 
14721  @return iterator pointing to the first element inserted, or @a pos if
14722  `ilist` is empty
14723 
14724  @complexity Linear in `ilist.size()` plus linear in the distance between
14725  @a pos and end of the container.
14726 
14727  @liveexample{The example shows how `insert()` is used.,insert__ilist}
14728 
14729  @since version 1.0.0
14730  */
14731  iterator insert(const_iterator pos, initializer_list_t ilist)
14732  {
14733  // insert only works for arrays
14734  if (JSON_UNLIKELY(not is_array()))
14735  {
14736  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
14737  }
14738 
14739  // check if iterator pos fits to this JSON value
14740  if (JSON_UNLIKELY(pos.m_object != this))
14741  {
14742  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
14743  }
14744 
14745  // insert to array and return iterator
14746  iterator result(this);
14747  result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist.begin(), ilist.end());
14748  return result;
14749  }
14750 
14751  /*!
14752  @brief inserts elements
14753 
14754  Inserts elements from range `[first, last)`.
14755 
14756  @param[in] first begin of the range of elements to insert
14757  @param[in] last end of the range of elements to insert
14758 
14759  @throw type_error.309 if called on JSON values other than objects; example:
14760  `"cannot use insert() with string"`
14761  @throw invalid_iterator.202 if iterator @a first or @a last does does not
14762  point to an object; example: `"iterators first and last must point to
14763  objects"`
14764  @throw invalid_iterator.210 if @a first and @a last do not belong to the
14765  same JSON value; example: `"iterators do not fit"`
14766 
14767  @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
14768  of elements to insert.
14769 
14770  @liveexample{The example shows how `insert()` is used.,insert__range_object}
14771 
14772  @since version 3.0.0
14773  */
14774  void insert(const_iterator first, const_iterator last)
14775  {
14776  // insert only works for objects
14777  if (JSON_UNLIKELY(not is_object()))
14778  {
14779  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
14780  }
14781 
14782  // check if range iterators belong to the same JSON object
14783  if (JSON_UNLIKELY(first.m_object != last.m_object))
14784  {
14785  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
14786  }
14787 
14788  // passed iterators must belong to objects
14789  if (JSON_UNLIKELY(not first.m_object->is_object()))
14790  {
14791  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
14792  }
14793 
14794  m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
14795  }
14796 
14797  /*!
14798  @brief updates a JSON object from another object, overwriting existing keys
14799 
14800  Inserts all values from JSON object @a j and overwrites existing keys.
14801 
14802  @param[in] j JSON object to read values from
14803 
14804  @throw type_error.312 if called on JSON values other than objects; example:
14805  `"cannot use update() with string"`
14806 
14807  @complexity O(N*log(size() + N)), where N is the number of elements to
14808  insert.
14809 
14810  @liveexample{The example shows how `update()` is used.,update}
14811 
14812  @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
14813 
14814  @since version 3.0.0
14815  */
14816  void update(const_reference j)
14817  {
14818  // implicitly convert null value to an empty object
14819  if (is_null())
14820  {
14821  m_type = value_t::object;
14822  m_value.object = create<object_t>();
14823  assert_invariant();
14824  }
14825 
14826  if (JSON_UNLIKELY(not is_object()))
14827  {
14828  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
14829  }
14830  if (JSON_UNLIKELY(not j.is_object()))
14831  {
14832  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
14833  }
14834 
14835  for (auto it = j.cbegin(); it != j.cend(); ++it)
14836  {
14837  m_value.object->operator[](it.key()) = it.value();
14838  }
14839  }
14840 
14841  /*!
14842  @brief updates a JSON object from another object, overwriting existing keys
14843 
14844  Inserts all values from from range `[first, last)` and overwrites existing
14845  keys.
14846 
14847  @param[in] first begin of the range of elements to insert
14848  @param[in] last end of the range of elements to insert
14849 
14850  @throw type_error.312 if called on JSON values other than objects; example:
14851  `"cannot use update() with string"`
14852  @throw invalid_iterator.202 if iterator @a first or @a last does does not
14853  point to an object; example: `"iterators first and last must point to
14854  objects"`
14855  @throw invalid_iterator.210 if @a first and @a last do not belong to the
14856  same JSON value; example: `"iterators do not fit"`
14857 
14858  @complexity O(N*log(size() + N)), where N is the number of elements to
14859  insert.
14860 
14861  @liveexample{The example shows how `update()` is used__range.,update}
14862 
14863  @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
14864 
14865  @since version 3.0.0
14866  */
14867  void update(const_iterator first, const_iterator last)
14868  {
14869  // implicitly convert null value to an empty object
14870  if (is_null())
14871  {
14872  m_type = value_t::object;
14873  m_value.object = create<object_t>();
14874  assert_invariant();
14875  }
14876 
14877  if (JSON_UNLIKELY(not is_object()))
14878  {
14879  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
14880  }
14881 
14882  // check if range iterators belong to the same JSON object
14883  if (JSON_UNLIKELY(first.m_object != last.m_object))
14884  {
14885  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
14886  }
14887 
14888  // passed iterators must belong to objects
14889  if (JSON_UNLIKELY(not first.m_object->is_object()
14890  or not last.m_object->is_object()))
14891  {
14892  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
14893  }
14894 
14895  for (auto it = first; it != last; ++it)
14896  {
14897  m_value.object->operator[](it.key()) = it.value();
14898  }
14899  }
14900 
14901  /*!
14902  @brief exchanges the values
14903 
14904  Exchanges the contents of the JSON value with those of @a other. Does not
14905  invoke any move, copy, or swap operations on individual elements. All
14906  iterators and references remain valid. The past-the-end iterator is
14907  invalidated.
14908 
14909  @param[in,out] other JSON value to exchange the contents with
14910 
14911  @complexity Constant.
14912 
14913  @liveexample{The example below shows how JSON values can be swapped with
14914  `swap()`.,swap__reference}
14915 
14916  @since version 1.0.0
14917  */
14918  void swap(reference other) noexcept (
14919  std::is_nothrow_move_constructible<value_t>::value and
14920  std::is_nothrow_move_assignable<value_t>::value and
14921  std::is_nothrow_move_constructible<json_value>::value and
14922  std::is_nothrow_move_assignable<json_value>::value
14923  )
14924  {
14925  std::swap(m_type, other.m_type);
14926  std::swap(m_value, other.m_value);
14927  assert_invariant();
14928  }
14929 
14930  /*!
14931  @brief exchanges the values
14932 
14933  Exchanges the contents of a JSON array with those of @a other. Does not
14934  invoke any move, copy, or swap operations on individual elements. All
14935  iterators and references remain valid. The past-the-end iterator is
14936  invalidated.
14937 
14938  @param[in,out] other array to exchange the contents with
14939 
14940  @throw type_error.310 when JSON value is not an array; example: `"cannot
14941  use swap() with string"`
14942 
14943  @complexity Constant.
14944 
14945  @liveexample{The example below shows how arrays can be swapped with
14946  `swap()`.,swap__array_t}
14947 
14948  @since version 1.0.0
14949  */
14950  void swap(array_t& other)
14951  {
14952  // swap only works for arrays
14953  if (JSON_LIKELY(is_array()))
14954  {
14955  std::swap(*(m_value.array), other);
14956  }
14957  else
14958  {
14959  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
14960  }
14961  }
14962 
14963  /*!
14964  @brief exchanges the values
14966  Exchanges the contents of a JSON object with those of @a other. Does not
14967  invoke any move, copy, or swap operations on individual elements. All
14968  iterators and references remain valid. The past-the-end iterator is
14969  invalidated.
14970 
14971  @param[in,out] other object to exchange the contents with
14972 
14973  @throw type_error.310 when JSON value is not an object; example:
14974  `"cannot use swap() with string"`
14975 
14976  @complexity Constant.
14977 
14978  @liveexample{The example below shows how objects can be swapped with
14979  `swap()`.,swap__object_t}
14980 
14981  @since version 1.0.0
14982  */
14983  void swap(object_t& other)
14984  {
14985  // swap only works for objects
14986  if (JSON_LIKELY(is_object()))
14987  {
14988  std::swap(*(m_value.object), other);
14989  }
14990  else
14991  {
14992  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
14993  }
14994  }
14995 
14996  /*!
14997  @brief exchanges the values
14999  Exchanges the contents of a JSON string with those of @a other. Does not
15000  invoke any move, copy, or swap operations on individual elements. All
15001  iterators and references remain valid. The past-the-end iterator is
15002  invalidated.
15003 
15004  @param[in,out] other string to exchange the contents with
15005 
15006  @throw type_error.310 when JSON value is not a string; example: `"cannot
15007  use swap() with boolean"`
15008 
15009  @complexity Constant.
15010 
15011  @liveexample{The example below shows how strings can be swapped with
15012  `swap()`.,swap__string_t}
15013 
15014  @since version 1.0.0
15015  */
15016  void swap(string_t& other)
15017  {
15018  // swap only works for strings
15019  if (JSON_LIKELY(is_string()))
15020  {
15021  std::swap(*(m_value.string), other);
15022  }
15023  else
15024  {
15025  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
15026  }
15027  }
15028 
15029  /// @}
15030 
15031  public:
15032  //////////////////////////////////////////
15033  // lexicographical comparison operators //
15034  //////////////////////////////////////////
15035 
15036  /// @name lexicographical comparison operators
15037  /// @{
15038 
15039  /*!
15040  @brief comparison: equal
15041 
15042  Compares two JSON values for equality according to the following rules:
15043  - Two JSON values are equal if (1) they are from the same type and (2)
15044  their stored values are the same according to their respective
15045  `operator==`.
15046  - Integer and floating-point numbers are automatically converted before
15047  comparison. Note than two NaN values are always treated as unequal.
15048  - Two JSON null values are equal.
15049 
15050  @note Floating-point inside JSON values numbers are compared with
15051  `json::number_float_t::operator==` which is `double::operator==` by
15052  default. To compare floating-point while respecting an epsilon, an alternative
15053  [comparison function](https://github.com/mariokonrad/marnav/blob/master/src/marnav/math/floatingpoint.hpp#L34-#L39)
15054  could be used, for instance
15055  @code {.cpp}
15056  template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
15057  inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
15058  {
15059  return std::abs(a - b) <= epsilon;
15060  }
15061  @endcode
15062 
15063  @note NaN values never compare equal to themselves or to other NaN values.
15064 
15065  @param[in] lhs first JSON value to consider
15066  @param[in] rhs second JSON value to consider
15067  @return whether the values @a lhs and @a rhs are equal
15068 
15069  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15070 
15071  @complexity Linear.
15072 
15073  @liveexample{The example demonstrates comparing several JSON
15074  types.,operator__equal}
15075 
15076  @since version 1.0.0
15077  */
15078  friend bool operator==(const_reference lhs, const_reference rhs) noexcept
15079  {
15080  const auto lhs_type = lhs.type();
15081  const auto rhs_type = rhs.type();
15082 
15083  if (lhs_type == rhs_type)
15084  {
15085  switch (lhs_type)
15086  {
15087  case value_t::array:
15088  return (*lhs.m_value.array == *rhs.m_value.array);
15089 
15090  case value_t::object:
15091  return (*lhs.m_value.object == *rhs.m_value.object);
15092 
15093  case value_t::null:
15094  return true;
15095 
15096  case value_t::string:
15097  return (*lhs.m_value.string == *rhs.m_value.string);
15098 
15099  case value_t::boolean:
15100  return (lhs.m_value.boolean == rhs.m_value.boolean);
15101 
15102  case value_t::number_integer:
15103  return (lhs.m_value.number_integer == rhs.m_value.number_integer);
15104 
15105  case value_t::number_unsigned:
15106  return (lhs.m_value.number_unsigned == rhs.m_value.number_unsigned);
15107 
15108  case value_t::number_float:
15109  return (lhs.m_value.number_float == rhs.m_value.number_float);
15110 
15111  default:
15112  return false;
15113  }
15114  }
15115  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
15116  {
15117  return (static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float);
15118  }
15119  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
15120  {
15121  return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer));
15122  }
15123  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
15124  {
15125  return (static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float);
15126  }
15127  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
15128  {
15129  return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned));
15130  }
15131  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
15132  {
15133  return (static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer);
15134  }
15135  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
15136  {
15137  return (lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned));
15138  }
15139 
15140  return false;
15141  }
15142 
15143  /*!
15144  @brief comparison: equal
15145  @copydoc operator==(const_reference, const_reference)
15146  */
15147  template<typename ScalarType, typename std::enable_if<
15148  std::is_scalar<ScalarType>::value, int>::type = 0>
15149  friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
15150  {
15151  return (lhs == basic_json(rhs));
15152  }
15153 
15154  /*!
15155  @brief comparison: equal
15156  @copydoc operator==(const_reference, const_reference)
15157  */
15158  template<typename ScalarType, typename std::enable_if<
15159  std::is_scalar<ScalarType>::value, int>::type = 0>
15160  friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
15161  {
15162  return (basic_json(lhs) == rhs);
15163  }
15165  /*!
15166  @brief comparison: not equal
15167 
15168  Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
15169 
15170  @param[in] lhs first JSON value to consider
15171  @param[in] rhs second JSON value to consider
15172  @return whether the values @a lhs and @a rhs are not equal
15173 
15174  @complexity Linear.
15176  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15177 
15178  @liveexample{The example demonstrates comparing several JSON
15179  types.,operator__notequal}
15180 
15181  @since version 1.0.0
15182  */
15183  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
15184  {
15185  return not (lhs == rhs);
15186  }
15187 
15188  /*!
15189  @brief comparison: not equal
15190  @copydoc operator!=(const_reference, const_reference)
15191  */
15192  template<typename ScalarType, typename std::enable_if<
15193  std::is_scalar<ScalarType>::value, int>::type = 0>
15194  friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
15195  {
15196  return (lhs != basic_json(rhs));
15197  }
15199  /*!
15200  @brief comparison: not equal
15201  @copydoc operator!=(const_reference, const_reference)
15202  */
15203  template<typename ScalarType, typename std::enable_if<
15204  std::is_scalar<ScalarType>::value, int>::type = 0>
15205  friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
15206  {
15207  return (basic_json(lhs) != rhs);
15208  }
15210  /*!
15211  @brief comparison: less than
15212 
15213  Compares whether one JSON value @a lhs is less than another JSON value @a
15214  rhs according to the following rules:
15215  - If @a lhs and @a rhs have the same type, the values are compared using
15216  the default `<` operator.
15217  - Integer and floating-point numbers are automatically converted before
15218  comparison
15219  - In case @a lhs and @a rhs have different types, the values are ignored
15220  and the order of the types is considered, see
15221  @ref operator<(const value_t, const value_t).
15222 
15223  @param[in] lhs first JSON value to consider
15224  @param[in] rhs second JSON value to consider
15225  @return whether @a lhs is less than @a rhs
15226 
15227  @complexity Linear.
15228 
15229  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15230 
15231  @liveexample{The example demonstrates comparing several JSON
15232  types.,operator__less}
15233 
15234  @since version 1.0.0
15235  */
15236  friend bool operator<(const_reference lhs, const_reference rhs) noexcept
15237  {
15238  const auto lhs_type = lhs.type();
15239  const auto rhs_type = rhs.type();
15240 
15241  if (lhs_type == rhs_type)
15242  {
15243  switch (lhs_type)
15244  {
15245  case value_t::array:
15246  return (*lhs.m_value.array) < (*rhs.m_value.array);
15247 
15248  case value_t::object:
15249  return *lhs.m_value.object < *rhs.m_value.object;
15250 
15251  case value_t::null:
15252  return false;
15253 
15254  case value_t::string:
15255  return *lhs.m_value.string < *rhs.m_value.string;
15256 
15257  case value_t::boolean:
15258  return lhs.m_value.boolean < rhs.m_value.boolean;
15259 
15260  case value_t::number_integer:
15261  return lhs.m_value.number_integer < rhs.m_value.number_integer;
15262 
15263  case value_t::number_unsigned:
15264  return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
15265 
15266  case value_t::number_float:
15267  return lhs.m_value.number_float < rhs.m_value.number_float;
15268 
15269  default:
15270  return false;
15271  }
15272  }
15273  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
15274  {
15275  return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
15276  }
15277  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
15278  {
15279  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
15280  }
15281  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
15282  {
15283  return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
15284  }
15285  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
15286  {
15287  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
15288  }
15289  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
15290  {
15291  return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
15292  }
15293  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
15294  {
15295  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
15296  }
15297 
15298  // We only reach this line if we cannot compare values. In that case,
15299  // we compare types. Note we have to call the operator explicitly,
15300  // because MSVC has problems otherwise.
15301  return operator<(lhs_type, rhs_type);
15302  }
15303 
15304  /*!
15305  @brief comparison: less than
15306  @copydoc operator<(const_reference, const_reference)
15307  */
15308  template<typename ScalarType, typename std::enable_if<
15309  std::is_scalar<ScalarType>::value, int>::type = 0>
15310  friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
15311  {
15312  return (lhs < basic_json(rhs));
15313  }
15314 
15315  /*!
15316  @brief comparison: less than
15317  @copydoc operator<(const_reference, const_reference)
15318  */
15319  template<typename ScalarType, typename std::enable_if<
15320  std::is_scalar<ScalarType>::value, int>::type = 0>
15321  friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
15322  {
15323  return (basic_json(lhs) < rhs);
15324  }
15326  /*!
15327  @brief comparison: less than or equal
15328 
15329  Compares whether one JSON value @a lhs is less than or equal to another
15330  JSON value by calculating `not (rhs < lhs)`.
15331 
15332  @param[in] lhs first JSON value to consider
15333  @param[in] rhs second JSON value to consider
15334  @return whether @a lhs is less than or equal to @a rhs
15335 
15336  @complexity Linear.
15337 
15338  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15339 
15340  @liveexample{The example demonstrates comparing several JSON
15341  types.,operator__greater}
15342 
15343  @since version 1.0.0
15344  */
15345  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
15346  {
15347  return not (rhs < lhs);
15348  }
15349 
15350  /*!
15351  @brief comparison: less than or equal
15352  @copydoc operator<=(const_reference, const_reference)
15353  */
15354  template<typename ScalarType, typename std::enable_if<
15355  std::is_scalar<ScalarType>::value, int>::type = 0>
15356  friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
15357  {
15358  return (lhs <= basic_json(rhs));
15359  }
15361  /*!
15362  @brief comparison: less than or equal
15363  @copydoc operator<=(const_reference, const_reference)
15364  */
15365  template<typename ScalarType, typename std::enable_if<
15366  std::is_scalar<ScalarType>::value, int>::type = 0>
15367  friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
15368  {
15369  return (basic_json(lhs) <= rhs);
15370  }
15372  /*!
15373  @brief comparison: greater than
15374 
15375  Compares whether one JSON value @a lhs is greater than another
15376  JSON value by calculating `not (lhs <= rhs)`.
15377 
15378  @param[in] lhs first JSON value to consider
15379  @param[in] rhs second JSON value to consider
15380  @return whether @a lhs is greater than to @a rhs
15381 
15382  @complexity Linear.
15383 
15384  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15385 
15386  @liveexample{The example demonstrates comparing several JSON
15387  types.,operator__lessequal}
15388 
15389  @since version 1.0.0
15390  */
15391  friend bool operator>(const_reference lhs, const_reference rhs) noexcept
15392  {
15393  return not (lhs <= rhs);
15394  }
15395 
15396  /*!
15397  @brief comparison: greater than
15398  @copydoc operator>(const_reference, const_reference)
15399  */
15400  template<typename ScalarType, typename std::enable_if<
15401  std::is_scalar<ScalarType>::value, int>::type = 0>
15402  friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
15403  {
15404  return (lhs > basic_json(rhs));
15405  }
15407  /*!
15408  @brief comparison: greater than
15409  @copydoc operator>(const_reference, const_reference)
15410  */
15411  template<typename ScalarType, typename std::enable_if<
15412  std::is_scalar<ScalarType>::value, int>::type = 0>
15413  friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
15414  {
15415  return (basic_json(lhs) > rhs);
15416  }
15418  /*!
15419  @brief comparison: greater than or equal
15420 
15421  Compares whether one JSON value @a lhs is greater than or equal to another
15422  JSON value by calculating `not (lhs < rhs)`.
15423 
15424  @param[in] lhs first JSON value to consider
15425  @param[in] rhs second JSON value to consider
15426  @return whether @a lhs is greater than or equal to @a rhs
15427 
15428  @complexity Linear.
15429 
15430  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15431 
15432  @liveexample{The example demonstrates comparing several JSON
15433  types.,operator__greaterequal}
15434 
15435  @since version 1.0.0
15436  */
15437  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
15438  {
15439  return not (lhs < rhs);
15440  }
15441 
15442  /*!
15443  @brief comparison: greater than or equal
15444  @copydoc operator>=(const_reference, const_reference)
15445  */
15446  template<typename ScalarType, typename std::enable_if<
15447  std::is_scalar<ScalarType>::value, int>::type = 0>
15448  friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
15449  {
15450  return (lhs >= basic_json(rhs));
15451  }
15453  /*!
15454  @brief comparison: greater than or equal
15455  @copydoc operator>=(const_reference, const_reference)
15456  */
15457  template<typename ScalarType, typename std::enable_if<
15458  std::is_scalar<ScalarType>::value, int>::type = 0>
15459  friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
15460  {
15461  return (basic_json(lhs) >= rhs);
15462  }
15464  /// @}
15465 
15466  ///////////////////
15467  // serialization //
15468  ///////////////////
15469 
15470  /// @name serialization
15471  /// @{
15472 
15473  /*!
15474  @brief serialize to stream
15475 
15476  Serialize the given JSON value @a j to the output stream @a o. The JSON
15477  value will be serialized using the @ref dump member function.
15478 
15479  - The indentation of the output can be controlled with the member variable
15480  `width` of the output stream @a o. For instance, using the manipulator
15481  `std::setw(4)` on @a o sets the indentation level to `4` and the
15482  serialization result is the same as calling `dump(4)`.
15483 
15484  - The indentation character can be controlled with the member variable
15485  `fill` of the output stream @a o. For instance, the manipulator
15486  `std::setfill('\\t')` sets indentation to use a tab character rather than
15487  the default space character.
15488 
15489  @param[in,out] o stream to serialize to
15490  @param[in] j JSON value to serialize
15491 
15492  @return the stream @a o
15493 
15494  @throw type_error.316 if a string stored inside the JSON value is not
15495  UTF-8 encoded
15496 
15497  @complexity Linear.
15498 
15499  @liveexample{The example below shows the serialization with different
15500  parameters to `width` to adjust the indentation level.,operator_serialize}
15501 
15502  @since version 1.0.0; indentation character added in version 3.0.0
15503  */
15504  friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
15505  {
15506  // read width member and use it as indentation parameter if nonzero
15507  const bool pretty_print = (o.width() > 0);
15508  const auto indentation = (pretty_print ? o.width() : 0);
15509 
15510  // reset width to 0 for subsequent calls to this stream
15511  o.width(0);
15512 
15513  // do the actual serialization
15514  serializer s(detail::output_adapter<char>(o), o.fill());
15515  s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
15516  return o;
15517  }
15518 
15519  /*!
15520  @brief serialize to stream
15521  @deprecated This stream operator is deprecated and will be removed in
15522  future 4.0.0 of the library. Please use
15523  @ref operator<<(std::ostream&, const basic_json&)
15524  instead; that is, replace calls like `j >> o;` with `o << j;`.
15525  @since version 1.0.0; deprecated since version 3.0.0
15526  */
15528  friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
15529  {
15530  return o << j;
15531  }
15532 
15533  /// @}
15534 
15535 
15536  /////////////////////
15537  // deserialization //
15538  /////////////////////
15539 
15540  /// @name deserialization
15541  /// @{
15542 
15543  /*!
15544  @brief deserialize from a compatible input
15545 
15546  This function reads from a compatible input. Examples are:
15547  - an array of 1-byte values
15548  - strings with character/literal type with size of 1 byte
15549  - input streams
15550  - container with contiguous storage of 1-byte values. Compatible container
15551  types include `std::vector`, `std::string`, `std::array`,
15552  `std::valarray`, and `std::initializer_list`. Furthermore, C-style
15553  arrays can be used with `std::begin()`/`std::end()`. User-defined
15554  containers can be used as long as they implement random-access iterators
15555  and a contiguous storage.
15556 
15557  @pre Each element of the container has a size of 1 byte. Violating this
15558  precondition yields undefined behavior. **This precondition is enforced
15559  with a static assertion.**
15560 
15561  @pre The container storage is contiguous. Violating this precondition
15562  yields undefined behavior. **This precondition is enforced with an
15563  assertion.**
15564  @pre Each element of the container has a size of 1 byte. Violating this
15565  precondition yields undefined behavior. **This precondition is enforced
15566  with a static assertion.**
15567 
15568  @warning There is no way to enforce all preconditions at compile-time. If
15569  the function is called with a noncompliant container and with
15570  assertions switched off, the behavior is undefined and will most
15571  likely yield segmentation violation.
15572 
15573  @param[in] i input to read from
15574  @param[in] cb a parser callback function of type @ref parser_callback_t
15575  which is used to control the deserialization by filtering unwanted values
15576  (optional)
15577 
15578  @return result of the deserialization
15579 
15580  @throw parse_error.101 if a parse error occurs; example: `""unexpected end
15581  of input; expected string literal""`
15582  @throw parse_error.102 if to_unicode fails or surrogate error
15583  @throw parse_error.103 if to_unicode fails
15584 
15585  @complexity Linear in the length of the input. The parser is a predictive
15586  LL(1) parser. The complexity can be higher if the parser callback function
15587  @a cb has a super-linear complexity.
15588 
15589  @note A UTF-8 byte order mark is silently ignored.
15590 
15591  @liveexample{The example below demonstrates the `parse()` function reading
15592  from an array.,parse__array__parser_callback_t}
15593 
15594  @liveexample{The example below demonstrates the `parse()` function with
15595  and without callback function.,parse__string__parser_callback_t}
15596 
15597  @liveexample{The example below demonstrates the `parse()` function with
15598  and without callback function.,parse__istream__parser_callback_t}
15599 
15600  @liveexample{The example below demonstrates the `parse()` function reading
15601  from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
15602 
15603  @since version 2.0.3 (contiguous containers)
15604  */
15605  static basic_json parse(detail::input_adapter i,
15606  const parser_callback_t cb = nullptr,
15607  const bool allow_exceptions = true)
15608  {
15609  basic_json result;
15610  parser(i, cb, allow_exceptions).parse(true, result);
15611  return result;
15612  }
15613 
15614  /*!
15615  @copydoc basic_json parse(detail::input_adapter, const parser_callback_t)
15616  */
15617  static basic_json parse(detail::input_adapter& i,
15618  const parser_callback_t cb = nullptr,
15619  const bool allow_exceptions = true)
15620  {
15621  basic_json result;
15622  parser(i, cb, allow_exceptions).parse(true, result);
15623  return result;
15624  }
15625 
15626  static bool accept(detail::input_adapter i)
15627  {
15628  return parser(i).accept(true);
15629  }
15630 
15631  static bool accept(detail::input_adapter& i)
15632  {
15633  return parser(i).accept(true);
15634  }
15635 
15636  /*!
15637  @brief deserialize from an iterator range with contiguous storage
15638 
15639  This function reads from an iterator range of a container with contiguous
15640  storage of 1-byte values. Compatible container types include
15641  `std::vector`, `std::string`, `std::array`, `std::valarray`, and
15642  `std::initializer_list`. Furthermore, C-style arrays can be used with
15643  `std::begin()`/`std::end()`. User-defined containers can be used as long
15644  as they implement random-access iterators and a contiguous storage.
15645 
15646  @pre The iterator range is contiguous. Violating this precondition yields
15647  undefined behavior. **This precondition is enforced with an assertion.**
15648  @pre Each element in the range has a size of 1 byte. Violating this
15649  precondition yields undefined behavior. **This precondition is enforced
15650  with a static assertion.**
15651 
15652  @warning There is no way to enforce all preconditions at compile-time. If
15653  the function is called with noncompliant iterators and with
15654  assertions switched off, the behavior is undefined and will most
15655  likely yield segmentation violation.
15656 
15657  @tparam IteratorType iterator of container with contiguous storage
15658  @param[in] first begin of the range to parse (included)
15659  @param[in] last end of the range to parse (excluded)
15660  @param[in] cb a parser callback function of type @ref parser_callback_t
15661  which is used to control the deserialization by filtering unwanted values
15662  (optional)
15663  @param[in] allow_exceptions whether to throw exceptions in case of a
15664  parse error (optional, true by default)
15665 
15666  @return result of the deserialization
15667 
15668  @throw parse_error.101 in case of an unexpected token
15669  @throw parse_error.102 if to_unicode fails or surrogate error
15670  @throw parse_error.103 if to_unicode fails
15671 
15672  @complexity Linear in the length of the input. The parser is a predictive
15673  LL(1) parser. The complexity can be higher if the parser callback function
15674  @a cb has a super-linear complexity.
15675 
15676  @note A UTF-8 byte order mark is silently ignored.
15677 
15678  @liveexample{The example below demonstrates the `parse()` function reading
15679  from an iterator range.,parse__iteratortype__parser_callback_t}
15680 
15681  @since version 2.0.3
15682  */
15683  template<class IteratorType, typename std::enable_if<
15684  std::is_base_of<
15685  std::random_access_iterator_tag,
15686  typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
15687  static basic_json parse(IteratorType first, IteratorType last,
15688  const parser_callback_t cb = nullptr,
15689  const bool allow_exceptions = true)
15690  {
15691  basic_json result;
15692  parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result);
15693  return result;
15694  }
15695 
15696  template<class IteratorType, typename std::enable_if<
15697  std::is_base_of<
15698  std::random_access_iterator_tag,
15699  typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
15700  static bool accept(IteratorType first, IteratorType last)
15701  {
15702  return parser(detail::input_adapter(first, last)).accept(true);
15703  }
15704 
15705  /*!
15706  @brief deserialize from stream
15707  @deprecated This stream operator is deprecated and will be removed in
15708  version 4.0.0 of the library. Please use
15709  @ref operator>>(std::istream&, basic_json&)
15710  instead; that is, replace calls like `j << i;` with `i >> j;`.
15711  @since version 1.0.0; deprecated since version 3.0.0
15712  */
15714  friend std::istream& operator<<(basic_json& j, std::istream& i)
15715  {
15716  return operator>>(i, j);
15717  }
15718 
15719  /*!
15720  @brief deserialize from stream
15721 
15722  Deserializes an input stream to a JSON value.
15723 
15724  @param[in,out] i input stream to read a serialized JSON value from
15725  @param[in,out] j JSON value to write the deserialized input to
15726 
15727  @throw parse_error.101 in case of an unexpected token
15728  @throw parse_error.102 if to_unicode fails or surrogate error
15729  @throw parse_error.103 if to_unicode fails
15730 
15731  @complexity Linear in the length of the input. The parser is a predictive
15732  LL(1) parser.
15733 
15734  @note A UTF-8 byte order mark is silently ignored.
15735 
15736  @liveexample{The example below shows how a JSON value is constructed by
15737  reading a serialization from a stream.,operator_deserialize}
15738 
15739  @sa parse(std::istream&, const parser_callback_t) for a variant with a
15740  parser callback function to filter values while parsing
15741 
15742  @since version 1.0.0
15743  */
15744  friend std::istream& operator>>(std::istream& i, basic_json& j)
15745  {
15746  parser(detail::input_adapter(i)).parse(false, j);
15747  return i;
15748  }
15749 
15750  /// @}
15751 
15752  ///////////////////////////
15753  // convenience functions //
15754  ///////////////////////////
15755 
15756  /*!
15757  @brief return the type as string
15758 
15759  Returns the type name as string to be used in error messages - usually to
15760  indicate that a function was called on a wrong JSON type.
15761 
15762  @return a string representation of a the @a m_type member:
15763  Value type | return value
15764  ----------- | -------------
15765  null | `"null"`
15766  boolean | `"boolean"`
15767  string | `"string"`
15768  number | `"number"` (for all number types)
15769  object | `"object"`
15770  array | `"array"`
15771  discarded | `"discarded"`
15772 
15773  @exceptionsafety No-throw guarantee: this function never throws exceptions.
15774 
15775  @complexity Constant.
15776 
15777  @liveexample{The following code exemplifies `type_name()` for all JSON
15778  types.,type_name}
15779 
15780  @sa @ref type() -- return the type of the JSON value
15781  @sa @ref operator value_t() -- return the type of the JSON value (implicit)
15782 
15783  @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
15784  since 3.0.0
15785  */
15786  const char* type_name() const noexcept
15787  {
15788  {
15789  switch (m_type)
15790  {
15791  case value_t::null:
15792  return "null";
15793  case value_t::object:
15794  return "object";
15795  case value_t::array:
15796  return "array";
15797  case value_t::string:
15798  return "string";
15799  case value_t::boolean:
15800  return "boolean";
15801  case value_t::discarded:
15802  return "discarded";
15803  default:
15804  return "number";
15805  }
15806  }
15807  }
15808 
15809 
15810  private:
15811  //////////////////////
15812  // member variables //
15813  //////////////////////
15814 
15815  /// the type of the current element
15816  value_t m_type = value_t::null;
15817 
15818  /// the value of the current element
15819  json_value m_value = {};
15820 
15821  //////////////////////////////////////////
15822  // binary serialization/deserialization //
15823  //////////////////////////////////////////
15824 
15825  /// @name binary serialization/deserialization support
15826  /// @{
15827 
15828  public:
15829  /*!
15830  @brief create a CBOR serialization of a given JSON value
15831 
15832  Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
15833  Binary Object Representation) serialization format. CBOR is a binary
15834  serialization format which aims to be more compact than JSON itself, yet
15835  more efficient to parse.
15836 
15837  The library uses the following mapping from JSON values types to
15838  CBOR types according to the CBOR specification (RFC 7049):
15839 
15840  JSON value type | value/range | CBOR type | first byte
15841  --------------- | ------------------------------------------ | ---------------------------------- | ---------------
15842  null | `null` | Null | 0xF6
15843  boolean | `true` | True | 0xF5
15844  boolean | `false` | False | 0xF4
15845  number_integer | -9223372036854775808..-2147483649 | Negative integer (8 bytes follow) | 0x3B
15846  number_integer | -2147483648..-32769 | Negative integer (4 bytes follow) | 0x3A
15847  number_integer | -32768..-129 | Negative integer (2 bytes follow) | 0x39
15848  number_integer | -128..-25 | Negative integer (1 byte follow) | 0x38
15849  number_integer | -24..-1 | Negative integer | 0x20..0x37
15850  number_integer | 0..23 | Integer | 0x00..0x17
15851  number_integer | 24..255 | Unsigned integer (1 byte follow) | 0x18
15852  number_integer | 256..65535 | Unsigned integer (2 bytes follow) | 0x19
15853  number_integer | 65536..4294967295 | Unsigned integer (4 bytes follow) | 0x1A
15854  number_integer | 4294967296..18446744073709551615 | Unsigned integer (8 bytes follow) | 0x1B
15855  number_unsigned | 0..23 | Integer | 0x00..0x17
15856  number_unsigned | 24..255 | Unsigned integer (1 byte follow) | 0x18
15857  number_unsigned | 256..65535 | Unsigned integer (2 bytes follow) | 0x19
15858  number_unsigned | 65536..4294967295 | Unsigned integer (4 bytes follow) | 0x1A
15859  number_unsigned | 4294967296..18446744073709551615 | Unsigned integer (8 bytes follow) | 0x1B
15860  number_float | *any value* | Double-Precision Float | 0xFB
15861  string | *length*: 0..23 | UTF-8 string | 0x60..0x77
15862  string | *length*: 23..255 | UTF-8 string (1 byte follow) | 0x78
15863  string | *length*: 256..65535 | UTF-8 string (2 bytes follow) | 0x79
15864  string | *length*: 65536..4294967295 | UTF-8 string (4 bytes follow) | 0x7A
15865  string | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow) | 0x7B
15866  array | *size*: 0..23 | array | 0x80..0x97
15867  array | *size*: 23..255 | array (1 byte follow) | 0x98
15868  array | *size*: 256..65535 | array (2 bytes follow) | 0x99
15869  array | *size*: 65536..4294967295 | array (4 bytes follow) | 0x9A
15870  array | *size*: 4294967296..18446744073709551615 | array (8 bytes follow) | 0x9B
15871  object | *size*: 0..23 | map | 0xA0..0xB7
15872  object | *size*: 23..255 | map (1 byte follow) | 0xB8
15873  object | *size*: 256..65535 | map (2 bytes follow) | 0xB9
15874  object | *size*: 65536..4294967295 | map (4 bytes follow) | 0xBA
15875  object | *size*: 4294967296..18446744073709551615 | map (8 bytes follow) | 0xBB
15876 
15877  @note The mapping is **complete** in the sense that any JSON value type
15878  can be converted to a CBOR value.
15879 
15880  @note If NaN or Infinity are stored inside a JSON number, they are
15881  serialized properly. This behavior differs from the @ref dump()
15882  function which serializes NaN or Infinity to `null`.
15883 
15884  @note The following CBOR types are not used in the conversion:
15885  - byte strings (0x40..0x5F)
15886  - UTF-8 strings terminated by "break" (0x7F)
15887  - arrays terminated by "break" (0x9F)
15888  - maps terminated by "break" (0xBF)
15889  - date/time (0xC0..0xC1)
15890  - bignum (0xC2..0xC3)
15891  - decimal fraction (0xC4)
15892  - bigfloat (0xC5)
15893  - tagged items (0xC6..0xD4, 0xD8..0xDB)
15894  - expected conversions (0xD5..0xD7)
15895  - simple values (0xE0..0xF3, 0xF8)
15896  - undefined (0xF7)
15897  - half and single-precision floats (0xF9-0xFA)
15898  - break (0xFF)
15899 
15900  @param[in] j JSON value to serialize
15901  @return MessagePack serialization as byte vector
15902 
15903  @complexity Linear in the size of the JSON value @a j.
15904 
15905  @liveexample{The example shows the serialization of a JSON value to a byte
15906  vector in CBOR format.,to_cbor}
15907 
15908  @sa http://cbor.io
15909  @sa @ref from_cbor(detail::input_adapter, const bool strict) for the
15910  analogous deserialization
15911  @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
15912  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
15913  related UBJSON format
15914 
15915  @since version 2.0.9
15916  */
15917  static std::vector<uint8_t> to_cbor(const basic_json& j)
15918  {
15919  std::vector<uint8_t> result;
15920  to_cbor(j, result);
15921  return result;
15922  }
15923 
15924  static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
15925  {
15926  binary_writer<uint8_t>(o).write_cbor(j);
15927  }
15928 
15929  static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
15930  {
15931  binary_writer<char>(o).write_cbor(j);
15932  }
15933 
15934  /*!
15935  @brief create a MessagePack serialization of a given JSON value
15936 
15937  Serializes a given JSON value @a j to a byte vector using the MessagePack
15938  serialization format. MessagePack is a binary serialization format which
15939  aims to be more compact than JSON itself, yet more efficient to parse.
15940 
15941  The library uses the following mapping from JSON values types to
15942  MessagePack types according to the MessagePack specification:
15943 
15944  JSON value type | value/range | MessagePack type | first byte
15945  --------------- | --------------------------------- | ---------------- | ----------
15946  null | `null` | nil | 0xC0
15947  boolean | `true` | true | 0xC3
15948  boolean | `false` | false | 0xC2
15949  number_integer | -9223372036854775808..-2147483649 | int64 | 0xD3
15950  number_integer | -2147483648..-32769 | int32 | 0xD2
15951  number_integer | -32768..-129 | int16 | 0xD1
15952  number_integer | -128..-33 | int8 | 0xD0
15953  number_integer | -32..-1 | negative fixint | 0xE0..0xFF
15954  number_integer | 0..127 | positive fixint | 0x00..0x7F
15955  number_integer | 128..255 | uint 8 | 0xCC
15956  number_integer | 256..65535 | uint 16 | 0xCD
15957  number_integer | 65536..4294967295 | uint 32 | 0xCE
15958  number_integer | 4294967296..18446744073709551615 | uint 64 | 0xCF
15959  number_unsigned | 0..127 | positive fixint | 0x00..0x7F
15960  number_unsigned | 128..255 | uint 8 | 0xCC
15961  number_unsigned | 256..65535 | uint 16 | 0xCD
15962  number_unsigned | 65536..4294967295 | uint 32 | 0xCE
15963  number_unsigned | 4294967296..18446744073709551615 | uint 64 | 0xCF
15964  number_float | *any value* | float 64 | 0xCB
15965  string | *length*: 0..31 | fixstr | 0xA0..0xBF
15966  string | *length*: 32..255 | str 8 | 0xD9
15967  string | *length*: 256..65535 | str 16 | 0xDA
15968  string | *length*: 65536..4294967295 | str 32 | 0xDB
15969  array | *size*: 0..15 | fixarray | 0x90..0x9F
15970  array | *size*: 16..65535 | array 16 | 0xDC
15971  array | *size*: 65536..4294967295 | array 32 | 0xDD
15972  object | *size*: 0..15 | fix map | 0x80..0x8F
15973  object | *size*: 16..65535 | map 16 | 0xDE
15974  object | *size*: 65536..4294967295 | map 32 | 0xDF
15975 
15976  @note The mapping is **complete** in the sense that any JSON value type
15977  can be converted to a MessagePack value.
15978 
15979  @note The following values can **not** be converted to a MessagePack value:
15980  - strings with more than 4294967295 bytes
15981  - arrays with more than 4294967295 elements
15982  - objects with more than 4294967295 elements
15983 
15984  @note The following MessagePack types are not used in the conversion:
15985  - bin 8 - bin 32 (0xC4..0xC6)
15986  - ext 8 - ext 32 (0xC7..0xC9)
15987  - float 32 (0xCA)
15988  - fixext 1 - fixext 16 (0xD4..0xD8)
15989 
15990  @note Any MessagePack output created @ref to_msgpack can be successfully
15991  parsed by @ref from_msgpack.
15992 
15993  @note If NaN or Infinity are stored inside a JSON number, they are
15994  serialized properly. This behavior differs from the @ref dump()
15995  function which serializes NaN or Infinity to `null`.
15996 
15997  @param[in] j JSON value to serialize
15998  @return MessagePack serialization as byte vector
15999 
16000  @complexity Linear in the size of the JSON value @a j.
16001 
16002  @liveexample{The example shows the serialization of a JSON value to a byte
16003  vector in MessagePack format.,to_msgpack}
16004 
16005  @sa http://msgpack.org
16006  @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the
16007  analogous deserialization
16008  @sa @ref to_cbor(const basic_json& for the related CBOR format
16009  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
16010  related UBJSON format
16011 
16012  @since version 2.0.9
16013  */
16014  static std::vector<uint8_t> to_msgpack(const basic_json& j)
16015  {
16016  std::vector<uint8_t> result;
16017  to_msgpack(j, result);
16018  return result;
16019  }
16020 
16021  static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
16022  {
16023  binary_writer<uint8_t>(o).write_msgpack(j);
16024  }
16025 
16026  static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
16027  {
16028  binary_writer<char>(o).write_msgpack(j);
16029  }
16030 
16031  /*!
16032  @brief create a UBJSON serialization of a given JSON value
16033 
16034  Serializes a given JSON value @a j to a byte vector using the UBJSON
16035  (Universal Binary JSON) serialization format. UBJSON aims to be more compact
16036  than JSON itself, yet more efficient to parse.
16037 
16038  The library uses the following mapping from JSON values types to
16039  UBJSON types according to the UBJSON specification:
16040 
16041  JSON value type | value/range | UBJSON type | marker
16042  --------------- | --------------------------------- | ----------- | ------
16043  null | `null` | null | `Z`
16044  boolean | `true` | true | `T`
16045  boolean | `false` | false | `F`
16046  number_integer | -9223372036854775808..-2147483649 | int64 | `L`
16047  number_integer | -2147483648..-32769 | int32 | `l`
16048  number_integer | -32768..-129 | int16 | `I`
16049  number_integer | -128..127 | int8 | `i`
16050  number_integer | 128..255 | uint8 | `U`
16051  number_integer | 256..32767 | int16 | `I`
16052  number_integer | 32768..2147483647 | int32 | `l`
16053  number_integer | 2147483648..9223372036854775807 | int64 | `L`
16054  number_unsigned | 0..127 | int8 | `i`
16055  number_unsigned | 128..255 | uint8 | `U`
16056  number_unsigned | 256..32767 | int16 | `I`
16057  number_unsigned | 32768..2147483647 | int32 | `l`
16058  number_unsigned | 2147483648..9223372036854775807 | int64 | `L`
16059  number_float | *any value* | float64 | `D`
16060  string | *with shortest length indicator* | string | `S`
16061  array | *see notes on optimized format* | array | `[`
16062  object | *see notes on optimized format* | map | `{`
16063 
16064  @note The mapping is **complete** in the sense that any JSON value type
16065  can be converted to a UBJSON value.
16066 
16067  @note The following values can **not** be converted to a UBJSON value:
16068  - strings with more than 9223372036854775807 bytes (theoretical)
16069  - unsigned integer numbers above 9223372036854775807
16070 
16071  @note The following markers are not used in the conversion:
16072  - `Z`: no-op values are not created.
16073  - `C`: single-byte strings are serialized with `S` markers.
16074 
16075  @note Any UBJSON output created @ref to_ubjson can be successfully parsed
16076  by @ref from_ubjson.
16077 
16078  @note If NaN or Infinity are stored inside a JSON number, they are
16079  serialized properly. This behavior differs from the @ref dump()
16080  function which serializes NaN or Infinity to `null`.
16081 
16082  @note The optimized formats for containers are supported: Parameter
16083  @a use_size adds size information to the beginning of a container and
16084  removes the closing marker. Parameter @a use_type further checks
16085  whether all elements of a container have the same type and adds the
16086  type marker to the beginning of the container. The @a use_type
16087  parameter must only be used together with @a use_size = true. Note
16088  that @a use_size = true alone may result in larger representations -
16089  the benefit of this parameter is that the receiving side is
16090  immediately informed on the number of elements of the container.
16091 
16092  @param[in] j JSON value to serialize
16093  @param[in] use_size whether to add size annotations to container types
16094  @param[in] use_type whether to add type annotations to container types
16095  (must be combined with @a use_size = true)
16096  @return UBJSON serialization as byte vector
16097 
16098  @complexity Linear in the size of the JSON value @a j.
16099 
16100  @liveexample{The example shows the serialization of a JSON value to a byte
16101  vector in UBJSON format.,to_ubjson}
16102 
16103  @sa http://ubjson.org
16104  @sa @ref from_ubjson(detail::input_adapter, const bool strict) for the
16105  analogous deserialization
16106  @sa @ref to_cbor(const basic_json& for the related CBOR format
16107  @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
16108 
16109  @since version 3.1.0
16110  */
16111  static std::vector<uint8_t> to_ubjson(const basic_json& j,
16112  const bool use_size = false,
16113  const bool use_type = false)
16114  {
16115  std::vector<uint8_t> result;
16116  to_ubjson(j, result, use_size, use_type);
16117  return result;
16118  }
16119 
16120  static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
16121  const bool use_size = false, const bool use_type = false)
16122  {
16123  binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
16124  }
16125 
16126  static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
16127  const bool use_size = false, const bool use_type = false)
16128  {
16129  binary_writer<char>(o).write_ubjson(j, use_size, use_type);
16130  }
16131 
16132  /*!
16133  @brief create a JSON value from an input in CBOR format
16134 
16135  Deserializes a given input @a i to a JSON value using the CBOR (Concise
16136  Binary Object Representation) serialization format.
16137 
16138  The library maps CBOR types to JSON value types as follows:
16139 
16140  CBOR type | JSON value type | first byte
16141  ---------------------- | --------------- | ----------
16142  Integer | number_unsigned | 0x00..0x17
16143  Unsigned integer | number_unsigned | 0x18
16144  Unsigned integer | number_unsigned | 0x19
16145  Unsigned integer | number_unsigned | 0x1A
16146  Unsigned integer | number_unsigned | 0x1B
16147  Negative integer | number_integer | 0x20..0x37
16148  Negative integer | number_integer | 0x38
16149  Negative integer | number_integer | 0x39
16150  Negative integer | number_integer | 0x3A
16151  Negative integer | number_integer | 0x3B
16152  Negative integer | number_integer | 0x40..0x57
16153  UTF-8 string | string | 0x60..0x77
16154  UTF-8 string | string | 0x78
16155  UTF-8 string | string | 0x79
16156  UTF-8 string | string | 0x7A
16157  UTF-8 string | string | 0x7B
16158  UTF-8 string | string | 0x7F
16159  array | array | 0x80..0x97
16160  array | array | 0x98
16161  array | array | 0x99
16162  array | array | 0x9A
16163  array | array | 0x9B
16164  array | array | 0x9F
16165  map | object | 0xA0..0xB7
16166  map | object | 0xB8
16167  map | object | 0xB9
16168  map | object | 0xBA
16169  map | object | 0xBB
16170  map | object | 0xBF
16171  False | `false` | 0xF4
16172  True | `true` | 0xF5
16173  Nill | `null` | 0xF6
16174  Half-Precision Float | number_float | 0xF9
16175  Single-Precision Float | number_float | 0xFA
16176  Double-Precision Float | number_float | 0xFB
16177 
16178  @warning The mapping is **incomplete** in the sense that not all CBOR
16179  types can be converted to a JSON value. The following CBOR types
16180  are not supported and will yield parse errors (parse_error.112):
16181  - byte strings (0x40..0x5F)
16182  - date/time (0xC0..0xC1)
16183  - bignum (0xC2..0xC3)
16184  - decimal fraction (0xC4)
16185  - bigfloat (0xC5)
16186  - tagged items (0xC6..0xD4, 0xD8..0xDB)
16187  - expected conversions (0xD5..0xD7)
16188  - simple values (0xE0..0xF3, 0xF8)
16189  - undefined (0xF7)
16190 
16191  @warning CBOR allows map keys of any type, whereas JSON only allows
16192  strings as keys in object values. Therefore, CBOR maps with keys
16193  other than UTF-8 strings are rejected (parse_error.113).
16194 
16195  @note Any CBOR output created @ref to_cbor can be successfully parsed by
16196  @ref from_cbor.
16197 
16198  @param[in] i an input in CBOR format convertible to an input adapter
16199  @param[in] strict whether to expect the input to be consumed until EOF
16200  (true by default)
16201  @return deserialized JSON value
16202 
16203  @throw parse_error.110 if the given input ends prematurely or the end of
16204  file was not reached when @a strict was set to true
16205  @throw parse_error.112 if unsupported features from CBOR were
16206  used in the given input @a v or if the input is not valid CBOR
16207  @throw parse_error.113 if a string was expected as map key, but not found
16208 
16209  @complexity Linear in the size of the input @a i.
16210 
16211  @liveexample{The example shows the deserialization of a byte vector in CBOR
16212  format to a JSON value.,from_cbor}
16213 
16214  @sa http://cbor.io
16215  @sa @ref to_cbor(const basic_json&) for the analogous serialization
16216  @sa @ref from_msgpack(detail::input_adapter, const bool) for the
16217  related MessagePack format
16218  @sa @ref from_ubjson(detail::input_adapter, const bool) for the related
16219  UBJSON format
16220 
16221  @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
16222  consume input adapters, removed start_index parameter, and added
16223  @a strict parameter since 3.0.0
16224  */
16225  static basic_json from_cbor(detail::input_adapter i,
16226  const bool strict = true)
16227  {
16228  return binary_reader(i).parse_cbor(strict);
16229  }
16230 
16231  /*!
16232  @copydoc from_cbor(detail::input_adapter, const bool)
16233  */
16234  template<typename A1, typename A2,
16235  detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
16236  static basic_json from_cbor(A1 && a1, A2 && a2, const bool strict = true)
16237  {
16238  return binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).parse_cbor(strict);
16239  }
16241  /*!
16242  @brief create a JSON value from an input in MessagePack format
16243 
16244  Deserializes a given input @a i to a JSON value using the MessagePack
16245  serialization format.
16246 
16247  The library maps MessagePack types to JSON value types as follows:
16248 
16249  MessagePack type | JSON value type | first byte
16250  ---------------- | --------------- | ----------
16251  positive fixint | number_unsigned | 0x00..0x7F
16252  fixmap | object | 0x80..0x8F
16253  fixarray | array | 0x90..0x9F
16254  fixstr | string | 0xA0..0xBF
16255  nil | `null` | 0xC0
16256  false | `false` | 0xC2
16257  true | `true` | 0xC3
16258  float 32 | number_float | 0xCA
16259  float 64 | number_float | 0xCB
16260  uint 8 | number_unsigned | 0xCC
16261  uint 16 | number_unsigned | 0xCD
16262  uint 32 | number_unsigned | 0xCE
16263  uint 64 | number_unsigned | 0xCF
16264  int 8 | number_integer | 0xD0
16265  int 16 | number_integer | 0xD1
16266  int 32 | number_integer | 0xD2
16267  int 64 | number_integer | 0xD3
16268  str 8 | string | 0xD9
16269  str 16 | string | 0xDA
16270  str 32 | string | 0xDB
16271  array 16 | array | 0xDC
16272  array 32 | array | 0xDD
16273  map 16 | object | 0xDE
16274  map 32 | object | 0xDF
16275  negative fixint | number_integer | 0xE0-0xFF
16276 
16277  @warning The mapping is **incomplete** in the sense that not all
16278  MessagePack types can be converted to a JSON value. The following
16279  MessagePack types are not supported and will yield parse errors:
16280  - bin 8 - bin 32 (0xC4..0xC6)
16281  - ext 8 - ext 32 (0xC7..0xC9)
16282  - fixext 1 - fixext 16 (0xD4..0xD8)
16283 
16284  @note Any MessagePack output created @ref to_msgpack can be successfully
16285  parsed by @ref from_msgpack.
16286 
16287  @param[in] i an input in MessagePack format convertible to an input
16288  adapter
16289  @param[in] strict whether to expect the input to be consumed until EOF
16290  (true by default)
16291 
16292  @throw parse_error.110 if the given input ends prematurely or the end of
16293  file was not reached when @a strict was set to true
16294  @throw parse_error.112 if unsupported features from MessagePack were
16295  used in the given input @a i or if the input is not valid MessagePack
16296  @throw parse_error.113 if a string was expected as map key, but not found
16297 
16298  @complexity Linear in the size of the input @a i.
16299 
16300  @liveexample{The example shows the deserialization of a byte vector in
16301  MessagePack format to a JSON value.,from_msgpack}
16302 
16303  @sa http://msgpack.org
16304  @sa @ref to_msgpack(const basic_json&) for the analogous serialization
16305  @sa @ref from_cbor(detail::input_adapter, const bool) for the related CBOR
16306  format
16307  @sa @ref from_ubjson(detail::input_adapter, const bool) for the related
16308  UBJSON format
16309 
16310  @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
16311  consume input adapters, removed start_index parameter, and added
16312  @a strict parameter since 3.0.0
16313  */
16314  static basic_json from_msgpack(detail::input_adapter i,
16315  const bool strict = true)
16316  {
16317  return binary_reader(i).parse_msgpack(strict);
16318  }
16319 
16320  /*!
16321  @copydoc from_msgpack(detail::input_adapter, const bool)
16322  */
16323  template<typename A1, typename A2,
16324  detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
16325  static basic_json from_msgpack(A1 && a1, A2 && a2, const bool strict = true)
16326  {
16327  return binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).parse_msgpack(strict);
16328  }
16330  /*!
16331  @brief create a JSON value from an input in UBJSON format
16332 
16333  Deserializes a given input @a i to a JSON value using the UBJSON (Universal
16334  Binary JSON) serialization format.
16335 
16336  The library maps UBJSON types to JSON value types as follows:
16337 
16338  UBJSON type | JSON value type | marker
16339  ----------- | --------------------------------------- | ------
16340  no-op | *no value, next value is read* | `N`
16341  null | `null` | `Z`
16342  false | `false` | `F`
16343  true | `true` | `T`
16344  float32 | number_float | `d`
16345  float64 | number_float | `D`
16346  uint8 | number_unsigned | `U`
16347  int8 | number_integer | `i`
16348  int16 | number_integer | `I`
16349  int32 | number_integer | `l`
16350  int64 | number_integer | `L`
16351  string | string | `S`
16352  char | string | `C`
16353  array | array (optimized values are supported) | `[`
16354  object | object (optimized values are supported) | `{`
16355 
16356  @note The mapping is **complete** in the sense that any UBJSON value can
16357  be converted to a JSON value.
16358 
16359  @param[in] i an input in UBJSON format convertible to an input adapter
16360  @param[in] strict whether to expect the input to be consumed until EOF
16361  (true by default)
16362 
16363  @throw parse_error.110 if the given input ends prematurely or the end of
16364  file was not reached when @a strict was set to true
16365  @throw parse_error.112 if a parse error occurs
16366  @throw parse_error.113 if a string could not be parsed successfully
16367 
16368  @complexity Linear in the size of the input @a i.
16369 
16370  @liveexample{The example shows the deserialization of a byte vector in
16371  UBJSON format to a JSON value.,from_ubjson}
16372 
16373  @sa http://ubjson.org
16374  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
16375  analogous serialization
16376  @sa @ref from_cbor(detail::input_adapter, const bool) for the related CBOR
16377  format
16378  @sa @ref from_msgpack(detail::input_adapter, const bool) for the related
16379  MessagePack format
16380 
16381  @since version 3.1.0
16382  */
16383  static basic_json from_ubjson(detail::input_adapter i,
16384  const bool strict = true)
16385  {
16386  return binary_reader(i).parse_ubjson(strict);
16387  }
16388 
16389  template<typename A1, typename A2,
16390  detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
16391  static basic_json from_ubjson(A1 && a1, A2 && a2, const bool strict = true)
16392  {
16393  return binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).parse_ubjson(strict);
16394  }
16395 
16396  /// @}
16397 
16398  //////////////////////////
16399  // JSON Pointer support //
16400  //////////////////////////
16401 
16402  /// @name JSON Pointer functions
16403  /// @{
16404 
16405  /*!
16406  @brief access specified element via JSON Pointer
16407 
16408  Uses a JSON pointer to retrieve a reference to the respective JSON value.
16409  No bound checking is performed. Similar to @ref operator[](const typename
16410  object_t::key_type&), `null` values are created in arrays and objects if
16411  necessary.
16412 
16413  In particular:
16414  - If the JSON pointer points to an object key that does not exist, it
16415  is created an filled with a `null` value before a reference to it
16416  is returned.
16417  - If the JSON pointer points to an array index that does not exist, it
16418  is created an filled with a `null` value before a reference to it
16419  is returned. All indices between the current maximum and the given
16420  index are also filled with `null`.
16421  - The special value `-` is treated as a synonym for the index past the
16422  end.
16423 
16424  @param[in] ptr a JSON pointer
16425 
16426  @return reference to the element pointed to by @a ptr
16427 
16428  @complexity Constant.
16429 
16430  @throw parse_error.106 if an array index begins with '0'
16431  @throw parse_error.109 if an array index was not a number
16432  @throw out_of_range.404 if the JSON pointer can not be resolved
16433 
16434  @liveexample{The behavior is shown in the example.,operatorjson_pointer}
16435 
16436  @since version 2.0.0
16437  */
16438  reference operator[](const json_pointer& ptr)
16439  {
16440  return ptr.get_unchecked(this);
16441  }
16442 
16443  /*!
16444  @brief access specified element via JSON Pointer
16445 
16446  Uses a JSON pointer to retrieve a reference to the respective JSON value.
16447  No bound checking is performed. The function does not change the JSON
16448  value; no `null` values are created. In particular, the the special value
16449  `-` yields an exception.
16450 
16451  @param[in] ptr JSON pointer to the desired element
16452 
16453  @return const reference to the element pointed to by @a ptr
16454 
16455  @complexity Constant.
16456 
16457  @throw parse_error.106 if an array index begins with '0'
16458  @throw parse_error.109 if an array index was not a number
16459  @throw out_of_range.402 if the array index '-' is used
16460  @throw out_of_range.404 if the JSON pointer can not be resolved
16461 
16462  @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
16463 
16464  @since version 2.0.0
16465  */
16466  const_reference operator[](const json_pointer& ptr) const
16467  {
16468  return ptr.get_unchecked(this);
16469  }
16470 
16471  /*!
16472  @brief access specified element via JSON Pointer
16473 
16474  Returns a reference to the element at with specified JSON pointer @a ptr,
16475  with bounds checking.
16476 
16477  @param[in] ptr JSON pointer to the desired element
16478 
16479  @return reference to the element pointed to by @a ptr
16480 
16481  @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
16482  begins with '0'. See example below.
16483 
16484  @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
16485  is not a number. See example below.
16486 
16487  @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
16488  is out of range. See example below.
16489 
16490  @throw out_of_range.402 if the array index '-' is used in the passed JSON
16491  pointer @a ptr. As `at` provides checked access (and no elements are
16492  implicitly inserted), the index '-' is always invalid. See example below.
16493 
16494  @throw out_of_range.403 if the JSON pointer describes a key of an object
16495  which cannot be found. See example below.
16496 
16497  @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
16498  See example below.
16499 
16500  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
16501  changes in the JSON value.
16502 
16503  @complexity Constant.
16504 
16505  @since version 2.0.0
16506 
16507  @liveexample{The behavior is shown in the example.,at_json_pointer}
16508  */
16509  reference at(const json_pointer& ptr)
16510  {
16511  return ptr.get_checked(this);
16512  }
16513 
16514  /*!
16515  @brief access specified element via JSON Pointer
16516 
16517  Returns a const reference to the element at with specified JSON pointer @a
16518  ptr, with bounds checking.
16519 
16520  @param[in] ptr JSON pointer to the desired element
16521 
16522  @return reference to the element pointed to by @a ptr
16523 
16524  @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
16525  begins with '0'. See example below.
16526 
16527  @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
16528  is not a number. See example below.
16529 
16530  @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
16531  is out of range. See example below.
16532 
16533  @throw out_of_range.402 if the array index '-' is used in the passed JSON
16534  pointer @a ptr. As `at` provides checked access (and no elements are
16535  implicitly inserted), the index '-' is always invalid. See example below.
16536 
16537  @throw out_of_range.403 if the JSON pointer describes a key of an object
16538  which cannot be found. See example below.
16539 
16540  @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
16541  See example below.
16542 
16543  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
16544  changes in the JSON value.
16545 
16546  @complexity Constant.
16547 
16548  @since version 2.0.0
16549 
16550  @liveexample{The behavior is shown in the example.,at_json_pointer_const}
16551  */
16552  const_reference at(const json_pointer& ptr) const
16553  {
16554  return ptr.get_checked(this);
16555  }
16556 
16557  /*!
16558  @brief return flattened JSON value
16559 
16560  The function creates a JSON object whose keys are JSON pointers (see [RFC
16561  6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
16562  primitive. The original JSON value can be restored using the @ref
16563  unflatten() function.
16564 
16565  @return an object that maps JSON pointers to primitive values
16566 
16567  @note Empty objects and arrays are flattened to `null` and will not be
16568  reconstructed correctly by the @ref unflatten() function.
16569 
16570  @complexity Linear in the size the JSON value.
16571 
16572  @liveexample{The following code shows how a JSON object is flattened to an
16573  object whose keys consist of JSON pointers.,flatten}
16574 
16575  @sa @ref unflatten() for the reverse function
16576 
16577  @since version 2.0.0
16578  */
16579  basic_json flatten() const
16580  {
16581  basic_json result(value_t::object);
16582  json_pointer::flatten("", *this, result);
16583  return result;
16584  }
16585 
16586  /*!
16587  @brief unflatten a previously flattened JSON value
16588 
16589  The function restores the arbitrary nesting of a JSON value that has been
16590  flattened before using the @ref flatten() function. The JSON value must
16591  meet certain constraints:
16592  1. The value must be an object.
16593  2. The keys must be JSON pointers (see
16594  [RFC 6901](https://tools.ietf.org/html/rfc6901))
16595  3. The mapped values must be primitive JSON types.
16596 
16597  @return the original JSON from a flattened version
16598 
16599  @note Empty objects and arrays are flattened by @ref flatten() to `null`
16600  values and can not unflattened to their original type. Apart from
16601  this example, for a JSON value `j`, the following is always true:
16602  `j == j.flatten().unflatten()`.
16603 
16604  @complexity Linear in the size the JSON value.
16605 
16606  @throw type_error.314 if value is not an object
16607  @throw type_error.315 if object values are not primitive
16608 
16609  @liveexample{The following code shows how a flattened JSON object is
16610  unflattened into the original nested JSON object.,unflatten}
16611 
16612  @sa @ref flatten() for the reverse function
16613 
16614  @since version 2.0.0
16615  */
16616  basic_json unflatten() const
16617  {
16618  return json_pointer::unflatten(*this);
16619  }
16620 
16621  /// @}
16622 
16623  //////////////////////////
16624  // JSON Patch functions //
16625  //////////////////////////
16626 
16627  /// @name JSON Patch functions
16628  /// @{
16629 
16630  /*!
16631  @brief applies a JSON patch
16632 
16633  [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
16634  expressing a sequence of operations to apply to a JSON) document. With
16635  this function, a JSON Patch is applied to the current JSON value by
16636  executing all operations from the patch.
16637 
16638  @param[in] json_patch JSON patch document
16639  @return patched document
16640 
16641  @note The application of a patch is atomic: Either all operations succeed
16642  and the patched document is returned or an exception is thrown. In
16643  any case, the original value is not changed: the patch is applied
16644  to a copy of the value.
16645 
16646  @throw parse_error.104 if the JSON patch does not consist of an array of
16647  objects
16648 
16649  @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
16650  attributes are missing); example: `"operation add must have member path"`
16651 
16652  @throw out_of_range.401 if an array index is out of range.
16653 
16654  @throw out_of_range.403 if a JSON pointer inside the patch could not be
16655  resolved successfully in the current JSON value; example: `"key baz not
16656  found"`
16657 
16658  @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
16659  "move")
16660 
16661  @throw other_error.501 if "test" operation was unsuccessful
16662 
16663  @complexity Linear in the size of the JSON value and the length of the
16664  JSON patch. As usually only a fraction of the JSON value is affected by
16665  the patch, the complexity can usually be neglected.
16666 
16667  @liveexample{The following code shows how a JSON patch is applied to a
16668  value.,patch}
16669 
16670  @sa @ref diff -- create a JSON patch by comparing two JSON values
16671 
16672  @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
16673  @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
16674 
16675  @since version 2.0.0
16676  */
16677  basic_json patch(const basic_json& json_patch) const
16678  {
16679  // make a working copy to apply the patch to
16680  basic_json result = *this;
16681 
16682  // the valid JSON Patch operations
16683  enum class patch_operations {add, remove, replace, move, copy, test, invalid};
16684 
16685  const auto get_op = [](const std::string & op)
16686  {
16687  if (op == "add")
16688  {
16689  return patch_operations::add;
16690  }
16691  if (op == "remove")
16692  {
16693  return patch_operations::remove;
16694  }
16695  if (op == "replace")
16696  {
16697  return patch_operations::replace;
16698  }
16699  if (op == "move")
16700  {
16701  return patch_operations::move;
16702  }
16703  if (op == "copy")
16704  {
16705  return patch_operations::copy;
16706  }
16707  if (op == "test")
16708  {
16709  return patch_operations::test;
16710  }
16711 
16712  return patch_operations::invalid;
16713  };
16714 
16715  // wrapper for "add" operation; add value at ptr
16716  const auto operation_add = [&result](json_pointer & ptr, basic_json val)
16717  {
16718  // adding to the root of the target document means replacing it
16719  if (ptr.is_root())
16720  {
16721  result = val;
16722  }
16723  else
16724  {
16725  // make sure the top element of the pointer exists
16726  json_pointer top_pointer = ptr.top();
16727  if (top_pointer != ptr)
16728  {
16729  result.at(top_pointer);
16730  }
16731 
16732  // get reference to parent of JSON pointer ptr
16733  const auto last_path = ptr.pop_back();
16734  basic_json& parent = result[ptr];
16735 
16736  switch (parent.m_type)
16737  {
16738  case value_t::null:
16739  case value_t::object:
16740  {
16741  // use operator[] to add value
16742  parent[last_path] = val;
16743  break;
16744  }
16745 
16746  case value_t::array:
16747  {
16748  if (last_path == "-")
16749  {
16750  // special case: append to back
16751  parent.push_back(val);
16752  }
16753  else
16754  {
16755  const auto idx = json_pointer::array_index(last_path);
16756  if (JSON_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
16757  {
16758  // avoid undefined behavior
16759  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
16760  }
16761  else
16762  {
16763  // default case: insert add offset
16764  parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
16765  }
16766  }
16767  break;
16768  }
16769 
16770  default:
16771  {
16772  // if there exists a parent it cannot be primitive
16773  assert(false); // LCOV_EXCL_LINE
16774  }
16775  }
16776  }
16777  };
16778 
16779  // wrapper for "remove" operation; remove value at ptr
16780  const auto operation_remove = [&result](json_pointer & ptr)
16781  {
16782  // get reference to parent of JSON pointer ptr
16783  const auto last_path = ptr.pop_back();
16784  basic_json& parent = result.at(ptr);
16785 
16786  // remove child
16787  if (parent.is_object())
16788  {
16789  // perform range check
16790  auto it = parent.find(last_path);
16791  if (JSON_LIKELY(it != parent.end()))
16792  {
16793  parent.erase(it);
16794  }
16795  else
16796  {
16797  JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
16798  }
16799  }
16800  else if (parent.is_array())
16801  {
16802  // note erase performs range check
16803  parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
16804  }
16805  };
16806 
16807  // type check: top level value must be an array
16808  if (JSON_UNLIKELY(not json_patch.is_array()))
16809  {
16810  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
16811  }
16812 
16813  // iterate and apply the operations
16814  for (const auto& val : json_patch)
16815  {
16816  // wrapper to get a value for an operation
16817  const auto get_value = [&val](const std::string & op,
16818  const std::string & member,
16819  bool string_type) -> basic_json &
16820  {
16821  // find value
16822  auto it = val.m_value.object->find(member);
16823 
16824  // context-sensitive error message
16825  const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
16826 
16827  // check if desired value is present
16828  if (JSON_UNLIKELY(it == val.m_value.object->end()))
16829  {
16830  JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
16831  }
16832 
16833  // check if result is of type string
16834  if (JSON_UNLIKELY(string_type and not it->second.is_string()))
16835  {
16836  JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
16837  }
16838 
16839  // no error: return value
16840  return it->second;
16841  };
16842 
16843  // type check: every element of the array must be an object
16844  if (JSON_UNLIKELY(not val.is_object()))
16845  {
16846  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
16847  }
16848 
16849  // collect mandatory members
16850  const std::string op = get_value("op", "op", true);
16851  const std::string path = get_value(op, "path", true);
16852  json_pointer ptr(path);
16853 
16854  switch (get_op(op))
16855  {
16856  case patch_operations::add:
16857  {
16858  operation_add(ptr, get_value("add", "value", false));
16859  break;
16860  }
16861 
16862  case patch_operations::remove:
16863  {
16864  operation_remove(ptr);
16865  break;
16866  }
16867 
16868  case patch_operations::replace:
16869  {
16870  // the "path" location must exist - use at()
16871  result.at(ptr) = get_value("replace", "value", false);
16872  break;
16873  }
16874 
16875  case patch_operations::move:
16876  {
16877  const std::string from_path = get_value("move", "from", true);
16878  json_pointer from_ptr(from_path);
16879 
16880  // the "from" location must exist - use at()
16881  basic_json v = result.at(from_ptr);
16882 
16883  // The move operation is functionally identical to a
16884  // "remove" operation on the "from" location, followed
16885  // immediately by an "add" operation at the target
16886  // location with the value that was just removed.
16887  operation_remove(from_ptr);
16888  operation_add(ptr, v);
16889  break;
16890  }
16891 
16892  case patch_operations::copy:
16893  {
16894  const std::string from_path = get_value("copy", "from", true);
16895  const json_pointer from_ptr(from_path);
16896 
16897  // the "from" location must exist - use at()
16898  basic_json v = result.at(from_ptr);
16899 
16900  // The copy is functionally identical to an "add"
16901  // operation at the target location using the value
16902  // specified in the "from" member.
16903  operation_add(ptr, v);
16904  break;
16905  }
16906 
16907  case patch_operations::test:
16908  {
16909  bool success = false;
16910  JSON_TRY
16911  {
16912  // check if "value" matches the one at "path"
16913  // the "path" location must exist - use at()
16914  success = (result.at(ptr) == get_value("test", "value", false));
16915  }
16916  JSON_CATCH (out_of_range&)
16917  {
16918  // ignore out of range errors: success remains false
16919  }
16920 
16921  // throw an exception if test fails
16922  if (JSON_UNLIKELY(not success))
16923  {
16924  JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
16925  }
16926 
16927  break;
16928  }
16929 
16930  case patch_operations::invalid:
16931  {
16932  // op must be "add", "remove", "replace", "move", "copy", or
16933  // "test"
16934  JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
16935  }
16936  }
16937  }
16938 
16939  return result;
16940  }
16941 
16942  /*!
16943  @brief creates a diff as a JSON patch
16944 
16945  Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
16946  be changed into the value @a target by calling @ref patch function.
16947 
16948  @invariant For two JSON values @a source and @a target, the following code
16949  yields always `true`:
16950  @code {.cpp}
16951  source.patch(diff(source, target)) == target;
16952  @endcode
16953 
16954  @note Currently, only `remove`, `add`, and `replace` operations are
16955  generated.
16956 
16957  @param[in] source JSON value to compare from
16958  @param[in] target JSON value to compare against
16959  @param[in] path helper value to create JSON pointers
16960 
16961  @return a JSON patch to convert the @a source to @a target
16962 
16963  @complexity Linear in the lengths of @a source and @a target.
16964 
16965  @liveexample{The following code shows how a JSON patch is created as a
16966  diff for two JSON values.,diff}
16967 
16968  @sa @ref patch -- apply a JSON patch
16969  @sa @ref merge_patch -- apply a JSON Merge Patch
16970 
16971  @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
16972 
16973  @since version 2.0.0
16974  */
16975  static basic_json diff(const basic_json& source, const basic_json& target,
16976  const std::string& path = "")
16977  {
16978  // the patch
16979  basic_json result(value_t::array);
16980 
16981  // if the values are the same, return empty patch
16982  if (source == target)
16983  {
16984  return result;
16985  }
16986 
16987  if (source.type() != target.type())
16988  {
16989  // different types: replace value
16990  result.push_back(
16991  {
16992  {"op", "replace"}, {"path", path}, {"value", target}
16993  });
16994  }
16995  else
16996  {
16997  switch (source.type())
16998  {
16999  case value_t::array:
17000  {
17001  // first pass: traverse common elements
17002  std::size_t i = 0;
17003  while (i < source.size() and i < target.size())
17004  {
17005  // recursive call to compare array values at index i
17006  auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
17007  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
17008  ++i;
17009  }
17010 
17011  // i now reached the end of at least one array
17012  // in a second pass, traverse the remaining elements
17013 
17014  // remove my remaining elements
17015  const auto end_index = static_cast<difference_type>(result.size());
17016  while (i < source.size())
17017  {
17018  // add operations in reverse order to avoid invalid
17019  // indices
17020  result.insert(result.begin() + end_index, object(
17021  {
17022  {"op", "remove"},
17023  {"path", path + "/" + std::to_string(i)}
17024  }));
17025  ++i;
17026  }
17027 
17028  // add other remaining elements
17029  while (i < target.size())
17030  {
17031  result.push_back(
17032  {
17033  {"op", "add"},
17034  {"path", path + "/" + std::to_string(i)},
17035  {"value", target[i]}
17036  });
17037  ++i;
17038  }
17039 
17040  break;
17041  }
17042 
17043  case value_t::object:
17044  {
17045  // first pass: traverse this object's elements
17046  for (auto it = source.cbegin(); it != source.cend(); ++it)
17047  {
17048  // escape the key name to be used in a JSON patch
17049  const auto key = json_pointer::escape(it.key());
17050 
17051  if (target.find(it.key()) != target.end())
17052  {
17053  // recursive call to compare object values at key it
17054  auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
17055  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
17056  }
17057  else
17058  {
17059  // found a key that is not in o -> remove it
17060  result.push_back(object(
17061  {
17062  {"op", "remove"}, {"path", path + "/" + key}
17063  }));
17064  }
17065  }
17066 
17067  // second pass: traverse other object's elements
17068  for (auto it = target.cbegin(); it != target.cend(); ++it)
17069  {
17070  if (source.find(it.key()) == source.end())
17071  {
17072  // found a key that is not in this -> add it
17073  const auto key = json_pointer::escape(it.key());
17074  result.push_back(
17075  {
17076  {"op", "add"}, {"path", path + "/" + key},
17077  {"value", it.value()}
17078  });
17079  }
17080  }
17081 
17082  break;
17083  }
17084 
17085  default:
17086  {
17087  // both primitive type: replace value
17088  result.push_back(
17089  {
17090  {"op", "replace"}, {"path", path}, {"value", target}
17091  });
17092  break;
17093  }
17094  }
17095  }
17096 
17097  return result;
17098  }
17099 
17100  /// @}
17101 
17102  ////////////////////////////////
17103  // JSON Merge Patch functions //
17104  ////////////////////////////////
17105 
17106  /// @name JSON Merge Patch functions
17107  /// @{
17108 
17109  /*!
17110  @brief applies a JSON Merge Patch
17111 
17112  The merge patch format is primarily intended for use with the HTTP PATCH
17113  method as a means of describing a set of modifications to a target
17114  resource's content. This function applies a merge patch to the current
17115  JSON value.
17116 
17117  The function implements the following algorithm from Section 2 of
17118  [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
17119 
17120  ```
17121  define MergePatch(Target, Patch):
17122  if Patch is an Object:
17123  if Target is not an Object:
17124  Target = {} // Ignore the contents and set it to an empty Object
17125  for each Name/Value pair in Patch:
17126  if Value is null:
17127  if Name exists in Target:
17128  remove the Name/Value pair from Target
17129  else:
17130  Target[Name] = MergePatch(Target[Name], Value)
17131  return Target
17132  else:
17133  return Patch
17134  ```
17135 
17136  Thereby, `Target` is the current object; that is, the patch is applied to
17137  the current value.
17138 
17139  @param[in] patch the patch to apply
17140 
17141  @complexity Linear in the lengths of @a patch.
17142 
17143  @liveexample{The following code shows how a JSON Merge Patch is applied to
17144  a JSON document.,merge_patch}
17145 
17146  @sa @ref patch -- apply a JSON patch
17147  @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
17148 
17149  @since version 3.0.0
17150  */
17151  void merge_patch(const basic_json& patch)
17152  {
17153  if (patch.is_object())
17154  {
17155  if (not is_object())
17156  {
17157  *this = object();
17158  }
17159  for (auto it = patch.begin(); it != patch.end(); ++it)
17160  {
17161  if (it.value().is_null())
17162  {
17163  erase(it.key());
17164  }
17165  else
17166  {
17167  operator[](it.key()).merge_patch(it.value());
17168  }
17169  }
17170  }
17171  else
17172  {
17173  *this = patch;
17174  }
17175  }
17176 
17177  /// @}
17178 };
17179 } // namespace nlohmann
17180 
17181 ///////////////////////
17182 // nonmember support //
17183 ///////////////////////
17184 
17185 // specialization of std::swap, and std::hash
17186 namespace std
17187 {
17188 /*!
17189 @brief exchanges the values of two JSON objects
17190 
17191 @since version 1.0.0
17192 */
17193 template<>
17194 inline void swap(nlohmann::json& j1,
17195  nlohmann::json& j2) noexcept(
17196  is_nothrow_move_constructible<nlohmann::json>::value and
17197  is_nothrow_move_assignable<nlohmann::json>::value
17198  )
17199 {
17200  j1.swap(j2);
17201 }
17202 
17203 /// hash value for JSON objects
17204 template<>
17205 struct hash<nlohmann::json>
17206 {
17207  /*!
17208  @brief return a hash value for a JSON object
17209 
17210  @since version 1.0.0
17211  */
17212  std::size_t operator()(const nlohmann::json& j) const
17213  {
17214  // a naive hashing via the string representation
17215  const auto& h = hash<nlohmann::json::string_t>();
17216  return h(j.dump());
17217  }
17218 };
17219 
17220 /// specialization for std::less<value_t>
17221 /// @note: do not remove the space after '<',
17222 /// see https://github.com/nlohmann/json/pull/679
17223 template<>
17224 struct less< ::nlohmann::detail::value_t>
17225 {
17226  /*!
17227  @brief compare two value_t enum values
17228  @since version 3.0.0
17229  */
17230  bool operator()(nlohmann::detail::value_t lhs,
17231  nlohmann::detail::value_t rhs) const noexcept
17232  {
17233  return nlohmann::detail::operator<(lhs, rhs);
17234  }
17235 };
17236 
17237 } // namespace std
17238 
17239 /*!
17240 @brief user-defined string literal for JSON values
17241 
17242 This operator implements a user-defined string literal for JSON objects. It
17243 can be used by adding `"_json"` to a string literal and returns a JSON object
17244 if no parse error occurred.
17245 
17246 @param[in] s a string representation of a JSON object
17247 @param[in] n the length of string @a s
17248 @return a JSON object
17249 
17250 @since version 1.0.0
17251 */
17252 inline nlohmann::json operator "" _json(const char* s, std::size_t n)
17253 {
17254  return nlohmann::json::parse(s, s + n);
17255 }
17256 
17257 /*!
17258 @brief user-defined string literal for JSON pointer
17259 
17260 This operator implements a user-defined string literal for JSON Pointers. It
17261 can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
17262 object if no parse error occurred.
17263 
17264 @param[in] s a string representation of a JSON Pointer
17265 @param[in] n the length of string @a s
17266 @return a JSON pointer object
17267 
17268 @since version 2.0.0
17269 */
17270 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
17271 {
17272  return nlohmann::json::json_pointer(std::string(s, n));
17273 }
17274 
17275 // #include <nlohmann/detail/macro_unscope.hpp>
17276 
17277 
17278 // restore GCC/clang diagnostic settings
17279 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
17280  #pragma GCC diagnostic pop
17281 #endif
17282 #if defined(__clang__)
17283  #pragma GCC diagnostic pop
17284 #endif
17285 
17286 // clean up
17287 #undef JSON_CATCH
17288 #undef JSON_THROW
17289 #undef JSON_TRY
17290 #undef JSON_LIKELY
17291 #undef JSON_UNLIKELY
17292 #undef JSON_DEPRECATED
17293 #undef JSON_HAS_CPP_14
17294 #undef JSON_HAS_CPP_17
17295 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
17296 #undef NLOHMANN_BASIC_JSON_TPL
17297 #undef NLOHMANN_JSON_HAS_HELPER
17298 
17299 
17300 #endif
#define NLOHMANN_BASIC_JSON_TPL_DECLARATION
Definition: json.hpp:197
#define JSON_DEPRECATED
Definition: json.hpp:149
#define JSON_LIKELY(x)
Definition: json.hpp:182
static std::vector< uint8_t > to_ubjson(const basic_json &j, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
Definition: json.hpp:16126
#define NLOHMANN_JSON_HAS_HELPER(type)
Helper to determine whether there&#39;s a key_type for T.
Definition: json.hpp:220
#define JSON_UNLIKELY(x)
Definition: json.hpp:183
#define NLOHMANN_JSON_VERSION_MAJOR
Definition: json.hpp:32
constexpr const auto & from_json
Definition: json.hpp:1226
#define JSON_CATCH(exception)
Definition: json.hpp:160
namespace for Niels Lohmann
Definition: json.hpp:63
#define NLOHMANN_BASIC_JSON_TPL
Definition: json.hpp:205
#define NLOHMANN_JSON_VERSION_PATCH
Definition: json.hpp:34
#define JSON_TRY
Definition: json.hpp:159
#define NLOHMANN_JSON_VERSION_MINOR
Definition: json.hpp:33
#define JSON_THROW(exception)
Definition: json.hpp:158
constexpr const auto & to_json
Definition: json.hpp:1568
json_pointer(const std::string &s="")
create JSON pointer
Definition: json.hpp:8977