Orderbook Simulation
OrderbookSim is a C++ application simulating a financial market order book. It efficiently manages and matches buy and sell orders while calculating the Volume-Weighted Average Price (VWAP).
json.hpp
Go to the documentation of this file.
1 // __ _____ _____ _____
2 // __| | __| | | | JSON for Modern C++
3 // | | |__ | | | | | | version 3.11.3
4 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
5 //
6 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
7 // SPDX-License-Identifier: MIT
8 
9 /****************************************************************************\
10  * Note on documentation: The source files contain links to the online *
11  * documentation of the public API at https://json.nlohmann.me. This URL *
12  * contains the most recent documentation and should also be applicable to *
13  * previous versions; documentation for deprecated functions is not *
14  * removed, but marked deprecated. See "Generate documentation" section in *
15  * file docs/README.md. *
16 \****************************************************************************/
17 
18 #ifndef INCLUDE_NLOHMANN_JSON_HPP_
19 #define INCLUDE_NLOHMANN_JSON_HPP_
20 
21 #include <algorithm> // all_of, find, for_each
22 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
23 #include <functional> // hash, less
24 #include <initializer_list> // initializer_list
25 #ifndef JSON_NO_IO
26 #include <iosfwd> // istream, ostream
27 #endif // JSON_NO_IO
28 #include <iterator> // random_access_iterator_tag
29 #include <memory> // unique_ptr
30 #include <string> // string, stoi, to_string
31 #include <utility> // declval, forward, move, pair, swap
32 #include <vector> // vector
33 
34 // #include <nlohmann/adl_serializer.hpp>
35 // __ _____ _____ _____
36 // __| | __| | | | JSON for Modern C++
37 // | | |__ | | | | | | version 3.11.3
38 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
39 //
40 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
41 // SPDX-License-Identifier: MIT
42 
43 
44 
45 #include <utility>
46 
47 // #include <nlohmann/detail/abi_macros.hpp>
48 // __ _____ _____ _____
49 // __| | __| | | | JSON for Modern C++
50 // | | |__ | | | | | | version 3.11.3
51 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
52 //
53 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
54 // SPDX-License-Identifier: MIT
55 
56 
57 
58 // This file contains all macro definitions affecting or depending on the ABI
59 
60 #ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
61 #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
62 #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
63 #warning "Already included a different version of the library!"
64 #endif
65 #endif
66 #endif
67 
68 #define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum)
69 #define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum)
70 #define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum)
71 
72 #ifndef JSON_DIAGNOSTICS
73 #define JSON_DIAGNOSTICS 0
74 #endif
75 
76 #ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
77 #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
78 #endif
79 
80 #if JSON_DIAGNOSTICS
81 #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
82 #else
83 #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
84 #endif
85 
86 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
87 #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
88 #else
89 #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
90 #endif
91 
92 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
93 #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
94 #endif
95 
96 // Construct the namespace ABI tags component
97 #define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
98 #define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
99  NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
100 
101 #define NLOHMANN_JSON_ABI_TAGS \
102  NLOHMANN_JSON_ABI_TAGS_CONCAT( \
103  NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \
104  NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
105 
106 // Construct the namespace version component
107 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
108  _v ## major ## _ ## minor ## _ ## patch
109 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
110  NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
111 
112 #if NLOHMANN_JSON_NAMESPACE_NO_VERSION
113 #define NLOHMANN_JSON_NAMESPACE_VERSION
114 #else
115 #define NLOHMANN_JSON_NAMESPACE_VERSION \
116  NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
117  NLOHMANN_JSON_VERSION_MINOR, \
118  NLOHMANN_JSON_VERSION_PATCH)
119 #endif
120 
121 // Combine namespace components
122 #define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
123 #define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
124  NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
125 
126 #ifndef NLOHMANN_JSON_NAMESPACE
127 #define NLOHMANN_JSON_NAMESPACE \
128  nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
129  NLOHMANN_JSON_ABI_TAGS, \
130  NLOHMANN_JSON_NAMESPACE_VERSION)
131 #endif
132 
133 #ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
134 #define NLOHMANN_JSON_NAMESPACE_BEGIN \
135  namespace nlohmann \
136  { \
137  inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
138  NLOHMANN_JSON_ABI_TAGS, \
139  NLOHMANN_JSON_NAMESPACE_VERSION) \
140  {
141 #endif
142 
143 #ifndef NLOHMANN_JSON_NAMESPACE_END
144 #define NLOHMANN_JSON_NAMESPACE_END \
145  } /* namespace (inline namespace) NOLINT(readability/namespace) */ \
146  } // namespace nlohmann
147 #endif
148 
149 // #include <nlohmann/detail/conversions/from_json.hpp>
150 // __ _____ _____ _____
151 // __| | __| | | | JSON for Modern C++
152 // | | |__ | | | | | | version 3.11.3
153 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
154 //
155 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
156 // SPDX-License-Identifier: MIT
157 
158 
159 
160 #include <algorithm> // transform
161 #include <array> // array
162 #include <forward_list> // forward_list
163 #include <iterator> // inserter, front_inserter, end
164 #include <map> // map
165 #include <string> // string
166 #include <tuple> // tuple, make_tuple
167 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
168 #include <unordered_map> // unordered_map
169 #include <utility> // pair, declval
170 #include <valarray> // valarray
171 
172 // #include <nlohmann/detail/exceptions.hpp>
173 // __ _____ _____ _____
174 // __| | __| | | | JSON for Modern C++
175 // | | |__ | | | | | | version 3.11.3
176 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
177 //
178 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
179 // SPDX-License-Identifier: MIT
180 
181 
182 
183 #include <cstddef> // nullptr_t
184 #include <exception> // exception
185 #if JSON_DIAGNOSTICS
186 #include <numeric> // accumulate
187 #endif
188 #include <stdexcept> // runtime_error
189 #include <string> // to_string
190 #include <vector> // vector
191 
192 // #include <nlohmann/detail/value_t.hpp>
193 // __ _____ _____ _____
194 // __| | __| | | | JSON for Modern C++
195 // | | |__ | | | | | | version 3.11.3
196 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
197 //
198 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
199 // SPDX-License-Identifier: MIT
200 
201 
202 
203 #include <array> // array
204 #include <cstddef> // size_t
205 #include <cstdint> // uint8_t
206 #include <string> // string
207 
208 // #include <nlohmann/detail/macro_scope.hpp>
209 // __ _____ _____ _____
210 // __| | __| | | | JSON for Modern C++
211 // | | |__ | | | | | | version 3.11.3
212 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
213 //
214 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
215 // SPDX-License-Identifier: MIT
216 
217 
218 
219 #include <utility> // declval, pair
220 // #include <nlohmann/detail/meta/detected.hpp>
221 // __ _____ _____ _____
222 // __| | __| | | | JSON for Modern C++
223 // | | |__ | | | | | | version 3.11.3
224 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
225 //
226 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
227 // SPDX-License-Identifier: MIT
228 
229 
230 
231 #include <type_traits>
232 
233 // #include <nlohmann/detail/meta/void_t.hpp>
234 // __ _____ _____ _____
235 // __| | __| | | | JSON for Modern C++
236 // | | |__ | | | | | | version 3.11.3
237 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
238 //
239 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
240 // SPDX-License-Identifier: MIT
241 
242 
243 
244 // #include <nlohmann/detail/abi_macros.hpp>
245 
246 
247 NLOHMANN_JSON_NAMESPACE_BEGIN
248 namespace detail
249 {
250 
251  template<typename ...Ts> struct make_void
252  {
253  using type = void;
254  };
255  template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
256 
257 } // namespace detail
258 NLOHMANN_JSON_NAMESPACE_END
259 
260 
261 NLOHMANN_JSON_NAMESPACE_BEGIN
262 namespace detail
263 {
264 
265  // https://en.cppreference.com/w/cpp/experimental/is_detected
266  struct nonesuch
267  {
268  nonesuch() = delete;
269  ~nonesuch() = delete;
270  nonesuch(nonesuch const&) = delete;
271  nonesuch(nonesuch const&&) = delete;
272  void operator=(nonesuch const&) = delete;
273  void operator=(nonesuch&&) = delete;
274  };
275 
276  template<class Default,
277  class AlwaysVoid,
278  template<class...> class Op,
279  class... Args>
280  struct detector
281  {
282  using value_t = std::false_type;
283  using type = Default;
284  };
285 
286  template<class Default, template<class...> class Op, class... Args>
287  struct detector<Default, void_t<Op<Args...>>, Op, Args...>
288  {
289  using value_t = std::true_type;
290  using type = Op<Args...>;
291  };
292 
293  template<template<class...> class Op, class... Args>
294  using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
295 
296  template<template<class...> class Op, class... Args>
297  struct is_detected_lazy : is_detected<Op, Args...> { };
298 
299  template<template<class...> class Op, class... Args>
300  using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
301 
302  template<class Default, template<class...> class Op, class... Args>
303  using detected_or = detector<Default, void, Op, Args...>;
304 
305  template<class Default, template<class...> class Op, class... Args>
306  using detected_or_t = typename detected_or<Default, Op, Args...>::type;
307 
308  template<class Expected, template<class...> class Op, class... Args>
309  using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
310 
311  template<class To, template<class...> class Op, class... Args>
312  using is_detected_convertible =
313  std::is_convertible<detected_t<Op, Args...>, To>;
314 
315 } // namespace detail
316 NLOHMANN_JSON_NAMESPACE_END
317 
318 // #include <nlohmann/thirdparty/hedley/hedley.hpp>
319 
320 
321 // __ _____ _____ _____
322 // __| | __| | | | JSON for Modern C++
323 // | | |__ | | | | | | version 3.11.3
324 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
325 //
326 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
327 // SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
328 // SPDX-License-Identifier: MIT
329 
330 /* Hedley - https://nemequ.github.io/hedley
331  * Created by Evan Nemerson <evan@nemerson.com>
332  */
333 
334 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
335 #if defined(JSON_HEDLEY_VERSION)
336 #undef JSON_HEDLEY_VERSION
337 #endif
338 #define JSON_HEDLEY_VERSION 15
339 
340 #if defined(JSON_HEDLEY_STRINGIFY_EX)
341 #undef JSON_HEDLEY_STRINGIFY_EX
342 #endif
343 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
344 
345 #if defined(JSON_HEDLEY_STRINGIFY)
346 #undef JSON_HEDLEY_STRINGIFY
347 #endif
348 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
349 
350 #if defined(JSON_HEDLEY_CONCAT_EX)
351 #undef JSON_HEDLEY_CONCAT_EX
352 #endif
353 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
354 
355 #if defined(JSON_HEDLEY_CONCAT)
356 #undef JSON_HEDLEY_CONCAT
357 #endif
358 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
359 
360 #if defined(JSON_HEDLEY_CONCAT3_EX)
361 #undef JSON_HEDLEY_CONCAT3_EX
362 #endif
363 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
364 
365 #if defined(JSON_HEDLEY_CONCAT3)
366 #undef JSON_HEDLEY_CONCAT3
367 #endif
368 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
369 
370 #if defined(JSON_HEDLEY_VERSION_ENCODE)
371 #undef JSON_HEDLEY_VERSION_ENCODE
372 #endif
373 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
374 
375 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
376 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
377 #endif
378 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
379 
380 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
381 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
382 #endif
383 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
384 
385 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
386 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
387 #endif
388 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
389 
390 #if defined(JSON_HEDLEY_GNUC_VERSION)
391 #undef JSON_HEDLEY_GNUC_VERSION
392 #endif
393 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
394 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
395 #elif defined(__GNUC__)
396 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
397 #endif
398 
399 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
400 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
401 #endif
402 #if defined(JSON_HEDLEY_GNUC_VERSION)
403 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
404 #else
405 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
406 #endif
407 
408 #if defined(JSON_HEDLEY_MSVC_VERSION)
409 #undef JSON_HEDLEY_MSVC_VERSION
410 #endif
411 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
412 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
413 #elif defined(_MSC_FULL_VER) && !defined(__ICL)
414 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
415 #elif defined(_MSC_VER) && !defined(__ICL)
416 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
417 #endif
418 
419 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
420 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
421 #endif
422 #if !defined(JSON_HEDLEY_MSVC_VERSION)
423 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
424 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
425 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
426 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
427 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
428 #else
429 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
430 #endif
431 
432 #if defined(JSON_HEDLEY_INTEL_VERSION)
433 #undef JSON_HEDLEY_INTEL_VERSION
434 #endif
435 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
436 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
437 #elif defined(__INTEL_COMPILER) && !defined(__ICL)
438 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
439 #endif
440 
441 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
442 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
443 #endif
444 #if defined(JSON_HEDLEY_INTEL_VERSION)
445 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
446 #else
447 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
448 #endif
449 
450 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
451 #undef JSON_HEDLEY_INTEL_CL_VERSION
452 #endif
453 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
454 #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
455 #endif
456 
457 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
458 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
459 #endif
460 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
461 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
462 #else
463 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
464 #endif
465 
466 #if defined(JSON_HEDLEY_PGI_VERSION)
467 #undef JSON_HEDLEY_PGI_VERSION
468 #endif
469 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
470 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
471 #endif
472 
473 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
474 #undef JSON_HEDLEY_PGI_VERSION_CHECK
475 #endif
476 #if defined(JSON_HEDLEY_PGI_VERSION)
477 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
478 #else
479 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
480 #endif
481 
482 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
483 #undef JSON_HEDLEY_SUNPRO_VERSION
484 #endif
485 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
486 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
487 #elif defined(__SUNPRO_C)
488 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
489 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
490 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
491 #elif defined(__SUNPRO_CC)
492 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
493 #endif
494 
495 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
496 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
497 #endif
498 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
499 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
500 #else
501 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
502 #endif
503 
504 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
505 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
506 #endif
507 #if defined(__EMSCRIPTEN__)
508 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
509 #endif
510 
511 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
512 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
513 #endif
514 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
515 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
516 #else
517 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
518 #endif
519 
520 #if defined(JSON_HEDLEY_ARM_VERSION)
521 #undef JSON_HEDLEY_ARM_VERSION
522 #endif
523 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
524 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
525 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
526 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
527 #endif
528 
529 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
530 #undef JSON_HEDLEY_ARM_VERSION_CHECK
531 #endif
532 #if defined(JSON_HEDLEY_ARM_VERSION)
533 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
534 #else
535 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
536 #endif
537 
538 #if defined(JSON_HEDLEY_IBM_VERSION)
539 #undef JSON_HEDLEY_IBM_VERSION
540 #endif
541 #if defined(__ibmxl__)
542 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
543 #elif defined(__xlC__) && defined(__xlC_ver__)
544 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
545 #elif defined(__xlC__)
546 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
547 #endif
548 
549 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
550 #undef JSON_HEDLEY_IBM_VERSION_CHECK
551 #endif
552 #if defined(JSON_HEDLEY_IBM_VERSION)
553 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
554 #else
555 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
556 #endif
557 
558 #if defined(JSON_HEDLEY_TI_VERSION)
559 #undef JSON_HEDLEY_TI_VERSION
560 #endif
561 #if \
562  defined(__TI_COMPILER_VERSION__) && \
563  ( \
564  defined(__TMS470__) || defined(__TI_ARM__) || \
565  defined(__MSP430__) || \
566  defined(__TMS320C2000__) \
567  )
568 #if (__TI_COMPILER_VERSION__ >= 16000000)
569 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
570 #endif
571 #endif
572 
573 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
574 #undef JSON_HEDLEY_TI_VERSION_CHECK
575 #endif
576 #if defined(JSON_HEDLEY_TI_VERSION)
577 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
578 #else
579 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
580 #endif
581 
582 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
583 #undef JSON_HEDLEY_TI_CL2000_VERSION
584 #endif
585 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
586 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
587 #endif
588 
589 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
590 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
591 #endif
592 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
593 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
594 #else
595 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
596 #endif
597 
598 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
599 #undef JSON_HEDLEY_TI_CL430_VERSION
600 #endif
601 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
602 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
603 #endif
604 
605 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
606 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
607 #endif
608 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
609 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
610 #else
611 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
612 #endif
613 
614 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
615 #undef JSON_HEDLEY_TI_ARMCL_VERSION
616 #endif
617 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
618 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
619 #endif
620 
621 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
622 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
623 #endif
624 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
625 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
626 #else
627 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
628 #endif
629 
630 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
631 #undef JSON_HEDLEY_TI_CL6X_VERSION
632 #endif
633 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
634 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
635 #endif
636 
637 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
638 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
639 #endif
640 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
641 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
642 #else
643 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
644 #endif
645 
646 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
647 #undef JSON_HEDLEY_TI_CL7X_VERSION
648 #endif
649 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
650 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
651 #endif
652 
653 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
654 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
655 #endif
656 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
657 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
658 #else
659 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
660 #endif
661 
662 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
663 #undef JSON_HEDLEY_TI_CLPRU_VERSION
664 #endif
665 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
666 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
667 #endif
668 
669 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
670 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
671 #endif
672 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
673 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
674 #else
675 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
676 #endif
677 
678 #if defined(JSON_HEDLEY_CRAY_VERSION)
679 #undef JSON_HEDLEY_CRAY_VERSION
680 #endif
681 #if defined(_CRAYC)
682 #if defined(_RELEASE_PATCHLEVEL)
683 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
684 #else
685 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
686 #endif
687 #endif
688 
689 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
690 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
691 #endif
692 #if defined(JSON_HEDLEY_CRAY_VERSION)
693 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
694 #else
695 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
696 #endif
697 
698 #if defined(JSON_HEDLEY_IAR_VERSION)
699 #undef JSON_HEDLEY_IAR_VERSION
700 #endif
701 #if defined(__IAR_SYSTEMS_ICC__)
702 #if __VER__ > 1000
703 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
704 #else
705 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
706 #endif
707 #endif
708 
709 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
710 #undef JSON_HEDLEY_IAR_VERSION_CHECK
711 #endif
712 #if defined(JSON_HEDLEY_IAR_VERSION)
713 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
714 #else
715 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
716 #endif
717 
718 #if defined(JSON_HEDLEY_TINYC_VERSION)
719 #undef JSON_HEDLEY_TINYC_VERSION
720 #endif
721 #if defined(__TINYC__)
722 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
723 #endif
724 
725 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
726 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
727 #endif
728 #if defined(JSON_HEDLEY_TINYC_VERSION)
729 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
730 #else
731 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
732 #endif
733 
734 #if defined(JSON_HEDLEY_DMC_VERSION)
735 #undef JSON_HEDLEY_DMC_VERSION
736 #endif
737 #if defined(__DMC__)
738 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
739 #endif
740 
741 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
742 #undef JSON_HEDLEY_DMC_VERSION_CHECK
743 #endif
744 #if defined(JSON_HEDLEY_DMC_VERSION)
745 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
746 #else
747 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
748 #endif
749 
750 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
751 #undef JSON_HEDLEY_COMPCERT_VERSION
752 #endif
753 #if defined(__COMPCERT_VERSION__)
754 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
755 #endif
756 
757 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
758 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
759 #endif
760 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
761 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
762 #else
763 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
764 #endif
765 
766 #if defined(JSON_HEDLEY_PELLES_VERSION)
767 #undef JSON_HEDLEY_PELLES_VERSION
768 #endif
769 #if defined(__POCC__)
770 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
771 #endif
772 
773 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
774 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
775 #endif
776 #if defined(JSON_HEDLEY_PELLES_VERSION)
777 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
778 #else
779 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
780 #endif
781 
782 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
783 #undef JSON_HEDLEY_MCST_LCC_VERSION
784 #endif
785 #if defined(__LCC__) && defined(__LCC_MINOR__)
786 #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
787 #endif
788 
789 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
790 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
791 #endif
792 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
793 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
794 #else
795 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
796 #endif
797 
798 #if defined(JSON_HEDLEY_GCC_VERSION)
799 #undef JSON_HEDLEY_GCC_VERSION
800 #endif
801 #if \
802  defined(JSON_HEDLEY_GNUC_VERSION) && \
803  !defined(__clang__) && \
804  !defined(JSON_HEDLEY_INTEL_VERSION) && \
805  !defined(JSON_HEDLEY_PGI_VERSION) && \
806  !defined(JSON_HEDLEY_ARM_VERSION) && \
807  !defined(JSON_HEDLEY_CRAY_VERSION) && \
808  !defined(JSON_HEDLEY_TI_VERSION) && \
809  !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
810  !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
811  !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
812  !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
813  !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
814  !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
815  !defined(__COMPCERT__) && \
816  !defined(JSON_HEDLEY_MCST_LCC_VERSION)
817 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
818 #endif
819 
820 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
821 #undef JSON_HEDLEY_GCC_VERSION_CHECK
822 #endif
823 #if defined(JSON_HEDLEY_GCC_VERSION)
824 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
825 #else
826 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
827 #endif
828 
829 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
830 #undef JSON_HEDLEY_HAS_ATTRIBUTE
831 #endif
832 #if \
833  defined(__has_attribute) && \
834  ( \
835  (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
836  )
837 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
838 #else
839 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
840 #endif
841 
842 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
843 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
844 #endif
845 #if defined(__has_attribute)
846 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
847 #else
848 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
849 #endif
850 
851 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
852 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
853 #endif
854 #if defined(__has_attribute)
855 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
856 #else
857 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
858 #endif
859 
860 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
861 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
862 #endif
863 #if \
864  defined(__has_cpp_attribute) && \
865  defined(__cplusplus) && \
866  (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
867 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
868 #else
869 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
870 #endif
871 
872 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
873 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
874 #endif
875 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
876 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
877 #elif \
878  !defined(JSON_HEDLEY_PGI_VERSION) && \
879  !defined(JSON_HEDLEY_IAR_VERSION) && \
880  (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
881  (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
882 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
883 #else
884 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
885 #endif
886 
887 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
888 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
889 #endif
890 #if defined(__has_cpp_attribute) && defined(__cplusplus)
891 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
892 #else
893 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
894 #endif
895 
896 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
897 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
898 #endif
899 #if defined(__has_cpp_attribute) && defined(__cplusplus)
900 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
901 #else
902 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
903 #endif
904 
905 #if defined(JSON_HEDLEY_HAS_BUILTIN)
906 #undef JSON_HEDLEY_HAS_BUILTIN
907 #endif
908 #if defined(__has_builtin)
909 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
910 #else
911 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
912 #endif
913 
914 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
915 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
916 #endif
917 #if defined(__has_builtin)
918 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
919 #else
920 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
921 #endif
922 
923 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
924 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
925 #endif
926 #if defined(__has_builtin)
927 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
928 #else
929 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
930 #endif
931 
932 #if defined(JSON_HEDLEY_HAS_FEATURE)
933 #undef JSON_HEDLEY_HAS_FEATURE
934 #endif
935 #if defined(__has_feature)
936 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
937 #else
938 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
939 #endif
940 
941 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
942 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
943 #endif
944 #if defined(__has_feature)
945 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
946 #else
947 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
948 #endif
949 
950 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
951 #undef JSON_HEDLEY_GCC_HAS_FEATURE
952 #endif
953 #if defined(__has_feature)
954 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
955 #else
956 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
957 #endif
958 
959 #if defined(JSON_HEDLEY_HAS_EXTENSION)
960 #undef JSON_HEDLEY_HAS_EXTENSION
961 #endif
962 #if defined(__has_extension)
963 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
964 #else
965 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
966 #endif
967 
968 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
969 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
970 #endif
971 #if defined(__has_extension)
972 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
973 #else
974 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
975 #endif
976 
977 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
978 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
979 #endif
980 #if defined(__has_extension)
981 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
982 #else
983 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
984 #endif
985 
986 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
987 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
988 #endif
989 #if defined(__has_declspec_attribute)
990 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
991 #else
992 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
993 #endif
994 
995 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
996 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
997 #endif
998 #if defined(__has_declspec_attribute)
999 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
1000 #else
1001 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
1002 #endif
1003 
1004 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
1005 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
1006 #endif
1007 #if defined(__has_declspec_attribute)
1008 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
1009 #else
1010 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1011 #endif
1012 
1013 #if defined(JSON_HEDLEY_HAS_WARNING)
1014 #undef JSON_HEDLEY_HAS_WARNING
1015 #endif
1016 #if defined(__has_warning)
1017 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
1018 #else
1019 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
1020 #endif
1021 
1022 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
1023 #undef JSON_HEDLEY_GNUC_HAS_WARNING
1024 #endif
1025 #if defined(__has_warning)
1026 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
1027 #else
1028 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
1029 #endif
1030 
1031 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
1032 #undef JSON_HEDLEY_GCC_HAS_WARNING
1033 #endif
1034 #if defined(__has_warning)
1035 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
1036 #else
1037 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1038 #endif
1039 
1040 #if \
1041  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1042  defined(__clang__) || \
1043  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1044  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1045  JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1046  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1047  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1048  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1049  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1050  JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1051  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1052  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
1053  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1054  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1055  JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
1056  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
1057  JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
1058  (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
1059 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
1060 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1061 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
1062 #else
1063 #define JSON_HEDLEY_PRAGMA(value)
1064 #endif
1065 
1066 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
1067 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
1068 #endif
1069 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
1070 #undef JSON_HEDLEY_DIAGNOSTIC_POP
1071 #endif
1072 #if defined(__clang__)
1073 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
1074 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
1075 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1076 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
1077 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
1078 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1079 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
1080 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
1081 #elif \
1082  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
1083  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1084 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
1085 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
1086 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
1087 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
1088 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
1089 #elif \
1090  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1091  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1092  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
1093  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1094  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1095  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1096 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
1097 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
1098 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1099 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
1100 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
1101 #else
1102 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
1103 #define JSON_HEDLEY_DIAGNOSTIC_POP
1104 #endif
1105 
1106  /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
1107  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
1108 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1109 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
1110 #endif
1111 #if defined(__cplusplus)
1112 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
1113 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
1114 # if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
1115 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1116  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1117  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1118  _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
1119  _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
1120  xpr \
1121  JSON_HEDLEY_DIAGNOSTIC_POP
1122 # else
1123 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1124  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1125  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1126  _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
1127  xpr \
1128  JSON_HEDLEY_DIAGNOSTIC_POP
1129 # endif
1130 # else
1131 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1132  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1133  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1134  xpr \
1135  JSON_HEDLEY_DIAGNOSTIC_POP
1136 # endif
1137 # endif
1138 #endif
1139 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1140 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
1141 #endif
1142 
1143 #if defined(JSON_HEDLEY_CONST_CAST)
1144 #undef JSON_HEDLEY_CONST_CAST
1145 #endif
1146 #if defined(__cplusplus)
1147 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1148 #elif \
1149  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1150  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1151  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1152 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1153  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1154  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1155  ((T) (expr)); \
1156  JSON_HEDLEY_DIAGNOSTIC_POP \
1157  }))
1158 #else
1159 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1160 #endif
1161 
1162 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
1163 #undef JSON_HEDLEY_REINTERPRET_CAST
1164 #endif
1165 #if defined(__cplusplus)
1166 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1167 #else
1168 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1169 #endif
1170 
1171 #if defined(JSON_HEDLEY_STATIC_CAST)
1172 #undef JSON_HEDLEY_STATIC_CAST
1173 #endif
1174 #if defined(__cplusplus)
1175 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1176 #else
1177 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1178 #endif
1179 
1180 #if defined(JSON_HEDLEY_CPP_CAST)
1181 #undef JSON_HEDLEY_CPP_CAST
1182 #endif
1183 #if defined(__cplusplus)
1184 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1185 # define JSON_HEDLEY_CPP_CAST(T, expr) \
1186  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1187  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1188  ((T) (expr)) \
1189  JSON_HEDLEY_DIAGNOSTIC_POP
1190 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1191 # define JSON_HEDLEY_CPP_CAST(T, expr) \
1192  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1193  _Pragma("diag_suppress=Pe137") \
1194  JSON_HEDLEY_DIAGNOSTIC_POP
1195 # else
1196 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1197 # endif
1198 #else
1199 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1200 #endif
1201 
1202 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1203 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1204 #endif
1205 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1206 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1207 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1208 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1209 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1210 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1211 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1212 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1213 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1214 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1215 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1216 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1217 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1218 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1219 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1220 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1221 #elif \
1222  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1223  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1224  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1225  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1226  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1227  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1228  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1229  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1230  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1231  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1232  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1233 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1234 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1235 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1236 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1237 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1238 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1239 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1240 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1241 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1242 #else
1243 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1244 #endif
1245 
1246 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1247 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1248 #endif
1249 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1250 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1251 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1252 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1253 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1254 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1255 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1256 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1257 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1258 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1259 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1260 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1261 #elif \
1262  JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1263  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1264  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1265  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1266 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1267 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1268 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1269 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1270 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1271 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1272 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1273 #else
1274 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1275 #endif
1276 
1277 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1278 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1279 #endif
1280 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1281 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1282 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1283 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1284 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1285 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1286 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1287 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1288 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1289 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1290 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1291 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1292 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1293 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1294 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1295 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1296 #elif \
1297  JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1298  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1299  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1300 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1301 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1302 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1303 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1304 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1305 #else
1306 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1307 #endif
1308 
1309 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1310 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1311 #endif
1312 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1313 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1314 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1315 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1316 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1317 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1318 #else
1319 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1320 #endif
1321 
1322 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1323 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1324 #endif
1325 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1326 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1327 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1328 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1329 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1330 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1331 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1332 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1333 #else
1334 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1335 #endif
1336 
1337 #if defined(JSON_HEDLEY_DEPRECATED)
1338 #undef JSON_HEDLEY_DEPRECATED
1339 #endif
1340 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1341 #undef JSON_HEDLEY_DEPRECATED_FOR
1342 #endif
1343 #if \
1344  JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1345  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1346 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1347 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1348 #elif \
1349  (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1350  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1351  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1352  JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1353  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1354  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1355  JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1356  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1357  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1358  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1359  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1360  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1361 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1362 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1363 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1364 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1365 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1366 #elif \
1367  JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1368  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1369  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1370  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1371  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1372  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1373  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1374  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1375  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1376  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1377  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1378  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1379  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1380  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1381  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1382  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1383 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1384 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1385 #elif \
1386  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1387  JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1388  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1389 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1390 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1391 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1392 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1393 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1394 #else
1395 #define JSON_HEDLEY_DEPRECATED(since)
1396 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1397 #endif
1398 
1399 #if defined(JSON_HEDLEY_UNAVAILABLE)
1400 #undef JSON_HEDLEY_UNAVAILABLE
1401 #endif
1402 #if \
1403  JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1404  JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1405  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1406  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1407 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1408 #else
1409 #define JSON_HEDLEY_UNAVAILABLE(available_since)
1410 #endif
1411 
1412 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1413 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1414 #endif
1415 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1416 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1417 #endif
1418 #if \
1419  JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1420  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1421  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1422  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1423  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1424  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1425  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1426  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1427  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1428  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1429  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1430  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1431  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1432  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1433  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1434  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1435  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1436 #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1437 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1438 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1439 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1440 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1441 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1442 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1443 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1444 #elif defined(_Check_return_) /* SAL */
1445 #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1446 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1447 #else
1448 #define JSON_HEDLEY_WARN_UNUSED_RESULT
1449 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1450 #endif
1451 
1452 #if defined(JSON_HEDLEY_SENTINEL)
1453 #undef JSON_HEDLEY_SENTINEL
1454 #endif
1455 #if \
1456  JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1457  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1458  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1459  JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1460  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1461 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1462 #else
1463 #define JSON_HEDLEY_SENTINEL(position)
1464 #endif
1465 
1466 #if defined(JSON_HEDLEY_NO_RETURN)
1467 #undef JSON_HEDLEY_NO_RETURN
1468 #endif
1469 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1470 #define JSON_HEDLEY_NO_RETURN __noreturn
1471 #elif \
1472  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1473  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1474 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1475 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1476 #define JSON_HEDLEY_NO_RETURN _Noreturn
1477 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1478 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1479 #elif \
1480  JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1481  JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1482  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1483  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1484  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1485  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1486  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1487  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1488  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1489  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1490  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1491  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1492  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1493  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1494  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1495  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1496  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1497 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1498 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1499 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1500 #elif \
1501  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1502  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1503 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1504 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1505 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1506 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1507 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1508 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1509 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1510 #else
1511 #define JSON_HEDLEY_NO_RETURN
1512 #endif
1513 
1514 #if defined(JSON_HEDLEY_NO_ESCAPE)
1515 #undef JSON_HEDLEY_NO_ESCAPE
1516 #endif
1517 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1518 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1519 #else
1520 #define JSON_HEDLEY_NO_ESCAPE
1521 #endif
1522 
1523 #if defined(JSON_HEDLEY_UNREACHABLE)
1524 #undef JSON_HEDLEY_UNREACHABLE
1525 #endif
1526 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1527 #undef JSON_HEDLEY_UNREACHABLE_RETURN
1528 #endif
1529 #if defined(JSON_HEDLEY_ASSUME)
1530 #undef JSON_HEDLEY_ASSUME
1531 #endif
1532 #if \
1533  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1534  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1535  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1536 #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1537 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1538 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1539 #elif \
1540  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1541  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1542 #if defined(__cplusplus)
1543 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1544 #else
1545 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1546 #endif
1547 #endif
1548 #if \
1549  (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1550  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1551  JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1552  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1553  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1554  JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1555  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1556 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1557 #elif defined(JSON_HEDLEY_ASSUME)
1558 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1559 #endif
1560 #if !defined(JSON_HEDLEY_ASSUME)
1561 #if defined(JSON_HEDLEY_UNREACHABLE)
1562 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1563 #else
1564 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1565 #endif
1566 #endif
1567 #if defined(JSON_HEDLEY_UNREACHABLE)
1568 #if \
1569  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1570  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1571 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1572 #else
1573 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1574 #endif
1575 #else
1576 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1577 #endif
1578 #if !defined(JSON_HEDLEY_UNREACHABLE)
1579 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1580 #endif
1581 
1582  JSON_HEDLEY_DIAGNOSTIC_PUSH
1583 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1584 #pragma clang diagnostic ignored "-Wpedantic"
1585 #endif
1586 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1587 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1588 #endif
1589 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1590 #if defined(__clang__)
1591 #pragma clang diagnostic ignored "-Wvariadic-macros"
1592 #elif defined(JSON_HEDLEY_GCC_VERSION)
1593 #pragma GCC diagnostic ignored "-Wvariadic-macros"
1594 #endif
1595 #endif
1596 #if defined(JSON_HEDLEY_NON_NULL)
1597 #undef JSON_HEDLEY_NON_NULL
1598 #endif
1599 #if \
1600  JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1601  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1602  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1603  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1604 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1605 #else
1606 #define JSON_HEDLEY_NON_NULL(...)
1607 #endif
1608  JSON_HEDLEY_DIAGNOSTIC_POP
1609 
1610 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1611 #undef JSON_HEDLEY_PRINTF_FORMAT
1612 #endif
1613 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1614 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1615 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1616 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1617 #elif \
1618  JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1619  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1620  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1621  JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1622  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1623  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1624  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1625  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1626  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1627  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1628  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1629  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1630  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1631  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1632  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1633  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1634  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1635 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1636 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1637 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1638 #else
1639 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1640 #endif
1641 
1642 #if defined(JSON_HEDLEY_CONSTEXPR)
1643 #undef JSON_HEDLEY_CONSTEXPR
1644 #endif
1645 #if defined(__cplusplus)
1646 #if __cplusplus >= 201103L
1647 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1648 #endif
1649 #endif
1650 #if !defined(JSON_HEDLEY_CONSTEXPR)
1651 #define JSON_HEDLEY_CONSTEXPR
1652 #endif
1653 
1654 #if defined(JSON_HEDLEY_PREDICT)
1655 #undef JSON_HEDLEY_PREDICT
1656 #endif
1657 #if defined(JSON_HEDLEY_LIKELY)
1658 #undef JSON_HEDLEY_LIKELY
1659 #endif
1660 #if defined(JSON_HEDLEY_UNLIKELY)
1661 #undef JSON_HEDLEY_UNLIKELY
1662 #endif
1663 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1664 #undef JSON_HEDLEY_UNPREDICTABLE
1665 #endif
1666 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1667 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1668 #endif
1669 #if \
1670  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1671  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1672  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1673 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))
1674 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))
1675 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))
1676 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )
1677 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )
1678 #elif \
1679  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1680  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1681  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1682  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1683  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1684  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1685  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1686  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1687  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1688  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1689  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1690  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1691  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1692  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1693  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1694  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1695 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1696  (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1697 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1698  (__extension__ ({ \
1699  double hedley_probability_ = (probability); \
1700  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1701  }))
1702 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1703  (__extension__ ({ \
1704  double hedley_probability_ = (probability); \
1705  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1706  }))
1707 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1708 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1709 #else
1710 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1711 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1712 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1713 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1714 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1715 #endif
1716 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1717 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1718 #endif
1719 
1720 #if defined(JSON_HEDLEY_MALLOC)
1721 #undef JSON_HEDLEY_MALLOC
1722 #endif
1723 #if \
1724  JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1725  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1726  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1727  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1728  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1729  JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1730  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1731  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1732  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1733  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1734  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1735  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1736  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1737  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1738  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1739  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1740  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1741  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1742 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1743 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1744 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1745 #elif \
1746  JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1747  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1748 #define JSON_HEDLEY_MALLOC __declspec(restrict)
1749 #else
1750 #define JSON_HEDLEY_MALLOC
1751 #endif
1752 
1753 #if defined(JSON_HEDLEY_PURE)
1754 #undef JSON_HEDLEY_PURE
1755 #endif
1756 #if \
1757  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1758  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1759  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1760  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1761  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1762  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1763  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1764  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1765  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1766  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1767  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1768  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1769  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1770  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1771  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1772  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1773  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1774  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1775  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1776 # define JSON_HEDLEY_PURE __attribute__((__pure__))
1777 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1778 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1779 #elif defined(__cplusplus) && \
1780  ( \
1781  JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1782  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1783  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1784  )
1785 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1786 #else
1787 # define JSON_HEDLEY_PURE
1788 #endif
1789 
1790 #if defined(JSON_HEDLEY_CONST)
1791 #undef JSON_HEDLEY_CONST
1792 #endif
1793 #if \
1794  JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1795  JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1796  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1797  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1798  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1799  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1800  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1801  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1802  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1803  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1804  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1805  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1806  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1807  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1808  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1809  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1810  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1811  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1812  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1813 #define JSON_HEDLEY_CONST __attribute__((__const__))
1814 #elif \
1815  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1816 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1817 #else
1818 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1819 #endif
1820 
1821 #if defined(JSON_HEDLEY_RESTRICT)
1822 #undef JSON_HEDLEY_RESTRICT
1823 #endif
1824 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1825 #define JSON_HEDLEY_RESTRICT restrict
1826 #elif \
1827  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1828  JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1829  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1830  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1831  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1832  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1833  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1834  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1835  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1836  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1837  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1838  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1839  JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1840  defined(__clang__) || \
1841  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1842 #define JSON_HEDLEY_RESTRICT __restrict
1843 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1844 #define JSON_HEDLEY_RESTRICT _Restrict
1845 #else
1846 #define JSON_HEDLEY_RESTRICT
1847 #endif
1848 
1849 #if defined(JSON_HEDLEY_INLINE)
1850 #undef JSON_HEDLEY_INLINE
1851 #endif
1852 #if \
1853  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1854  (defined(__cplusplus) && (__cplusplus >= 199711L))
1855 #define JSON_HEDLEY_INLINE inline
1856 #elif \
1857  defined(JSON_HEDLEY_GCC_VERSION) || \
1858  JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1859 #define JSON_HEDLEY_INLINE __inline__
1860 #elif \
1861  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1862  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1863  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1864  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1865  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1866  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1867  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1868  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1869  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1870  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1871 #define JSON_HEDLEY_INLINE __inline
1872 #else
1873 #define JSON_HEDLEY_INLINE
1874 #endif
1875 
1876 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1877 #undef JSON_HEDLEY_ALWAYS_INLINE
1878 #endif
1879 #if \
1880  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1881  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1882  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1883  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1884  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1885  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1886  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1887  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1888  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1889  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1890  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1891  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1892  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1893  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1894  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1895  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1896  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1897  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1898  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1899 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1900 #elif \
1901  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1902  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1903 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1904 #elif defined(__cplusplus) && \
1905  ( \
1906  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1907  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1908  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1909  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1910  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1911  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1912  )
1913 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1914 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1915 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1916 #else
1917 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1918 #endif
1919 
1920 #if defined(JSON_HEDLEY_NEVER_INLINE)
1921 #undef JSON_HEDLEY_NEVER_INLINE
1922 #endif
1923 #if \
1924  JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1925  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1926  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1927  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1928  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1929  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1930  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1931  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1932  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1933  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1934  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1935  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1936  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1937  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1938  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1939  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1940  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1941  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1942  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1943 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1944 #elif \
1945  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1946  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1947 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1948 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1949 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1950 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1951 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1952 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1953 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1954 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1955 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1956 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1957 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1958 #else
1959 #define JSON_HEDLEY_NEVER_INLINE
1960 #endif
1961 
1962 #if defined(JSON_HEDLEY_PRIVATE)
1963 #undef JSON_HEDLEY_PRIVATE
1964 #endif
1965 #if defined(JSON_HEDLEY_PUBLIC)
1966 #undef JSON_HEDLEY_PUBLIC
1967 #endif
1968 #if defined(JSON_HEDLEY_IMPORT)
1969 #undef JSON_HEDLEY_IMPORT
1970 #endif
1971 #if defined(_WIN32) || defined(__CYGWIN__)
1972 # define JSON_HEDLEY_PRIVATE
1973 # define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1974 # define JSON_HEDLEY_IMPORT __declspec(dllimport)
1975 #else
1976 # if \
1977  JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1978  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1979  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1980  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1981  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1982  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1983  ( \
1984  defined(__TI_EABI__) && \
1985  ( \
1986  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1987  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1988  ) \
1989  ) || \
1990  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1991 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1992 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1993 # else
1994 # define JSON_HEDLEY_PRIVATE
1995 # define JSON_HEDLEY_PUBLIC
1996 # endif
1997 # define JSON_HEDLEY_IMPORT extern
1998 #endif
1999 
2000 #if defined(JSON_HEDLEY_NO_THROW)
2001 #undef JSON_HEDLEY_NO_THROW
2002 #endif
2003 #if \
2004  JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
2005  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
2006  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2007  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2008 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
2009 #elif \
2010  JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
2011  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
2012  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
2013 #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
2014 #else
2015 #define JSON_HEDLEY_NO_THROW
2016 #endif
2017 
2018 #if defined(JSON_HEDLEY_FALL_THROUGH)
2019 #undef JSON_HEDLEY_FALL_THROUGH
2020 #endif
2021 #if \
2022  JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
2023  JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
2024  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2025 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
2026 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
2027 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
2028 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
2029 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
2030 #elif defined(__fallthrough) /* SAL */
2031 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
2032 #else
2033 #define JSON_HEDLEY_FALL_THROUGH
2034 #endif
2035 
2036 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
2037 #undef JSON_HEDLEY_RETURNS_NON_NULL
2038 #endif
2039 #if \
2040  JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
2041  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
2042  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2043 #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
2044 #elif defined(_Ret_notnull_) /* SAL */
2045 #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
2046 #else
2047 #define JSON_HEDLEY_RETURNS_NON_NULL
2048 #endif
2049 
2050 #if defined(JSON_HEDLEY_ARRAY_PARAM)
2051 #undef JSON_HEDLEY_ARRAY_PARAM
2052 #endif
2053 #if \
2054  defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
2055  !defined(__STDC_NO_VLA__) && \
2056  !defined(__cplusplus) && \
2057  !defined(JSON_HEDLEY_PGI_VERSION) && \
2058  !defined(JSON_HEDLEY_TINYC_VERSION)
2059 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
2060 #else
2061 #define JSON_HEDLEY_ARRAY_PARAM(name)
2062 #endif
2063 
2064 #if defined(JSON_HEDLEY_IS_CONSTANT)
2065 #undef JSON_HEDLEY_IS_CONSTANT
2066 #endif
2067 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
2068 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
2069 #endif
2070  /* JSON_HEDLEY_IS_CONSTEXPR_ is for
2071  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
2072 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2073 #undef JSON_HEDLEY_IS_CONSTEXPR_
2074 #endif
2075 #if \
2076  JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
2077  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
2078  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2079  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
2080  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
2081  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
2082  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
2083  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
2084  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
2085  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2086 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
2087 #endif
2088 #if !defined(__cplusplus)
2089 # if \
2090  JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
2091  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
2092  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2093  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
2094  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
2095  JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
2096  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
2097 #if defined(__INTPTR_TYPE__)
2098 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
2099 #else
2100 #include <stdint.h>
2101 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
2102 #endif
2103 # elif \
2104  ( \
2105  defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
2106  !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
2107  !defined(JSON_HEDLEY_PGI_VERSION) && \
2108  !defined(JSON_HEDLEY_IAR_VERSION)) || \
2109  (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
2110  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
2111  JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
2112  JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
2113  JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
2114 #if defined(__INTPTR_TYPE__)
2115 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
2116 #else
2117 #include <stdint.h>
2118 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
2119 #endif
2120 # elif \
2121  defined(JSON_HEDLEY_GCC_VERSION) || \
2122  defined(JSON_HEDLEY_INTEL_VERSION) || \
2123  defined(JSON_HEDLEY_TINYC_VERSION) || \
2124  defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
2125  JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
2126  defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
2127  defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
2128  defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
2129  defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
2130  defined(__clang__)
2131 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
2132  sizeof(void) != \
2133  sizeof(*( \
2134  1 ? \
2135  ((void*) ((expr) * 0L) ) : \
2136 ((struct { char v[sizeof(void) * 2]; } *) 1) \
2137  ) \
2138  ) \
2139  )
2140 # endif
2141 #endif
2142 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2143 #if !defined(JSON_HEDLEY_IS_CONSTANT)
2144 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
2145 #endif
2146 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2147 #else
2148 #if !defined(JSON_HEDLEY_IS_CONSTANT)
2149 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2150 #endif
2151 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2152 #endif
2153 
2154 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2155 #undef JSON_HEDLEY_BEGIN_C_DECLS
2156 #endif
2157 #if defined(JSON_HEDLEY_END_C_DECLS)
2158 #undef JSON_HEDLEY_END_C_DECLS
2159 #endif
2160 #if defined(JSON_HEDLEY_C_DECL)
2161 #undef JSON_HEDLEY_C_DECL
2162 #endif
2163 #if defined(__cplusplus)
2164 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2165 #define JSON_HEDLEY_END_C_DECLS }
2166 #define JSON_HEDLEY_C_DECL extern "C"
2167 #else
2168 #define JSON_HEDLEY_BEGIN_C_DECLS
2169 #define JSON_HEDLEY_END_C_DECLS
2170 #define JSON_HEDLEY_C_DECL
2171 #endif
2172 
2173 #if defined(JSON_HEDLEY_STATIC_ASSERT)
2174 #undef JSON_HEDLEY_STATIC_ASSERT
2175 #endif
2176 #if \
2177  !defined(__cplusplus) && ( \
2178  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2179  (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2180  JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2181  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2182  defined(_Static_assert) \
2183  )
2184 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2185 #elif \
2186  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2187  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2188  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2189 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2190 #else
2191 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2192 #endif
2193 
2194 #if defined(JSON_HEDLEY_NULL)
2195 #undef JSON_HEDLEY_NULL
2196 #endif
2197 #if defined(__cplusplus)
2198 #if __cplusplus >= 201103L
2199 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2200 #elif defined(NULL)
2201 #define JSON_HEDLEY_NULL NULL
2202 #else
2203 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2204 #endif
2205 #elif defined(NULL)
2206 #define JSON_HEDLEY_NULL NULL
2207 #else
2208 #define JSON_HEDLEY_NULL ((void*) 0)
2209 #endif
2210 
2211 #if defined(JSON_HEDLEY_MESSAGE)
2212 #undef JSON_HEDLEY_MESSAGE
2213 #endif
2214 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2215 # define JSON_HEDLEY_MESSAGE(msg) \
2216  JSON_HEDLEY_DIAGNOSTIC_PUSH \
2217  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2218  JSON_HEDLEY_PRAGMA(message msg) \
2219  JSON_HEDLEY_DIAGNOSTIC_POP
2220 #elif \
2221  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2222  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2223 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2224 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2225 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2226 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2227 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2228 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2229 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2230 #else
2231 # define JSON_HEDLEY_MESSAGE(msg)
2232 #endif
2233 
2234 #if defined(JSON_HEDLEY_WARNING)
2235 #undef JSON_HEDLEY_WARNING
2236 #endif
2237 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2238 # define JSON_HEDLEY_WARNING(msg) \
2239  JSON_HEDLEY_DIAGNOSTIC_PUSH \
2240  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2241  JSON_HEDLEY_PRAGMA(clang warning msg) \
2242  JSON_HEDLEY_DIAGNOSTIC_POP
2243 #elif \
2244  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2245  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2246  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2247 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2248 #elif \
2249  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2250  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2251 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2252 #else
2253 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2254 #endif
2255 
2256 #if defined(JSON_HEDLEY_REQUIRE)
2257 #undef JSON_HEDLEY_REQUIRE
2258 #endif
2259 #if defined(JSON_HEDLEY_REQUIRE_MSG)
2260 #undef JSON_HEDLEY_REQUIRE_MSG
2261 #endif
2262 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2263 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2264 # define JSON_HEDLEY_REQUIRE(expr) \
2265  JSON_HEDLEY_DIAGNOSTIC_PUSH \
2266  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2267  __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2268  JSON_HEDLEY_DIAGNOSTIC_POP
2269 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2270  JSON_HEDLEY_DIAGNOSTIC_PUSH \
2271  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2272  __attribute__((diagnose_if(!(expr), msg, "error"))) \
2273  JSON_HEDLEY_DIAGNOSTIC_POP
2274 # else
2275 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2276 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2277 # endif
2278 #else
2279 # define JSON_HEDLEY_REQUIRE(expr)
2280 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2281 #endif
2282 
2283 #if defined(JSON_HEDLEY_FLAGS)
2284 #undef JSON_HEDLEY_FLAGS
2285 #endif
2286 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2287 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2288 #else
2289 #define JSON_HEDLEY_FLAGS
2290 #endif
2291 
2292 #if defined(JSON_HEDLEY_FLAGS_CAST)
2293 #undef JSON_HEDLEY_FLAGS_CAST
2294 #endif
2295 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2296 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2297  JSON_HEDLEY_DIAGNOSTIC_PUSH \
2298  _Pragma("warning(disable:188)") \
2299  ((T) (expr)); \
2300  JSON_HEDLEY_DIAGNOSTIC_POP \
2301  }))
2302 #else
2303 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2304 #endif
2305 
2306 #if defined(JSON_HEDLEY_EMPTY_BASES)
2307 #undef JSON_HEDLEY_EMPTY_BASES
2308 #endif
2309 #if \
2310  (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2311  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2312 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2313 #else
2314 #define JSON_HEDLEY_EMPTY_BASES
2315 #endif
2316 
2317  /* Remaining macros are deprecated. */
2318 
2319 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2320 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2321 #endif
2322 #if defined(__clang__)
2323 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2324 #else
2325 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2326 #endif
2327 
2328 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2329 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2330 #endif
2331 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2332 
2333 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2334 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2335 #endif
2336 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2337 
2338 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2339 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2340 #endif
2341 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2342 
2343 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2344 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2345 #endif
2346 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2347 
2348 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2349 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2350 #endif
2351 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2352 
2353 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2354 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2355 #endif
2356 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2357 
2358 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2359 #undef JSON_HEDLEY_CLANG_HAS_WARNING
2360 #endif
2361 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2362 
2363 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2364 
2365 
2366 // This file contains all internal macro definitions (except those affecting ABI)
2367 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2368 
2369 // #include <nlohmann/detail/abi_macros.hpp>
2370 
2371 
2372 // exclude unsupported compilers
2373 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2374 #if defined(__clang__)
2375 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2376 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2377 #endif
2378 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2379 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2380 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2381 #endif
2382 #endif
2383 #endif
2384 
2385 // C++ language standard detection
2386 // if the user manually specified the used c++ version this is skipped
2387 #if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2388 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2389 #define JSON_HAS_CPP_20
2390 #define JSON_HAS_CPP_17
2391 #define JSON_HAS_CPP_14
2392 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2393 #define JSON_HAS_CPP_17
2394 #define JSON_HAS_CPP_14
2395 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2396 #define JSON_HAS_CPP_14
2397 #endif
2398 // the cpp 11 flag is always specified because it is the minimal required version
2399 #define JSON_HAS_CPP_11
2400 #endif
2401 
2402 #ifdef __has_include
2403 #if __has_include(<version>)
2404 #include <version>
2405 #endif
2406 #endif
2407 
2408 #if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
2409 #ifdef JSON_HAS_CPP_17
2410 #if defined(__cpp_lib_filesystem)
2411 #define JSON_HAS_FILESYSTEM 1
2412 #elif defined(__cpp_lib_experimental_filesystem)
2413 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2414 #elif !defined(__has_include)
2415 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2416 #elif __has_include(<filesystem>)
2417 #define JSON_HAS_FILESYSTEM 1
2418 #elif __has_include(<experimental/filesystem>)
2419 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2420 #endif
2421 
2422 // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
2423 #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
2424 #undef JSON_HAS_FILESYSTEM
2425 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2426 #endif
2427 
2428 // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
2429 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
2430 #undef JSON_HAS_FILESYSTEM
2431 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2432 #endif
2433 
2434 // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
2435 #if defined(__clang_major__) && __clang_major__ < 7
2436 #undef JSON_HAS_FILESYSTEM
2437 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2438 #endif
2439 
2440 // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
2441 #if defined(_MSC_VER) && _MSC_VER < 1914
2442 #undef JSON_HAS_FILESYSTEM
2443 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2444 #endif
2445 
2446 // no filesystem support before iOS 13
2447 #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
2448 #undef JSON_HAS_FILESYSTEM
2449 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2450 #endif
2451 
2452 // no filesystem support before macOS Catalina
2453 #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
2454 #undef JSON_HAS_FILESYSTEM
2455 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2456 #endif
2457 #endif
2458 #endif
2459 
2460 #ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2461 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
2462 #endif
2463 
2464 #ifndef JSON_HAS_FILESYSTEM
2465 #define JSON_HAS_FILESYSTEM 0
2466 #endif
2467 
2468 #ifndef JSON_HAS_THREE_WAY_COMPARISON
2469 #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
2470  && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
2471 #define JSON_HAS_THREE_WAY_COMPARISON 1
2472 #else
2473 #define JSON_HAS_THREE_WAY_COMPARISON 0
2474 #endif
2475 #endif
2476 
2477 #ifndef JSON_HAS_RANGES
2478  // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
2479 #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
2480 #define JSON_HAS_RANGES 0
2481 #elif defined(__cpp_lib_ranges)
2482 #define JSON_HAS_RANGES 1
2483 #else
2484 #define JSON_HAS_RANGES 0
2485 #endif
2486 #endif
2487 
2488 #ifndef JSON_HAS_STATIC_RTTI
2489 #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
2490 #define JSON_HAS_STATIC_RTTI 1
2491 #else
2492 #define JSON_HAS_STATIC_RTTI 0
2493 #endif
2494 #endif
2495 
2496 #ifdef JSON_HAS_CPP_17
2497 #define JSON_INLINE_VARIABLE inline
2498 #else
2499 #define JSON_INLINE_VARIABLE
2500 #endif
2501 
2502 #if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
2503 #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
2504 #else
2505 #define JSON_NO_UNIQUE_ADDRESS
2506 #endif
2507 
2508 // disable documentation warnings on clang
2509 #if defined(__clang__)
2510 #pragma clang diagnostic push
2511 #pragma clang diagnostic ignored "-Wdocumentation"
2512 #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2513 #endif
2514 
2515 // allow disabling exceptions
2516 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2517 #define JSON_THROW(exception) throw exception
2518 #define JSON_TRY try
2519 #define JSON_CATCH(exception) catch(exception)
2520 #define JSON_INTERNAL_CATCH(exception) catch(exception)
2521 #else
2522 #include <cstdlib>
2523 #define JSON_THROW(exception) std::abort()
2524 #define JSON_TRY if(true)
2525 #define JSON_CATCH(exception) if(false)
2526 #define JSON_INTERNAL_CATCH(exception) if(false)
2527 #endif
2528 
2529 // override exception macros
2530 #if defined(JSON_THROW_USER)
2531 #undef JSON_THROW
2532 #define JSON_THROW JSON_THROW_USER
2533 #endif
2534 #if defined(JSON_TRY_USER)
2535 #undef JSON_TRY
2536 #define JSON_TRY JSON_TRY_USER
2537 #endif
2538 #if defined(JSON_CATCH_USER)
2539 #undef JSON_CATCH
2540 #define JSON_CATCH JSON_CATCH_USER
2541 #undef JSON_INTERNAL_CATCH
2542 #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2543 #endif
2544 #if defined(JSON_INTERNAL_CATCH_USER)
2545 #undef JSON_INTERNAL_CATCH
2546 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2547 #endif
2548 
2549 // allow overriding assert
2550 #if !defined(JSON_ASSERT)
2551 #include <cassert> // assert
2552 #define JSON_ASSERT(x) assert(x)
2553 #endif
2554 
2555 // allow to access some private functions (needed by the test suite)
2556 #if defined(JSON_TESTS_PRIVATE)
2557 #define JSON_PRIVATE_UNLESS_TESTED public
2558 #else
2559 #define JSON_PRIVATE_UNLESS_TESTED private
2560 #endif
2561 
2567 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2568  template<typename BasicJsonType> \
2569  inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2570  { \
2571  static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2572  static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2573  auto it = std::find_if(std::begin(m), std::end(m), \
2574  [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2575  { \
2576  return ej_pair.first == e; \
2577  }); \
2578  j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2579  } \
2580  template<typename BasicJsonType> \
2581  inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2582  { \
2583  static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2584  static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2585  auto it = std::find_if(std::begin(m), std::end(m), \
2586  [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2587  { \
2588  return ej_pair.second == j; \
2589  }); \
2590  e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2591  }
2592 
2593 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2594 // may be removed in the future once the class is split.
2595 
2596 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2597  template<template<typename, typename, typename...> class ObjectType, \
2598  template<typename, typename...> class ArrayType, \
2599  class StringType, class BooleanType, class NumberIntegerType, \
2600  class NumberUnsignedType, class NumberFloatType, \
2601  template<typename> class AllocatorType, \
2602  template<typename, typename = void> class JSONSerializer, \
2603  class BinaryType, \
2604  class CustomBaseClass>
2605 
2606 #define NLOHMANN_BASIC_JSON_TPL \
2607  basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2608  NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2609  AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
2610 
2611 // Macros to simplify conversion from/to types
2612 
2613 #define NLOHMANN_JSON_EXPAND( x ) x
2614 #define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
2615 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2616  NLOHMANN_JSON_PASTE64, \
2617  NLOHMANN_JSON_PASTE63, \
2618  NLOHMANN_JSON_PASTE62, \
2619  NLOHMANN_JSON_PASTE61, \
2620  NLOHMANN_JSON_PASTE60, \
2621  NLOHMANN_JSON_PASTE59, \
2622  NLOHMANN_JSON_PASTE58, \
2623  NLOHMANN_JSON_PASTE57, \
2624  NLOHMANN_JSON_PASTE56, \
2625  NLOHMANN_JSON_PASTE55, \
2626  NLOHMANN_JSON_PASTE54, \
2627  NLOHMANN_JSON_PASTE53, \
2628  NLOHMANN_JSON_PASTE52, \
2629  NLOHMANN_JSON_PASTE51, \
2630  NLOHMANN_JSON_PASTE50, \
2631  NLOHMANN_JSON_PASTE49, \
2632  NLOHMANN_JSON_PASTE48, \
2633  NLOHMANN_JSON_PASTE47, \
2634  NLOHMANN_JSON_PASTE46, \
2635  NLOHMANN_JSON_PASTE45, \
2636  NLOHMANN_JSON_PASTE44, \
2637  NLOHMANN_JSON_PASTE43, \
2638  NLOHMANN_JSON_PASTE42, \
2639  NLOHMANN_JSON_PASTE41, \
2640  NLOHMANN_JSON_PASTE40, \
2641  NLOHMANN_JSON_PASTE39, \
2642  NLOHMANN_JSON_PASTE38, \
2643  NLOHMANN_JSON_PASTE37, \
2644  NLOHMANN_JSON_PASTE36, \
2645  NLOHMANN_JSON_PASTE35, \
2646  NLOHMANN_JSON_PASTE34, \
2647  NLOHMANN_JSON_PASTE33, \
2648  NLOHMANN_JSON_PASTE32, \
2649  NLOHMANN_JSON_PASTE31, \
2650  NLOHMANN_JSON_PASTE30, \
2651  NLOHMANN_JSON_PASTE29, \
2652  NLOHMANN_JSON_PASTE28, \
2653  NLOHMANN_JSON_PASTE27, \
2654  NLOHMANN_JSON_PASTE26, \
2655  NLOHMANN_JSON_PASTE25, \
2656  NLOHMANN_JSON_PASTE24, \
2657  NLOHMANN_JSON_PASTE23, \
2658  NLOHMANN_JSON_PASTE22, \
2659  NLOHMANN_JSON_PASTE21, \
2660  NLOHMANN_JSON_PASTE20, \
2661  NLOHMANN_JSON_PASTE19, \
2662  NLOHMANN_JSON_PASTE18, \
2663  NLOHMANN_JSON_PASTE17, \
2664  NLOHMANN_JSON_PASTE16, \
2665  NLOHMANN_JSON_PASTE15, \
2666  NLOHMANN_JSON_PASTE14, \
2667  NLOHMANN_JSON_PASTE13, \
2668  NLOHMANN_JSON_PASTE12, \
2669  NLOHMANN_JSON_PASTE11, \
2670  NLOHMANN_JSON_PASTE10, \
2671  NLOHMANN_JSON_PASTE9, \
2672  NLOHMANN_JSON_PASTE8, \
2673  NLOHMANN_JSON_PASTE7, \
2674  NLOHMANN_JSON_PASTE6, \
2675  NLOHMANN_JSON_PASTE5, \
2676  NLOHMANN_JSON_PASTE4, \
2677  NLOHMANN_JSON_PASTE3, \
2678  NLOHMANN_JSON_PASTE2, \
2679  NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2680 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2681 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2682 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2683 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2684 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2685 #define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
2686 #define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
2687 #define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
2688 #define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
2689 #define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
2690 #define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
2691 #define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
2692 #define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
2693 #define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
2694 #define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
2695 #define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
2696 #define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
2697 #define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
2698 #define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
2699 #define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
2700 #define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
2701 #define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
2702 #define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
2703 #define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
2704 #define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
2705 #define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
2706 #define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
2707 #define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
2708 #define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
2709 #define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
2710 #define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
2711 #define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
2712 #define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
2713 #define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
2714 #define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
2715 #define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
2716 #define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
2717 #define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
2718 #define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
2719 #define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
2720 #define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
2721 #define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
2722 #define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
2723 #define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
2724 #define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
2725 #define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
2726 #define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
2727 #define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
2728 #define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
2729 #define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
2730 #define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
2731 #define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
2732 #define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
2733 #define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
2734 #define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
2735 #define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
2736 #define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
2737 #define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
2738 #define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
2739 #define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
2740 #define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
2741 #define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
2742 #define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
2743 
2744 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2745 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2746 #define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);
2747 
2753 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2754  friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2755  friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2756 
2757 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \
2758  friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2759  friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2760 
2761 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \
2762  friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2763 
2769 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2770  inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2771  inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2772 
2773 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \
2774  inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2775 
2776 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \
2777  inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2778  inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2779 
2780 // inspired from https://stackoverflow.com/a/26745591
2781 // allows to call any std function as if (e.g. with begin):
2782 // using std::begin; begin(x);
2783 //
2784 // it allows using the detected idiom to retrieve the return type
2785 // of such an expression
2786 #define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \
2787  namespace detail { \
2788  using std::std_name; \
2789  \
2790  template<typename... T> \
2791  using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
2792  } \
2793  \
2794  namespace detail2 { \
2795  struct std_name##_tag \
2796  { \
2797  }; \
2798  \
2799  template<typename... T> \
2800  std_name##_tag std_name(T&&...); \
2801  \
2802  template<typename... T> \
2803  using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
2804  \
2805  template<typename... T> \
2806  struct would_call_std_##std_name \
2807  { \
2808  static constexpr auto const value = ::nlohmann::detail:: \
2809  is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
2810  }; \
2811  } /* namespace detail2 */ \
2812  \
2813  template<typename... T> \
2814  struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...> \
2815  { \
2816  }
2817 
2818 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2819 #define JSON_USE_IMPLICIT_CONVERSIONS 1
2820 #endif
2821 
2822 #if JSON_USE_IMPLICIT_CONVERSIONS
2823 #define JSON_EXPLICIT
2824 #else
2825 #define JSON_EXPLICIT explicit
2826 #endif
2827 
2828 #ifndef JSON_DISABLE_ENUM_SERIALIZATION
2829 #define JSON_DISABLE_ENUM_SERIALIZATION 0
2830 #endif
2831 
2832 #ifndef JSON_USE_GLOBAL_UDLS
2833 #define JSON_USE_GLOBAL_UDLS 1
2834 #endif
2835 
2836 #if JSON_HAS_THREE_WAY_COMPARISON
2837 #include <compare> // partial_ordering
2838 #endif
2839 
2840 NLOHMANN_JSON_NAMESPACE_BEGIN
2841 namespace detail
2842 {
2843 
2845  // JSON type enumeration //
2847 
2872  enum class value_t : std::uint8_t
2873  {
2874  null,
2875  object,
2876  array,
2877  string,
2878  boolean,
2879  number_integer,
2880  number_unsigned,
2881  number_float,
2882  binary,
2883  discarded
2884  };
2885 
2899 #if JSON_HAS_THREE_WAY_COMPARISON
2900  inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
2901 #else
2902  inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2903 #endif
2904  {
2905  static constexpr std::array<std::uint8_t, 9> order = { {
2906  0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
2907  1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
2908  6 /* binary */
2909  }
2910  };
2911 
2912  const auto l_index = static_cast<std::size_t>(lhs);
2913  const auto r_index = static_cast<std::size_t>(rhs);
2914 #if JSON_HAS_THREE_WAY_COMPARISON
2915  if (l_index < order.size() && r_index < order.size())
2916  {
2917  return order[l_index] <=> order[r_index]; // *NOPAD*
2918  }
2919  return std::partial_ordering::unordered;
2920 #else
2921  return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
2922 #endif
2923  }
2924 
2925  // GCC selects the built-in operator< over an operator rewritten from
2926  // a user-defined spaceship operator
2927  // Clang, MSVC, and ICC select the rewritten candidate
2928  // (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
2929 #if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
2930  inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2931  {
2932  return std::is_lt(lhs <=> rhs); // *NOPAD*
2933  }
2934 #endif
2935 
2936 } // namespace detail
2937 NLOHMANN_JSON_NAMESPACE_END
2938 
2939 // #include <nlohmann/detail/string_escape.hpp>
2940 // __ _____ _____ _____
2941 // __| | __| | | | JSON for Modern C++
2942 // | | |__ | | | | | | version 3.11.3
2943 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
2944 //
2945 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
2946 // SPDX-License-Identifier: MIT
2947 
2948 
2949 
2950 // #include <nlohmann/detail/abi_macros.hpp>
2951 
2952 
2953 NLOHMANN_JSON_NAMESPACE_BEGIN
2954 namespace detail
2955 {
2956 
2970  template<typename StringType>
2971  inline void replace_substring(StringType& s, const StringType& f,
2972  const StringType& t)
2973  {
2974  JSON_ASSERT(!f.empty());
2975  for (auto pos = s.find(f); // find first occurrence of f
2976  pos != StringType::npos; // make sure f was found
2977  s.replace(pos, f.size(), t), // replace with t, and
2978  pos = s.find(f, pos + t.size())) // find next occurrence of f
2979  {
2980  }
2981  }
2982 
2990  template<typename StringType>
2991  inline StringType escape(StringType s)
2992  {
2993  replace_substring(s, StringType{ "~" }, StringType{ "~0" });
2994  replace_substring(s, StringType{ "/" }, StringType{ "~1" });
2995  return s;
2996  }
2997 
3005  template<typename StringType>
3006  static void unescape(StringType& s)
3007  {
3008  replace_substring(s, StringType{ "~1" }, StringType{ "/" });
3009  replace_substring(s, StringType{ "~0" }, StringType{ "~" });
3010  }
3011 
3012 } // namespace detail
3013 NLOHMANN_JSON_NAMESPACE_END
3014 
3015 // #include <nlohmann/detail/input/position_t.hpp>
3016 // __ _____ _____ _____
3017 // __| | __| | | | JSON for Modern C++
3018 // | | |__ | | | | | | version 3.11.3
3019 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3020 //
3021 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3022 // SPDX-License-Identifier: MIT
3023 
3024 
3025 
3026 #include <cstddef> // size_t
3027 
3028 // #include <nlohmann/detail/abi_macros.hpp>
3029 
3030 
3031 NLOHMANN_JSON_NAMESPACE_BEGIN
3032 namespace detail
3033 {
3034 
3036  struct position_t
3037  {
3039  std::size_t chars_read_total = 0;
3041  std::size_t chars_read_current_line = 0;
3043  std::size_t lines_read = 0;
3044 
3046  constexpr operator size_t() const
3047  {
3048  return chars_read_total;
3049  }
3050  };
3051 
3052 } // namespace detail
3053 NLOHMANN_JSON_NAMESPACE_END
3054 
3055 // #include <nlohmann/detail/macro_scope.hpp>
3056 
3057 // #include <nlohmann/detail/meta/cpp_future.hpp>
3058 // __ _____ _____ _____
3059 // __| | __| | | | JSON for Modern C++
3060 // | | |__ | | | | | | version 3.11.3
3061 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3062 //
3063 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3064 // SPDX-FileCopyrightText: 2018 The Abseil Authors
3065 // SPDX-License-Identifier: MIT
3066 
3067 
3068 
3069 #include <array> // array
3070 #include <cstddef> // size_t
3071 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
3072 #include <utility> // index_sequence, make_index_sequence, index_sequence_for
3073 
3074 // #include <nlohmann/detail/macro_scope.hpp>
3075 
3076 
3077 NLOHMANN_JSON_NAMESPACE_BEGIN
3078 namespace detail
3079 {
3080 
3081  template<typename T>
3082  using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3083 
3084 #ifdef JSON_HAS_CPP_14
3085 
3086  // the following utilities are natively available in C++14
3087  using std::enable_if_t;
3088  using std::index_sequence;
3089  using std::make_index_sequence;
3090  using std::index_sequence_for;
3091 
3092 #else
3093 
3094  // alias templates to reduce boilerplate
3095  template<bool B, typename T = void>
3096  using enable_if_t = typename std::enable_if<B, T>::type;
3097 
3098  // The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
3099  // which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
3100 
3102 
3103  // integer_sequence
3104  //
3105  // Class template representing a compile-time integer sequence. An instantiation
3106  // of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
3107  // type through its template arguments (which is a common need when
3108  // working with C++11 variadic templates). `absl::integer_sequence` is designed
3109  // to be a drop-in replacement for C++14's `std::integer_sequence`.
3110  //
3111  // Example:
3112  //
3113  // template< class T, T... Ints >
3114  // void user_function(integer_sequence<T, Ints...>);
3115  //
3116  // int main()
3117  // {
3118  // // user_function's `T` will be deduced to `int` and `Ints...`
3119  // // will be deduced to `0, 1, 2, 3, 4`.
3120  // user_function(make_integer_sequence<int, 5>());
3121  // }
3122  template <typename T, T... Ints>
3123  struct integer_sequence
3124  {
3125  using value_type = T;
3126  static constexpr std::size_t size() noexcept
3127  {
3128  return sizeof...(Ints);
3129  }
3130  };
3131 
3132  // index_sequence
3133  //
3134  // A helper template for an `integer_sequence` of `size_t`,
3135  // `absl::index_sequence` is designed to be a drop-in replacement for C++14's
3136  // `std::index_sequence`.
3137  template <size_t... Ints>
3138  using index_sequence = integer_sequence<size_t, Ints...>;
3139 
3140  namespace utility_internal
3141  {
3142 
3143  template <typename Seq, size_t SeqSize, size_t Rem>
3144  struct Extend;
3145 
3146  // Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
3147  template <typename T, T... Ints, size_t SeqSize>
3148  struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3149  {
3150  using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3151  };
3152 
3153  template <typename T, T... Ints, size_t SeqSize>
3154  struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3155  {
3156  using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3157  };
3158 
3159  // Recursion helper for 'make_integer_sequence<T, N>'.
3160  // 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
3161  template <typename T, size_t N>
3162  struct Gen
3163  {
3164  using type =
3165  typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3166  };
3167 
3168  template <typename T>
3169  struct Gen<T, 0>
3170  {
3171  using type = integer_sequence<T>;
3172  };
3173 
3174  } // namespace utility_internal
3175 
3176  // Compile-time sequences of integers
3177 
3178  // make_integer_sequence
3179  //
3180  // This template alias is equivalent to
3181  // `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
3182  // replacement for C++14's `std::make_integer_sequence`.
3183  template <typename T, T N>
3184  using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
3185 
3186  // make_index_sequence
3187  //
3188  // This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
3189  // and is designed to be a drop-in replacement for C++14's
3190  // `std::make_index_sequence`.
3191  template <size_t N>
3192  using make_index_sequence = make_integer_sequence<size_t, N>;
3193 
3194  // index_sequence_for
3195  //
3196  // Converts a typename pack into an index sequence of the same length, and
3197  // is designed to be a drop-in replacement for C++14's
3198  // `std::index_sequence_for()`
3199  template <typename... Ts>
3200  using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
3201 
3203 
3204 #endif
3205 
3206 // dispatch utility (taken from ranges-v3)
3207  template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
3208  template<> struct priority_tag<0> {};
3209 
3210  // taken from ranges-v3
3211  template<typename T>
3212  struct static_const
3213  {
3214  static JSON_INLINE_VARIABLE constexpr T value{};
3215  };
3216 
3217 #ifndef JSON_HAS_CPP_17
3218  template<typename T>
3219  constexpr T static_const<T>::value;
3220 #endif
3221 
3222  template<typename T, typename... Args>
3223  inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
3224  {
3225  return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
3226  }
3227 
3228 } // namespace detail
3229 NLOHMANN_JSON_NAMESPACE_END
3230 
3231 // #include <nlohmann/detail/meta/type_traits.hpp>
3232 // __ _____ _____ _____
3233 // __| | __| | | | JSON for Modern C++
3234 // | | |__ | | | | | | version 3.11.3
3235 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3236 //
3237 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3238 // SPDX-License-Identifier: MIT
3239 
3240 
3241 
3242 #include <limits> // numeric_limits
3243 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
3244 #include <utility> // declval
3245 #include <tuple> // tuple
3246 #include <string> // char_traits
3247 
3248 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
3249 // __ _____ _____ _____
3250 // __| | __| | | | JSON for Modern C++
3251 // | | |__ | | | | | | version 3.11.3
3252 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3253 //
3254 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3255 // SPDX-License-Identifier: MIT
3256 
3257 
3258 
3259 #include <iterator> // random_access_iterator_tag
3260 
3261 // #include <nlohmann/detail/abi_macros.hpp>
3262 
3263 // #include <nlohmann/detail/meta/void_t.hpp>
3264 
3265 // #include <nlohmann/detail/meta/cpp_future.hpp>
3266 
3267 
3268 NLOHMANN_JSON_NAMESPACE_BEGIN
3269 namespace detail
3270 {
3271 
3272  template<typename It, typename = void>
3273  struct iterator_types {};
3274 
3275  template<typename It>
3276  struct iterator_types <
3277  It,
3278  void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3279  typename It::reference, typename It::iterator_category >>
3280  {
3281  using difference_type = typename It::difference_type;
3282  using value_type = typename It::value_type;
3283  using pointer = typename It::pointer;
3284  using reference = typename It::reference;
3285  using iterator_category = typename It::iterator_category;
3286  };
3287 
3288  // This is required as some compilers implement std::iterator_traits in a way that
3289  // doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
3290  template<typename T, typename = void>
3291  struct iterator_traits
3292  {
3293  };
3294 
3295  template<typename T>
3296  struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3297  : iterator_types<T>
3298  {
3299  };
3300 
3301  template<typename T>
3302  struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3303  {
3304  using iterator_category = std::random_access_iterator_tag;
3305  using value_type = T;
3306  using difference_type = ptrdiff_t;
3307  using pointer = T*;
3308  using reference = T&;
3309  };
3310 
3311 } // namespace detail
3312 NLOHMANN_JSON_NAMESPACE_END
3313 
3314 // #include <nlohmann/detail/macro_scope.hpp>
3315 
3316 // #include <nlohmann/detail/meta/call_std/begin.hpp>
3317 // __ _____ _____ _____
3318 // __| | __| | | | JSON for Modern C++
3319 // | | |__ | | | | | | version 3.11.3
3320 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3321 //
3322 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3323 // SPDX-License-Identifier: MIT
3324 
3325 
3326 
3327 // #include <nlohmann/detail/macro_scope.hpp>
3328 
3329 
3330 NLOHMANN_JSON_NAMESPACE_BEGIN
3331 
3332 NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
3333 
3334 NLOHMANN_JSON_NAMESPACE_END
3335 
3336 // #include <nlohmann/detail/meta/call_std/end.hpp>
3337 // __ _____ _____ _____
3338 // __| | __| | | | JSON for Modern C++
3339 // | | |__ | | | | | | version 3.11.3
3340 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3341 //
3342 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3343 // SPDX-License-Identifier: MIT
3344 
3345 
3346 
3347 // #include <nlohmann/detail/macro_scope.hpp>
3348 
3349 
3350 NLOHMANN_JSON_NAMESPACE_BEGIN
3351 
3352 NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
3353 
3354 NLOHMANN_JSON_NAMESPACE_END
3355 
3356 // #include <nlohmann/detail/meta/cpp_future.hpp>
3357 
3358 // #include <nlohmann/detail/meta/detected.hpp>
3359 
3360 // #include <nlohmann/json_fwd.hpp>
3361 // __ _____ _____ _____
3362 // __| | __| | | | JSON for Modern C++
3363 // | | |__ | | | | | | version 3.11.3
3364 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
3365 //
3366 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3367 // SPDX-License-Identifier: MIT
3368 
3369 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3370 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3371 
3372 #include <cstdint> // int64_t, uint64_t
3373 #include <map> // map
3374 #include <memory> // allocator
3375 #include <string> // string
3376 #include <vector> // vector
3377 
3378 // #include <nlohmann/detail/abi_macros.hpp>
3379 
3380 
3386 NLOHMANN_JSON_NAMESPACE_BEGIN
3387 
3395 template<typename T = void, typename SFINAE = void>
3396 struct adl_serializer;
3397 
3400 template<template<typename U, typename V, typename... Args> class ObjectType =
3401  std::map,
3402  template<typename U, typename... Args> class ArrayType = std::vector,
3403  class StringType = std::string, class BooleanType = bool,
3404  class NumberIntegerType = std::int64_t,
3405  class NumberUnsignedType = std::uint64_t,
3406  class NumberFloatType = double,
3407  template<typename U> class AllocatorType = std::allocator,
3408  template<typename T, typename SFINAE = void> class JSONSerializer =
3409  adl_serializer,
3410  class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
3411  class CustomBaseClass = void>
3412 class basic_json;
3413 
3416 template<typename RefStringType>
3417 class json_pointer;
3418 
3423 using json = basic_json<>;
3424 
3427 template<class Key, class T, class IgnoredLess, class Allocator>
3428 struct ordered_map;
3429 
3432 using ordered_json = basic_json<nlohmann::ordered_map>;
3433 
3434 NLOHMANN_JSON_NAMESPACE_END
3435 
3436 #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
3437 
3438 
3439 NLOHMANN_JSON_NAMESPACE_BEGIN
3448 namespace detail
3449 {
3450 
3452  // helpers //
3454 
3455  // Note to maintainers:
3456  //
3457  // Every trait in this file expects a non CV-qualified type.
3458  // The only exceptions are in the 'aliases for detected' section
3459  // (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
3460  //
3461  // In this case, T has to be properly CV-qualified to constraint the function arguments
3462  // (e.g. to_json(BasicJsonType&, const T&))
3463 
3464  template<typename> struct is_basic_json : std::false_type {};
3465 
3466  NLOHMANN_BASIC_JSON_TPL_DECLARATION
3467  struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3468 
3469  // used by exceptions create() member functions
3470  // true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
3471  // false_type otherwise
3472  template<typename BasicJsonContext>
3473  struct is_basic_json_context :
3474  std::integral_constant < bool,
3475  is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
3476  || std::is_same<BasicJsonContext, std::nullptr_t>::value >
3477  {};
3478 
3480  // json_ref helpers //
3482 
3483  template<typename>
3484  class json_ref;
3485 
3486  template<typename>
3487  struct is_json_ref : std::false_type {};
3488 
3489  template<typename T>
3490  struct is_json_ref<json_ref<T>> : std::true_type {};
3491 
3493  // aliases for detected //
3495 
3496  template<typename T>
3497  using mapped_type_t = typename T::mapped_type;
3498 
3499  template<typename T>
3500  using key_type_t = typename T::key_type;
3501 
3502  template<typename T>
3503  using value_type_t = typename T::value_type;
3504 
3505  template<typename T>
3506  using difference_type_t = typename T::difference_type;
3507 
3508  template<typename T>
3509  using pointer_t = typename T::pointer;
3510 
3511  template<typename T>
3512  using reference_t = typename T::reference;
3513 
3514  template<typename T>
3515  using iterator_category_t = typename T::iterator_category;
3516 
3517  template<typename T, typename... Args>
3518  using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3519 
3520  template<typename T, typename... Args>
3521  using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3522 
3523  template<typename T, typename U>
3524  using get_template_function = decltype(std::declval<T>().template get<U>());
3525 
3526  // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3527  template<typename BasicJsonType, typename T, typename = void>
3528  struct has_from_json : std::false_type {};
3529 
3530  // trait checking if j.get<T> is valid
3531  // use this trait instead of std::is_constructible or std::is_convertible,
3532  // both rely on, or make use of implicit conversions, and thus fail when T
3533  // has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3534  template <typename BasicJsonType, typename T>
3535  struct is_getable
3536  {
3537  static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3538  };
3539 
3540  template<typename BasicJsonType, typename T>
3541  struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3542  {
3543  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3544 
3545  static constexpr bool value =
3546  is_detected_exact<void, from_json_function, serializer,
3547  const BasicJsonType&, T&>::value;
3548  };
3549 
3550  // This trait checks if JSONSerializer<T>::from_json(json const&) exists
3551  // this overload is used for non-default-constructible user-defined-types
3552  template<typename BasicJsonType, typename T, typename = void>
3553  struct has_non_default_from_json : std::false_type {};
3554 
3555  template<typename BasicJsonType, typename T>
3556  struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3557  {
3558  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3559 
3560  static constexpr bool value =
3561  is_detected_exact<T, from_json_function, serializer,
3562  const BasicJsonType&>::value;
3563  };
3564 
3565  // This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3566  // Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3567  template<typename BasicJsonType, typename T, typename = void>
3568  struct has_to_json : std::false_type {};
3569 
3570  template<typename BasicJsonType, typename T>
3571  struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3572  {
3573  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3574 
3575  static constexpr bool value =
3576  is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3577  T>::value;
3578  };
3579 
3580  template<typename T>
3581  using detect_key_compare = typename T::key_compare;
3582 
3583  template<typename T>
3584  struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
3585 
3586  // obtains the actual object key comparator
3587  template<typename BasicJsonType>
3588  struct actual_object_comparator
3589  {
3590  using object_t = typename BasicJsonType::object_t;
3591  using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
3592  using type = typename std::conditional < has_key_compare<object_t>::value,
3593  typename object_t::key_compare, object_comparator_t>::type;
3594  };
3595 
3596  template<typename BasicJsonType>
3597  using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
3598 
3600  // char_traits //
3602 
3603  // Primary template of char_traits calls std char_traits
3604  template<typename T>
3605  struct char_traits : std::char_traits<T>
3606  {};
3607 
3608  // Explicitly define char traits for unsigned char since it is not standard
3609  template<>
3610  struct char_traits<unsigned char> : std::char_traits<char>
3611  {
3612  using char_type = unsigned char;
3613  using int_type = uint64_t;
3614 
3615  // Redefine to_int_type function
3616  static int_type to_int_type(char_type c) noexcept
3617  {
3618  return static_cast<int_type>(c);
3619  }
3620 
3621  static char_type to_char_type(int_type i) noexcept
3622  {
3623  return static_cast<char_type>(i);
3624  }
3625 
3626  static constexpr int_type eof() noexcept
3627  {
3628  return static_cast<int_type>(EOF);
3629  }
3630  };
3631 
3632  // Explicitly define char traits for signed char since it is not standard
3633  template<>
3634  struct char_traits<signed char> : std::char_traits<char>
3635  {
3636  using char_type = signed char;
3637  using int_type = uint64_t;
3638 
3639  // Redefine to_int_type function
3640  static int_type to_int_type(char_type c) noexcept
3641  {
3642  return static_cast<int_type>(c);
3643  }
3644 
3645  static char_type to_char_type(int_type i) noexcept
3646  {
3647  return static_cast<char_type>(i);
3648  }
3649 
3650  static constexpr int_type eof() noexcept
3651  {
3652  return static_cast<int_type>(EOF);
3653  }
3654  };
3655 
3657  // is_ functions //
3659 
3660  // https://en.cppreference.com/w/cpp/types/conjunction
3661  template<class...> struct conjunction : std::true_type { };
3662  template<class B> struct conjunction<B> : B { };
3663  template<class B, class... Bn>
3664  struct conjunction<B, Bn...>
3665  : std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
3666 
3667  // https://en.cppreference.com/w/cpp/types/negation
3668  template<class B> struct negation : std::integral_constant < bool, !B::value > { };
3669 
3670  // Reimplementation of is_constructible and is_default_constructible, due to them being broken for
3671  // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
3672  // This causes compile errors in e.g. clang 3.5 or gcc 4.9.
3673  template <typename T>
3674  struct is_default_constructible : std::is_default_constructible<T> {};
3675 
3676  template <typename T1, typename T2>
3677  struct is_default_constructible<std::pair<T1, T2>>
3678  : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3679 
3680  template <typename T1, typename T2>
3681  struct is_default_constructible<const std::pair<T1, T2>>
3682  : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3683 
3684  template <typename... Ts>
3685  struct is_default_constructible<std::tuple<Ts...>>
3686  : conjunction<is_default_constructible<Ts>...> {};
3687 
3688  template <typename... Ts>
3689  struct is_default_constructible<const std::tuple<Ts...>>
3690  : conjunction<is_default_constructible<Ts>...> {};
3691 
3692  template <typename T, typename... Args>
3693  struct is_constructible : std::is_constructible<T, Args...> {};
3694 
3695  template <typename T1, typename T2>
3696  struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3697 
3698  template <typename T1, typename T2>
3699  struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3700 
3701  template <typename... Ts>
3702  struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3703 
3704  template <typename... Ts>
3705  struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3706 
3707  template<typename T, typename = void>
3708  struct is_iterator_traits : std::false_type {};
3709 
3710  template<typename T>
3711  struct is_iterator_traits<iterator_traits<T>>
3712  {
3713  private:
3714  using traits = iterator_traits<T>;
3715 
3716  public:
3717  static constexpr auto value =
3718  is_detected<value_type_t, traits>::value&&
3719  is_detected<difference_type_t, traits>::value&&
3720  is_detected<pointer_t, traits>::value&&
3721  is_detected<iterator_category_t, traits>::value&&
3722  is_detected<reference_t, traits>::value;
3723  };
3724 
3725  template<typename T>
3726  struct is_range
3727  {
3728  private:
3729  using t_ref = typename std::add_lvalue_reference<T>::type;
3730 
3731  using iterator = detected_t<result_of_begin, t_ref>;
3732  using sentinel = detected_t<result_of_end, t_ref>;
3733 
3734  // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
3735  // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
3736  // but reimplementing these would be too much work, as a lot of other concepts are used underneath
3737  static constexpr auto is_iterator_begin =
3738  is_iterator_traits<iterator_traits<iterator>>::value;
3739 
3740  public:
3741  static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value&& is_iterator_begin;
3742  };
3743 
3744  template<typename R>
3745  using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3746 
3747  template<typename T>
3748  using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
3749 
3750  // The following implementation of is_complete_type is taken from
3751  // https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
3752  // and is written by Xiang Fan who agreed to using it in this library.
3753 
3754  template<typename T, typename = void>
3755  struct is_complete_type : std::false_type {};
3756 
3757  template<typename T>
3758  struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3759 
3760  template<typename BasicJsonType, typename CompatibleObjectType,
3761  typename = void>
3762  struct is_compatible_object_type_impl : std::false_type {};
3763 
3764  template<typename BasicJsonType, typename CompatibleObjectType>
3765  struct is_compatible_object_type_impl <
3766  BasicJsonType, CompatibleObjectType,
3767  enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3768  is_detected<key_type_t, CompatibleObjectType>::value >>
3769  {
3770  using object_t = typename BasicJsonType::object_t;
3771 
3772  // macOS's is_constructible does not play well with nonesuch...
3773  static constexpr bool value =
3774  is_constructible<typename object_t::key_type,
3775  typename CompatibleObjectType::key_type>::value&&
3776  is_constructible<typename object_t::mapped_type,
3777  typename CompatibleObjectType::mapped_type>::value;
3778  };
3779 
3780  template<typename BasicJsonType, typename CompatibleObjectType>
3781  struct is_compatible_object_type
3782  : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3783 
3784  template<typename BasicJsonType, typename ConstructibleObjectType,
3785  typename = void>
3786  struct is_constructible_object_type_impl : std::false_type {};
3787 
3788  template<typename BasicJsonType, typename ConstructibleObjectType>
3789  struct is_constructible_object_type_impl <
3790  BasicJsonType, ConstructibleObjectType,
3791  enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3792  is_detected<key_type_t, ConstructibleObjectType>::value >>
3793  {
3794  using object_t = typename BasicJsonType::object_t;
3795 
3796  static constexpr bool value =
3797  (is_default_constructible<ConstructibleObjectType>::value &&
3798  (std::is_move_assignable<ConstructibleObjectType>::value ||
3799  std::is_copy_assignable<ConstructibleObjectType>::value) &&
3800  (is_constructible<typename ConstructibleObjectType::key_type,
3801  typename object_t::key_type>::value &&
3802  std::is_same <
3803  typename object_t::mapped_type,
3804  typename ConstructibleObjectType::mapped_type >::value)) ||
3805  (has_from_json<BasicJsonType,
3806  typename ConstructibleObjectType::mapped_type>::value ||
3807  has_non_default_from_json <
3808  BasicJsonType,
3809  typename ConstructibleObjectType::mapped_type >::value);
3810  };
3811 
3812  template<typename BasicJsonType, typename ConstructibleObjectType>
3813  struct is_constructible_object_type
3814  : is_constructible_object_type_impl<BasicJsonType,
3815  ConstructibleObjectType> {};
3816 
3817  template<typename BasicJsonType, typename CompatibleStringType>
3818  struct is_compatible_string_type
3819  {
3820  static constexpr auto value =
3821  is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3822  };
3823 
3824  template<typename BasicJsonType, typename ConstructibleStringType>
3825  struct is_constructible_string_type
3826  {
3827  // launder type through decltype() to fix compilation failure on ICPC
3828 #ifdef __INTEL_COMPILER
3829  using laundered_type = decltype(std::declval<ConstructibleStringType>());
3830 #else
3831  using laundered_type = ConstructibleStringType;
3832 #endif
3833 
3834  static constexpr auto value =
3835  conjunction <
3836  is_constructible<laundered_type, typename BasicJsonType::string_t>,
3837  is_detected_exact<typename BasicJsonType::string_t::value_type,
3838  value_type_t, laundered_type >>::value;
3839  };
3840 
3841  template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3842  struct is_compatible_array_type_impl : std::false_type {};
3843 
3844  template<typename BasicJsonType, typename CompatibleArrayType>
3845  struct is_compatible_array_type_impl <
3846  BasicJsonType, CompatibleArrayType,
3847  enable_if_t <
3848  is_detected<iterator_t, CompatibleArrayType>::value&&
3849  is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value &&
3850  // special case for types like std::filesystem::path whose iterator's value_type are themselves
3851  // c.f. https://github.com/nlohmann/json/pull/3073
3852  !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3853  {
3854  static constexpr bool value =
3855  is_constructible<BasicJsonType,
3856  range_value_t<CompatibleArrayType>>::value;
3857  };
3858 
3859  template<typename BasicJsonType, typename CompatibleArrayType>
3860  struct is_compatible_array_type
3861  : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3862 
3863  template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3864  struct is_constructible_array_type_impl : std::false_type {};
3865 
3866  template<typename BasicJsonType, typename ConstructibleArrayType>
3867  struct is_constructible_array_type_impl <
3868  BasicJsonType, ConstructibleArrayType,
3869  enable_if_t<std::is_same<ConstructibleArrayType,
3870  typename BasicJsonType::value_type>::value >>
3871  : std::true_type {};
3872 
3873  template<typename BasicJsonType, typename ConstructibleArrayType>
3874  struct is_constructible_array_type_impl <
3875  BasicJsonType, ConstructibleArrayType,
3876  enable_if_t < !std::is_same<ConstructibleArrayType,
3877  typename BasicJsonType::value_type>::value &&
3878  !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3879  is_default_constructible<ConstructibleArrayType>::value &&
3880  (std::is_move_assignable<ConstructibleArrayType>::value ||
3881  std::is_copy_assignable<ConstructibleArrayType>::value) &&
3882  is_detected<iterator_t, ConstructibleArrayType>::value&&
3883  is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
3884  is_detected<range_value_t, ConstructibleArrayType>::value &&
3885  // special case for types like std::filesystem::path whose iterator's value_type are themselves
3886  // c.f. https://github.com/nlohmann/json/pull/3073
3887  !std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
3888  is_complete_type <
3889  detected_t<range_value_t, ConstructibleArrayType >>::value >>
3890  {
3891  using value_type = range_value_t<ConstructibleArrayType>;
3892 
3893  static constexpr bool value =
3894  std::is_same<value_type,
3895  typename BasicJsonType::array_t::value_type>::value ||
3896  has_from_json<BasicJsonType,
3897  value_type>::value ||
3898  has_non_default_from_json <
3899  BasicJsonType,
3900  value_type >::value;
3901  };
3902 
3903  template<typename BasicJsonType, typename ConstructibleArrayType>
3904  struct is_constructible_array_type
3905  : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3906 
3907  template<typename RealIntegerType, typename CompatibleNumberIntegerType,
3908  typename = void>
3909  struct is_compatible_integer_type_impl : std::false_type {};
3910 
3911  template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3912  struct is_compatible_integer_type_impl <
3913  RealIntegerType, CompatibleNumberIntegerType,
3914  enable_if_t < std::is_integral<RealIntegerType>::value&&
3915  std::is_integral<CompatibleNumberIntegerType>::value &&
3916  !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3917  {
3918  // is there an assert somewhere on overflows?
3919  using RealLimits = std::numeric_limits<RealIntegerType>;
3920  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3921 
3922  static constexpr auto value =
3923  is_constructible<RealIntegerType,
3924  CompatibleNumberIntegerType>::value&&
3925  CompatibleLimits::is_integer&&
3926  RealLimits::is_signed == CompatibleLimits::is_signed;
3927  };
3928 
3929  template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3930  struct is_compatible_integer_type
3931  : is_compatible_integer_type_impl<RealIntegerType,
3932  CompatibleNumberIntegerType> {};
3933 
3934  template<typename BasicJsonType, typename CompatibleType, typename = void>
3935  struct is_compatible_type_impl : std::false_type {};
3936 
3937  template<typename BasicJsonType, typename CompatibleType>
3938  struct is_compatible_type_impl <
3939  BasicJsonType, CompatibleType,
3940  enable_if_t<is_complete_type<CompatibleType>::value >>
3941  {
3942  static constexpr bool value =
3943  has_to_json<BasicJsonType, CompatibleType>::value;
3944  };
3945 
3946  template<typename BasicJsonType, typename CompatibleType>
3947  struct is_compatible_type
3948  : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3949 
3950  template<typename T1, typename T2>
3951  struct is_constructible_tuple : std::false_type {};
3952 
3953  template<typename T1, typename... Args>
3954  struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3955 
3956  template<typename BasicJsonType, typename T>
3957  struct is_json_iterator_of : std::false_type {};
3958 
3959  template<typename BasicJsonType>
3960  struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
3961 
3962  template<typename BasicJsonType>
3963  struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
3964  {};
3965 
3966  // checks if a given type T is a template specialization of Primary
3967  template<template <typename...> class Primary, typename T>
3968  struct is_specialization_of : std::false_type {};
3969 
3970  template<template <typename...> class Primary, typename... Args>
3971  struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
3972 
3973  template<typename T>
3974  using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
3975 
3976  // checks if A and B are comparable using Compare functor
3977  template<typename Compare, typename A, typename B, typename = void>
3978  struct is_comparable : std::false_type {};
3979 
3980  template<typename Compare, typename A, typename B>
3981  struct is_comparable<Compare, A, B, void_t<
3982  decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
3983  decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
3984  >> : std::true_type {};
3985 
3986  template<typename T>
3987  using detect_is_transparent = typename T::is_transparent;
3988 
3989  // type trait to check if KeyType can be used as object key (without a BasicJsonType)
3990  // see is_usable_as_basic_json_key_type below
3991  template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
3992  bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
3993  using is_usable_as_key_type = typename std::conditional <
3994  is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
3995  && !(ExcludeObjectKeyType&& std::is_same<KeyType,
3996  ObjectKeyType>::value)
3997  && (!RequireTransparentComparator
3998  || is_detected <detect_is_transparent, Comparator>::value)
3999  && !is_json_pointer<KeyType>::value,
4000  std::true_type,
4001  std::false_type >::type;
4002 
4003  // type trait to check if KeyType can be used as object key
4004  // true if:
4005  // - KeyType is comparable with BasicJsonType::object_t::key_type
4006  // - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
4007  // - the comparator is transparent or RequireTransparentComparator is false
4008  // - KeyType is not a JSON iterator or json_pointer
4009  template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
4010  bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
4011  using is_usable_as_basic_json_key_type = typename std::conditional <
4012  is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
4013  typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
4014  RequireTransparentComparator, ExcludeObjectKeyType>::value
4015  && !is_json_iterator_of<BasicJsonType, KeyType>::value,
4016  std::true_type,
4017  std::false_type >::type;
4018 
4019  template<typename ObjectType, typename KeyType>
4020  using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
4021 
4022  // type trait to check if object_t has an erase() member functions accepting KeyType
4023  template<typename BasicJsonType, typename KeyType>
4024  using has_erase_with_key_type = typename std::conditional <
4025  is_detected <
4026  detect_erase_with_key_type,
4027  typename BasicJsonType::object_t, KeyType >::value,
4028  std::true_type,
4029  std::false_type >::type;
4030 
4031  // a naive helper to check if a type is an ordered_map (exploits the fact that
4032  // ordered_map inherits capacity() from std::vector)
4033  template <typename T>
4034  struct is_ordered_map
4035  {
4036  using one = char;
4037 
4038  struct two
4039  {
4040  char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4041  };
4042 
4043  template <typename C> static one test(decltype(&C::capacity));
4044  template <typename C> static two test(...);
4045 
4046  enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
4047  };
4048 
4049  // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
4050  template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
4051  T conditional_static_cast(U value)
4052  {
4053  return static_cast<T>(value);
4054  }
4055 
4056  template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
4057  T conditional_static_cast(U value)
4058  {
4059  return value;
4060  }
4061 
4062  template<typename... Types>
4063  using all_integral = conjunction<std::is_integral<Types>...>;
4064 
4065  template<typename... Types>
4066  using all_signed = conjunction<std::is_signed<Types>...>;
4067 
4068  template<typename... Types>
4069  using all_unsigned = conjunction<std::is_unsigned<Types>...>;
4070 
4071  // there's a disjunction trait in another PR; replace when merged
4072  template<typename... Types>
4073  using same_sign = std::integral_constant < bool,
4074  all_signed<Types...>::value || all_unsigned<Types...>::value >;
4075 
4076  template<typename OfType, typename T>
4077  using never_out_of_range = std::integral_constant < bool,
4078  (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
4079  || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
4080 
4081  template<typename OfType, typename T,
4082  bool OfTypeSigned = std::is_signed<OfType>::value,
4083  bool TSigned = std::is_signed<T>::value>
4084  struct value_in_range_of_impl2;
4085 
4086  template<typename OfType, typename T>
4087  struct value_in_range_of_impl2<OfType, T, false, false>
4088  {
4089  static constexpr bool test(T val)
4090  {
4091  using CommonType = typename std::common_type<OfType, T>::type;
4092  return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4093  }
4094  };
4095 
4096  template<typename OfType, typename T>
4097  struct value_in_range_of_impl2<OfType, T, true, false>
4098  {
4099  static constexpr bool test(T val)
4100  {
4101  using CommonType = typename std::common_type<OfType, T>::type;
4102  return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4103  }
4104  };
4105 
4106  template<typename OfType, typename T>
4107  struct value_in_range_of_impl2<OfType, T, false, true>
4108  {
4109  static constexpr bool test(T val)
4110  {
4111  using CommonType = typename std::common_type<OfType, T>::type;
4112  return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4113  }
4114  };
4115 
4116  template<typename OfType, typename T>
4117  struct value_in_range_of_impl2<OfType, T, true, true>
4118  {
4119  static constexpr bool test(T val)
4120  {
4121  using CommonType = typename std::common_type<OfType, T>::type;
4122  return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
4123  && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4124  }
4125  };
4126 
4127  template<typename OfType, typename T,
4128  bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
4129  typename = detail::enable_if_t<all_integral<OfType, T>::value>>
4130  struct value_in_range_of_impl1;
4131 
4132  template<typename OfType, typename T>
4133  struct value_in_range_of_impl1<OfType, T, false>
4134  {
4135  static constexpr bool test(T val)
4136  {
4137  return value_in_range_of_impl2<OfType, T>::test(val);
4138  }
4139  };
4140 
4141  template<typename OfType, typename T>
4142  struct value_in_range_of_impl1<OfType, T, true>
4143  {
4144  static constexpr bool test(T /*val*/)
4145  {
4146  return true;
4147  }
4148  };
4149 
4150  template<typename OfType, typename T>
4151  inline constexpr bool value_in_range_of(T val)
4152  {
4153  return value_in_range_of_impl1<OfType, T>::test(val);
4154  }
4155 
4156  template<bool Value>
4157  using bool_constant = std::integral_constant<bool, Value>;
4158 
4160  // is_c_string
4162 
4163  namespace impl
4164  {
4165 
4166  template<typename T>
4167  inline constexpr bool is_c_string()
4168  {
4169  using TUnExt = typename std::remove_extent<T>::type;
4170  using TUnCVExt = typename std::remove_cv<TUnExt>::type;
4171  using TUnPtr = typename std::remove_pointer<T>::type;
4172  using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
4173  return
4174  (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
4175  || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
4176  }
4177 
4178  } // namespace impl
4179 
4180  // checks whether T is a [cv] char */[cv] char[] C string
4181  template<typename T>
4182  struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
4183 
4184  template<typename T>
4185  using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
4186 
4188  // is_transparent
4190 
4191  namespace impl
4192  {
4193 
4194  template<typename T>
4195  inline constexpr bool is_transparent()
4196  {
4197  return is_detected<detect_is_transparent, T>::value;
4198  }
4199 
4200  } // namespace impl
4201 
4202  // checks whether T has a member named is_transparent
4203  template<typename T>
4204  struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
4205 
4207 
4208 } // namespace detail
4209 NLOHMANN_JSON_NAMESPACE_END
4210 
4211 // #include <nlohmann/detail/string_concat.hpp>
4212 // __ _____ _____ _____
4213 // __| | __| | | | JSON for Modern C++
4214 // | | |__ | | | | | | version 3.11.3
4215 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
4216 //
4217 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
4218 // SPDX-License-Identifier: MIT
4219 
4220 
4221 
4222 #include <cstring> // strlen
4223 #include <string> // string
4224 #include <utility> // forward
4225 
4226 // #include <nlohmann/detail/meta/cpp_future.hpp>
4227 
4228 // #include <nlohmann/detail/meta/detected.hpp>
4229 
4230 
4231 NLOHMANN_JSON_NAMESPACE_BEGIN
4232 namespace detail
4233 {
4234 
4235  inline std::size_t concat_length()
4236  {
4237  return 0;
4238  }
4239 
4240  template<typename... Args>
4241  inline std::size_t concat_length(const char* cstr, const Args& ... rest);
4242 
4243  template<typename StringType, typename... Args>
4244  inline std::size_t concat_length(const StringType& str, const Args& ... rest);
4245 
4246  template<typename... Args>
4247  inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
4248  {
4249  return 1 + concat_length(rest...);
4250  }
4251 
4252  template<typename... Args>
4253  inline std::size_t concat_length(const char* cstr, const Args& ... rest)
4254  {
4255  // cppcheck-suppress ignoredReturnValue
4256  return ::strlen(cstr) + concat_length(rest...);
4257  }
4258 
4259  template<typename StringType, typename... Args>
4260  inline std::size_t concat_length(const StringType& str, const Args& ... rest)
4261  {
4262  return str.size() + concat_length(rest...);
4263  }
4264 
4265  template<typename OutStringType>
4266  inline void concat_into(OutStringType& /*out*/)
4267  {}
4268 
4269  template<typename StringType, typename Arg>
4270  using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg&& >()));
4271 
4272  template<typename StringType, typename Arg>
4273  using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
4274 
4275  template<typename StringType, typename Arg>
4276  using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg&& >());
4277 
4278  template<typename StringType, typename Arg>
4279  using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
4280 
4281  template<typename StringType, typename Arg>
4282  using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
4283 
4284  template<typename StringType, typename Arg>
4285  using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
4286 
4287  template<typename StringType, typename Arg>
4288  using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
4289 
4290  template<typename StringType, typename Arg>
4291  using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
4292 
4293  template < typename OutStringType, typename Arg, typename... Args,
4294  enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4295  && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
4296  inline void concat_into(OutStringType& out, Arg&& arg, Args && ... rest);
4297 
4298  template < typename OutStringType, typename Arg, typename... Args,
4299  enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4300  && !detect_string_can_append_op<OutStringType, Arg>::value
4301  && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
4302  inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4303 
4304  template < typename OutStringType, typename Arg, typename... Args,
4305  enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4306  && !detect_string_can_append_op<OutStringType, Arg>::value
4307  && !detect_string_can_append_iter<OutStringType, Arg>::value
4308  && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
4309  inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4310 
4311  template<typename OutStringType, typename Arg, typename... Args,
4312  enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
4313  inline void concat_into(OutStringType& out, Arg&& arg, Args && ... rest)
4314  {
4315  out.append(std::forward<Arg>(arg));
4316  concat_into(out, std::forward<Args>(rest)...);
4317  }
4318 
4319  template < typename OutStringType, typename Arg, typename... Args,
4320  enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4321  && detect_string_can_append_op<OutStringType, Arg>::value, int > >
4322  inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
4323  {
4324  out += std::forward<Arg>(arg);
4325  concat_into(out, std::forward<Args>(rest)...);
4326  }
4327 
4328  template < typename OutStringType, typename Arg, typename... Args,
4329  enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4330  && !detect_string_can_append_op<OutStringType, Arg>::value
4331  && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
4332  inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4333  {
4334  out.append(arg.begin(), arg.end());
4335  concat_into(out, std::forward<Args>(rest)...);
4336  }
4337 
4338  template < typename OutStringType, typename Arg, typename... Args,
4339  enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4340  && !detect_string_can_append_op<OutStringType, Arg>::value
4341  && !detect_string_can_append_iter<OutStringType, Arg>::value
4342  && detect_string_can_append_data<OutStringType, Arg>::value, int > >
4343  inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4344  {
4345  out.append(arg.data(), arg.size());
4346  concat_into(out, std::forward<Args>(rest)...);
4347  }
4348 
4349  template<typename OutStringType = std::string, typename... Args>
4350  inline OutStringType concat(Args && ... args)
4351  {
4352  OutStringType str;
4353  str.reserve(concat_length(args...));
4354  concat_into(str, std::forward<Args>(args)...);
4355  return str;
4356  }
4357 
4358 } // namespace detail
4359 NLOHMANN_JSON_NAMESPACE_END
4360 
4361 
4362 NLOHMANN_JSON_NAMESPACE_BEGIN
4363 namespace detail
4364 {
4365 
4367  // exceptions //
4369 
4372  class exception : public std::exception
4373  {
4374  public:
4376  const char* what() const noexcept override
4377  {
4378  return m.what();
4379  }
4380 
4382  const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
4383 
4384  protected:
4385  JSON_HEDLEY_NON_NULL(3)
4386  exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
4387 
4388  static std::string name(const std::string& ename, int id_)
4389  {
4390  return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
4391  }
4392 
4393  static std::string diagnostics(std::nullptr_t /*leaf_element*/)
4394  {
4395  return "";
4396  }
4397 
4398  template<typename BasicJsonType>
4399  static std::string diagnostics(const BasicJsonType* leaf_element)
4400  {
4401 #if JSON_DIAGNOSTICS
4402  std::vector<std::string> tokens;
4403  for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
4404  {
4405  switch (current->m_parent->type())
4406  {
4407  case value_t::array:
4408  {
4409  for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
4410  {
4411  if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
4412  {
4413  tokens.emplace_back(std::to_string(i));
4414  break;
4415  }
4416  }
4417  break;
4418  }
4419 
4420  case value_t::object:
4421  {
4422  for (const auto& element : *current->m_parent->m_data.m_value.object)
4423  {
4424  if (&element.second == current)
4425  {
4426  tokens.emplace_back(element.first.c_str());
4427  break;
4428  }
4429  }
4430  break;
4431  }
4432 
4433  case value_t::null: // LCOV_EXCL_LINE
4434  case value_t::string: // LCOV_EXCL_LINE
4435  case value_t::boolean: // LCOV_EXCL_LINE
4436  case value_t::number_integer: // LCOV_EXCL_LINE
4437  case value_t::number_unsigned: // LCOV_EXCL_LINE
4438  case value_t::number_float: // LCOV_EXCL_LINE
4439  case value_t::binary: // LCOV_EXCL_LINE
4440  case value_t::discarded: // LCOV_EXCL_LINE
4441  default: // LCOV_EXCL_LINE
4442  break; // LCOV_EXCL_LINE
4443  }
4444  }
4445 
4446  if (tokens.empty())
4447  {
4448  return "";
4449  }
4450 
4451  auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
4452  [](const std::string& a, const std::string& b)
4453  {
4454  return concat(a, '/', detail::escape(b));
4455  });
4456  return concat('(', str, ") ");
4457 #else
4458  static_cast<void>(leaf_element);
4459  return "";
4460 #endif
4461  }
4462 
4463  private:
4465  std::runtime_error m;
4466  };
4467 
4470  class parse_error : public exception
4471  {
4472  public:
4482  template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4483  static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
4484  {
4485  const std::string w = concat(exception::name("parse_error", id_), "parse error",
4486  position_string(pos), ": ", exception::diagnostics(context), what_arg);
4487  return { id_, pos.chars_read_total, w.c_str() };
4488  }
4489 
4490  template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4491  static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
4492  {
4493  const std::string w = concat(exception::name("parse_error", id_), "parse error",
4494  (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
4495  ": ", exception::diagnostics(context), what_arg);
4496  return { id_, byte_, w.c_str() };
4497  }
4498 
4508  const std::size_t byte;
4509 
4510  private:
4511  parse_error(int id_, std::size_t byte_, const char* what_arg)
4512  : exception(id_, what_arg), byte(byte_) {}
4513 
4514  static std::string position_string(const position_t& pos)
4515  {
4516  return concat(" at line ", std::to_string(pos.lines_read + 1),
4517  ", column ", std::to_string(pos.chars_read_current_line));
4518  }
4519  };
4520 
4523  class invalid_iterator : public exception
4524  {
4525  public:
4526  template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4527  static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
4528  {
4529  const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
4530  return { id_, w.c_str() };
4531  }
4532 
4533  private:
4534  JSON_HEDLEY_NON_NULL(3)
4535  invalid_iterator(int id_, const char* what_arg)
4536  : exception(id_, what_arg) {}
4537  };
4538 
4541  class type_error : public exception
4542  {
4543  public:
4544  template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4545  static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4546  {
4547  const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
4548  return { id_, w.c_str() };
4549  }
4550 
4551  private:
4552  JSON_HEDLEY_NON_NULL(3)
4553  type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
4554  };
4555 
4558  class out_of_range : public exception
4559  {
4560  public:
4561  template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4562  static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
4563  {
4564  const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
4565  return { id_, w.c_str() };
4566  }
4567 
4568  private:
4569  JSON_HEDLEY_NON_NULL(3)
4570  out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
4571  };
4572 
4575  class other_error : public exception
4576  {
4577  public:
4578  template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4579  static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4580  {
4581  const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
4582  return { id_, w.c_str() };
4583  }
4584 
4585  private:
4586  JSON_HEDLEY_NON_NULL(3)
4587  other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
4588  };
4589 
4590 } // namespace detail
4591 NLOHMANN_JSON_NAMESPACE_END
4592 
4593 // #include <nlohmann/detail/macro_scope.hpp>
4594 
4595 // #include <nlohmann/detail/meta/cpp_future.hpp>
4596 
4597 // #include <nlohmann/detail/meta/identity_tag.hpp>
4598 // __ _____ _____ _____
4599 // __| | __| | | | JSON for Modern C++
4600 // | | |__ | | | | | | version 3.11.3
4601 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
4602 //
4603 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
4604 // SPDX-License-Identifier: MIT
4605 
4606 
4607 
4608 // #include <nlohmann/detail/abi_macros.hpp>
4609 
4610 
4611 NLOHMANN_JSON_NAMESPACE_BEGIN
4612 namespace detail
4613 {
4614 
4615  // dispatching helper struct
4616  template <class T> struct identity_tag {};
4617 
4618 } // namespace detail
4619 NLOHMANN_JSON_NAMESPACE_END
4620 
4621 // #include <nlohmann/detail/meta/std_fs.hpp>
4622 // __ _____ _____ _____
4623 // __| | __| | | | JSON for Modern C++
4624 // | | |__ | | | | | | version 3.11.3
4625 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
4626 //
4627 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
4628 // SPDX-License-Identifier: MIT
4629 
4630 
4631 
4632 // #include <nlohmann/detail/macro_scope.hpp>
4633 
4634 
4635 #if JSON_HAS_EXPERIMENTAL_FILESYSTEM
4636 #include <experimental/filesystem>
4637 NLOHMANN_JSON_NAMESPACE_BEGIN
4638 namespace detail
4639 {
4640  namespace std_fs = std::experimental::filesystem;
4641 } // namespace detail
4642 NLOHMANN_JSON_NAMESPACE_END
4643 #elif JSON_HAS_FILESYSTEM
4644 #include <filesystem>
4645 NLOHMANN_JSON_NAMESPACE_BEGIN
4646 namespace detail
4647 {
4648  namespace std_fs = std::filesystem;
4649 } // namespace detail
4650 NLOHMANN_JSON_NAMESPACE_END
4651 #endif
4652 
4653 // #include <nlohmann/detail/meta/type_traits.hpp>
4654 
4655 // #include <nlohmann/detail/string_concat.hpp>
4656 
4657 // #include <nlohmann/detail/value_t.hpp>
4658 
4659 
4660 NLOHMANN_JSON_NAMESPACE_BEGIN
4661 namespace detail
4662 {
4663 
4664  template<typename BasicJsonType>
4665  inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
4666  {
4667  if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
4668  {
4669  JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
4670  }
4671  n = nullptr;
4672  }
4673 
4674  // overloads for basic_json template parameters
4675  template < typename BasicJsonType, typename ArithmeticType,
4676  enable_if_t < std::is_arithmetic<ArithmeticType>::value &&
4677  !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4678  int > = 0 >
4679  void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
4680  {
4681  switch (static_cast<value_t>(j))
4682  {
4683  case value_t::number_unsigned:
4684  {
4685  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4686  break;
4687  }
4688  case value_t::number_integer:
4689  {
4690  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4691  break;
4692  }
4693  case value_t::number_float:
4694  {
4695  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4696  break;
4697  }
4698 
4699  case value_t::null:
4700  case value_t::object:
4701  case value_t::array:
4702  case value_t::string:
4703  case value_t::boolean:
4704  case value_t::binary:
4705  case value_t::discarded:
4706  default:
4707  JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
4708  }
4709  }
4710 
4711  template<typename BasicJsonType>
4712  inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
4713  {
4714  if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
4715  {
4716  JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
4717  }
4718  b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
4719  }
4720 
4721  template<typename BasicJsonType>
4722  inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
4723  {
4724  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4725  {
4726  JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
4727  }
4728  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4729  }
4730 
4731  template <
4732  typename BasicJsonType, typename StringType,
4733  enable_if_t <
4734  std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
4735  && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
4736  && !std::is_same<typename BasicJsonType::string_t, StringType>::value
4737  && !is_json_ref<StringType>::value, int > = 0 >
4738  inline void from_json(const BasicJsonType& j, StringType& s)
4739  {
4740  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4741  {
4742  JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
4743  }
4744 
4745  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4746  }
4747 
4748  template<typename BasicJsonType>
4749  inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
4750  {
4751  get_arithmetic_value(j, val);
4752  }
4753 
4754  template<typename BasicJsonType>
4755  inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
4756  {
4757  get_arithmetic_value(j, val);
4758  }
4759 
4760  template<typename BasicJsonType>
4761  inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
4762  {
4763  get_arithmetic_value(j, val);
4764  }
4765 
4766 #if !JSON_DISABLE_ENUM_SERIALIZATION
4767  template<typename BasicJsonType, typename EnumType,
4768  enable_if_t<std::is_enum<EnumType>::value, int> = 0>
4769  inline void from_json(const BasicJsonType& j, EnumType& e)
4770  {
4771  typename std::underlying_type<EnumType>::type val;
4772  get_arithmetic_value(j, val);
4773  e = static_cast<EnumType>(val);
4774  }
4775 #endif // JSON_DISABLE_ENUM_SERIALIZATION
4776 
4777  // forward_list doesn't have an insert method
4778  template<typename BasicJsonType, typename T, typename Allocator,
4779  enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
4780  inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
4781  {
4782  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4783  {
4784  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
4785  }
4786  l.clear();
4787  std::transform(j.rbegin(), j.rend(),
4788  std::front_inserter(l), [](const BasicJsonType& i)
4789  {
4790  return i.template get<T>();
4791  });
4792  }
4793 
4794  // valarray doesn't have an insert method
4795  template<typename BasicJsonType, typename T,
4796  enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
4797  inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
4798  {
4799  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4800  {
4801  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
4802  }
4803  l.resize(j.size());
4804  std::transform(j.begin(), j.end(), std::begin(l),
4805  [](const BasicJsonType& elem)
4806  {
4807  return elem.template get<T>();
4808  });
4809  }
4810 
4811  template<typename BasicJsonType, typename T, std::size_t N>
4812  auto from_json(const BasicJsonType& j, T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4813  -> decltype(j.template get<T>(), void())
4814  {
4815  for (std::size_t i = 0; i < N; ++i)
4816  {
4817  arr[i] = j.at(i).template get<T>();
4818  }
4819  }
4820 
4821  template<typename BasicJsonType>
4822  inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
4823  {
4824  arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
4825  }
4826 
4827  template<typename BasicJsonType, typename T, std::size_t N>
4828  auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
4829  priority_tag<2> /*unused*/)
4830  -> decltype(j.template get<T>(), void())
4831  {
4832  for (std::size_t i = 0; i < N; ++i)
4833  {
4834  arr[i] = j.at(i).template get<T>();
4835  }
4836  }
4837 
4838  template<typename BasicJsonType, typename ConstructibleArrayType,
4839  enable_if_t<
4840  std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4841  int> = 0>
4842  auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
4843  -> decltype(
4844  arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4845  j.template get<typename ConstructibleArrayType::value_type>(),
4846  void())
4847  {
4848  using std::end;
4849 
4850  ConstructibleArrayType ret;
4851  ret.reserve(j.size());
4852  std::transform(j.begin(), j.end(),
4853  std::inserter(ret, end(ret)), [](const BasicJsonType& i)
4854  {
4855  // get<BasicJsonType>() returns *this, this won't call a from_json
4856  // method when value_type is BasicJsonType
4857  return i.template get<typename ConstructibleArrayType::value_type>();
4858  });
4859  arr = std::move(ret);
4860  }
4861 
4862  template<typename BasicJsonType, typename ConstructibleArrayType,
4863  enable_if_t<
4864  std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4865  int> = 0>
4866  inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
4867  priority_tag<0> /*unused*/)
4868  {
4869  using std::end;
4870 
4871  ConstructibleArrayType ret;
4872  std::transform(
4873  j.begin(), j.end(), std::inserter(ret, end(ret)),
4874  [](const BasicJsonType& i)
4875  {
4876  // get<BasicJsonType>() returns *this, this won't call a from_json
4877  // method when value_type is BasicJsonType
4878  return i.template get<typename ConstructibleArrayType::value_type>();
4879  });
4880  arr = std::move(ret);
4881  }
4882 
4883  template < typename BasicJsonType, typename ConstructibleArrayType,
4884  enable_if_t <
4885  is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value &&
4886  !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value &&
4887  !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value &&
4888  !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value &&
4889  !is_basic_json<ConstructibleArrayType>::value,
4890  int > = 0 >
4891  auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
4892  -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
4893  j.template get<typename ConstructibleArrayType::value_type>(),
4894  void())
4895  {
4896  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4897  {
4898  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
4899  }
4900 
4901  from_json_array_impl(j, arr, priority_tag<3> {});
4902  }
4903 
4904  template < typename BasicJsonType, typename T, std::size_t... Idx >
4905  std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4906  identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
4907  {
4908  return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4909  }
4910 
4911  template < typename BasicJsonType, typename T, std::size_t N >
4912  auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4913  -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4914  {
4915  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4916  {
4917  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
4918  }
4919 
4920  return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4921  }
4922 
4923  template<typename BasicJsonType>
4924  inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
4925  {
4926  if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
4927  {
4928  JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
4929  }
4930 
4931  bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4932  }
4933 
4934  template<typename BasicJsonType, typename ConstructibleObjectType,
4935  enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
4936  inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
4937  {
4938  if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
4939  {
4940  JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
4941  }
4942 
4943  ConstructibleObjectType ret;
4944  const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4945  using value_type = typename ConstructibleObjectType::value_type;
4946  std::transform(
4947  inner_object->begin(), inner_object->end(),
4948  std::inserter(ret, ret.begin()),
4949  [](typename BasicJsonType::object_t::value_type const& p)
4950  {
4951  return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4952  });
4953  obj = std::move(ret);
4954  }
4955 
4956  // overload for arithmetic types, not chosen for basic_json template arguments
4957  // (BooleanType, etc..); note: Is it really necessary to provide explicit
4958  // overloads for boolean_t etc. in case of a custom BooleanType which is not
4959  // an arithmetic type?
4960  template < typename BasicJsonType, typename ArithmeticType,
4961  enable_if_t <
4962  std::is_arithmetic<ArithmeticType>::value &&
4963  !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value &&
4964  !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value &&
4965  !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value &&
4966  !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4967  int > = 0 >
4968  inline void from_json(const BasicJsonType& j, ArithmeticType& val)
4969  {
4970  switch (static_cast<value_t>(j))
4971  {
4972  case value_t::number_unsigned:
4973  {
4974  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4975  break;
4976  }
4977  case value_t::number_integer:
4978  {
4979  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4980  break;
4981  }
4982  case value_t::number_float:
4983  {
4984  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4985  break;
4986  }
4987  case value_t::boolean:
4988  {
4989  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4990  break;
4991  }
4992 
4993  case value_t::null:
4994  case value_t::object:
4995  case value_t::array:
4996  case value_t::string:
4997  case value_t::binary:
4998  case value_t::discarded:
4999  default:
5000  JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
5001  }
5002  }
5003 
5004  template<typename BasicJsonType, typename... Args, std::size_t... Idx>
5005  std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
5006  {
5007  return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
5008  }
5009 
5010  template < typename BasicJsonType, class A1, class A2 >
5011  std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
5012  {
5013  return { std::forward<BasicJsonType>(j).at(0).template get<A1>(),
5014  std::forward<BasicJsonType>(j).at(1).template get<A2>() };
5015  }
5016 
5017  template<typename BasicJsonType, typename A1, typename A2>
5018  inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
5019  {
5020  p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
5021  }
5022 
5023  template<typename BasicJsonType, typename... Args>
5024  std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
5025  {
5026  return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
5027  }
5028 
5029  template<typename BasicJsonType, typename... Args>
5030  inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
5031  {
5032  t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
5033  }
5034 
5035  template<typename BasicJsonType, typename TupleRelated>
5036  auto from_json(BasicJsonType&& j, TupleRelated&& t)
5037  -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
5038  {
5039  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5040  {
5041  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5042  }
5043 
5044  return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
5045  }
5046 
5047  template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
5048  typename = enable_if_t < !std::is_constructible <
5049  typename BasicJsonType::string_t, Key >::value >>
5050  inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
5051  {
5052  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5053  {
5054  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5055  }
5056  m.clear();
5057  for (const auto& p : j)
5058  {
5059  if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
5060  {
5061  JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
5062  }
5063  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
5064  }
5065  }
5066 
5067  template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
5068  typename = enable_if_t < !std::is_constructible <
5069  typename BasicJsonType::string_t, Key >::value >>
5070  inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
5071  {
5072  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5073  {
5074  JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5075  }
5076  m.clear();
5077  for (const auto& p : j)
5078  {
5079  if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
5080  {
5081  JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
5082  }
5083  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
5084  }
5085  }
5086 
5087 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
5088  template<typename BasicJsonType>
5089  inline void from_json(const BasicJsonType& j, std_fs::path& p)
5090  {
5091  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
5092  {
5093  JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
5094  }
5095  p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
5096  }
5097 #endif
5098 
5099  struct from_json_fn
5100  {
5101  template<typename BasicJsonType, typename T>
5102  auto operator()(const BasicJsonType& j, T&& val) const
5103  noexcept(noexcept(from_json(j, std::forward<T>(val))))
5104  -> decltype(from_json(j, std::forward<T>(val)))
5105  {
5106  return from_json(j, std::forward<T>(val));
5107  }
5108  };
5109 
5110 } // namespace detail
5111 
5112 #ifndef JSON_HAS_CPP_17
5116 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
5117 {
5118 #endif
5119  JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
5120  detail::static_const<detail::from_json_fn>::value;
5121 #ifndef JSON_HAS_CPP_17
5122 } // namespace
5123 #endif
5124 
5125 NLOHMANN_JSON_NAMESPACE_END
5126 
5127 // #include <nlohmann/detail/conversions/to_json.hpp>
5128 // __ _____ _____ _____
5129 // __| | __| | | | JSON for Modern C++
5130 // | | |__ | | | | | | version 3.11.3
5131 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
5132 //
5133 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
5134 // SPDX-License-Identifier: MIT
5135 
5136 
5137 
5138 #include <algorithm> // copy
5139 #include <iterator> // begin, end
5140 #include <string> // string
5141 #include <tuple> // tuple, get
5142 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
5143 #include <utility> // move, forward, declval, pair
5144 #include <valarray> // valarray
5145 #include <vector> // vector
5146 
5147 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
5148 // __ _____ _____ _____
5149 // __| | __| | | | JSON for Modern C++
5150 // | | |__ | | | | | | version 3.11.3
5151 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
5152 //
5153 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
5154 // SPDX-License-Identifier: MIT
5155 
5156 
5157 
5158 #include <cstddef> // size_t
5159 #include <iterator> // input_iterator_tag
5160 #include <string> // string, to_string
5161 #include <tuple> // tuple_size, get, tuple_element
5162 #include <utility> // move
5163 
5164 #if JSON_HAS_RANGES
5165 #include <ranges> // enable_borrowed_range
5166 #endif
5167 
5168 // #include <nlohmann/detail/abi_macros.hpp>
5169 
5170 // #include <nlohmann/detail/meta/type_traits.hpp>
5171 
5172 // #include <nlohmann/detail/value_t.hpp>
5173 
5174 
5175 NLOHMANN_JSON_NAMESPACE_BEGIN
5176 namespace detail
5177 {
5178 
5179  template<typename string_type>
5180  void int_to_string(string_type& target, std::size_t value)
5181  {
5182  // For ADL
5183  using std::to_string;
5184  target = to_string(value);
5185  }
5186  template<typename IteratorType> class iteration_proxy_value
5187  {
5188  public:
5189  using difference_type = std::ptrdiff_t;
5190  using value_type = iteration_proxy_value;
5191  using pointer = value_type*;
5192  using reference = value_type&;
5193  using iterator_category = std::input_iterator_tag;
5194  using string_type = typename std::remove_cv< typename std::remove_reference<decltype(std::declval<IteratorType>().key()) >::type >::type;
5195 
5196  private:
5198  IteratorType anchor{};
5200  std::size_t array_index = 0;
5202  mutable std::size_t array_index_last = 0;
5204  mutable string_type array_index_str = "0";
5206  string_type empty_str{};
5207 
5208  public:
5209  explicit iteration_proxy_value() = default;
5210  explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
5211  noexcept(std::is_nothrow_move_constructible<IteratorType>::value
5212  && std::is_nothrow_default_constructible<string_type>::value)
5213  : anchor(std::move(it))
5214  , array_index(array_index_)
5215  {}
5216 
5217  iteration_proxy_value(iteration_proxy_value const&) = default;
5218  iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
5219  // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
5220  iteration_proxy_value(iteration_proxy_value&&)
5221  noexcept(std::is_nothrow_move_constructible<IteratorType>::value
5222  && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
5223  iteration_proxy_value& operator=(iteration_proxy_value&&)
5224  noexcept(std::is_nothrow_move_assignable<IteratorType>::value
5225  && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
5226  ~iteration_proxy_value() = default;
5227 
5229  const iteration_proxy_value& operator*() const
5230  {
5231  return *this;
5232  }
5233 
5235  iteration_proxy_value& operator++()
5236  {
5237  ++anchor;
5238  ++array_index;
5239 
5240  return *this;
5241  }
5242 
5243  iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
5244  {
5245  auto tmp = iteration_proxy_value(anchor, array_index);
5246  ++anchor;
5247  ++array_index;
5248  return tmp;
5249  }
5250 
5252  bool operator==(const iteration_proxy_value& o) const
5253  {
5254  return anchor == o.anchor;
5255  }
5256 
5258  bool operator!=(const iteration_proxy_value& o) const
5259  {
5260  return anchor != o.anchor;
5261  }
5262 
5264  const string_type& key() const
5265  {
5266  JSON_ASSERT(anchor.m_object != nullptr);
5267 
5268  switch (anchor.m_object->type())
5269  {
5270  // use integer array index as key
5271  case value_t::array:
5272  {
5273  if (array_index != array_index_last)
5274  {
5275  int_to_string(array_index_str, array_index);
5276  array_index_last = array_index;
5277  }
5278  return array_index_str;
5279  }
5280 
5281  // use key from the object
5282  case value_t::object:
5283  return anchor.key();
5284 
5285  // use an empty key for all primitive types
5286  case value_t::null:
5287  case value_t::string:
5288  case value_t::boolean:
5289  case value_t::number_integer:
5290  case value_t::number_unsigned:
5291  case value_t::number_float:
5292  case value_t::binary:
5293  case value_t::discarded:
5294  default:
5295  return empty_str;
5296  }
5297  }
5298 
5300  typename IteratorType::reference value() const
5301  {
5302  return anchor.value();
5303  }
5304  };
5305 
5307  template<typename IteratorType> class iteration_proxy
5308  {
5309  private:
5311  typename IteratorType::pointer container = nullptr;
5312 
5313  public:
5314  explicit iteration_proxy() = default;
5315 
5317  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
5318  : container(&cont) {}
5319 
5320  iteration_proxy(iteration_proxy const&) = default;
5321  iteration_proxy& operator=(iteration_proxy const&) = default;
5322  iteration_proxy(iteration_proxy&&) noexcept = default;
5323  iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
5324  ~iteration_proxy() = default;
5325 
5327  iteration_proxy_value<IteratorType> begin() const noexcept
5328  {
5329  return iteration_proxy_value<IteratorType>(container->begin());
5330  }
5331 
5333  iteration_proxy_value<IteratorType> end() const noexcept
5334  {
5335  return iteration_proxy_value<IteratorType>(container->end());
5336  }
5337  };
5338 
5339  // Structured Bindings Support
5340  // For further reference see https://blog.tartanllama.xyz/structured-bindings/
5341  // And see https://github.com/nlohmann/json/pull/1391
5342  template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
5343  auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
5344  {
5345  return i.key();
5346  }
5347  // Structured Bindings Support
5348  // For further reference see https://blog.tartanllama.xyz/structured-bindings/
5349  // And see https://github.com/nlohmann/json/pull/1391
5350  template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
5351  auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
5352  {
5353  return i.value();
5354  }
5355 
5356 } // namespace detail
5357 NLOHMANN_JSON_NAMESPACE_END
5358 
5359 // The Addition to the STD Namespace is required to add
5360 // Structured Bindings Support to the iteration_proxy_value class
5361 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
5362 // And see https://github.com/nlohmann/json/pull/1391
5363 namespace std
5364 {
5365 
5366 #if defined(__clang__)
5367  // Fix: https://github.com/nlohmann/json/issues/1401
5368 #pragma clang diagnostic push
5369 #pragma clang diagnostic ignored "-Wmismatched-tags"
5370 #endif
5371  template<typename IteratorType>
5372  class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
5373  : public std::integral_constant<std::size_t, 2> {};
5374 
5375  template<std::size_t N, typename IteratorType>
5376  class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
5377  {
5378  public:
5379  using type = decltype(
5380  get<N>(std::declval <
5381  ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
5382  };
5383 #if defined(__clang__)
5384 #pragma clang diagnostic pop
5385 #endif
5386 
5387 } // namespace std
5388 
5389 #if JSON_HAS_RANGES
5390 template <typename IteratorType>
5391 inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
5392 #endif
5393 
5394 // #include <nlohmann/detail/macro_scope.hpp>
5395 
5396 // #include <nlohmann/detail/meta/cpp_future.hpp>
5397 
5398 // #include <nlohmann/detail/meta/std_fs.hpp>
5399 
5400 // #include <nlohmann/detail/meta/type_traits.hpp>
5401 
5402 // #include <nlohmann/detail/value_t.hpp>
5403 
5404 
5405 NLOHMANN_JSON_NAMESPACE_BEGIN
5406 namespace detail
5407 {
5408 
5410  // constructors //
5412 
5413  /*
5414  * Note all external_constructor<>::construct functions need to call
5415  * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
5416  * allocated value (e.g., a string). See bug issue
5417  * https://github.com/nlohmann/json/issues/2865 for more information.
5418  */
5419 
5420  template<value_t> struct external_constructor;
5421 
5422  template<>
5423  struct external_constructor<value_t::boolean>
5424  {
5425  template<typename BasicJsonType>
5426  static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
5427  {
5428  j.m_data.m_value.destroy(j.m_data.m_type);
5429  j.m_data.m_type = value_t::boolean;
5430  j.m_data.m_value = b;
5431  j.assert_invariant();
5432  }
5433  };
5434 
5435  template<>
5436  struct external_constructor<value_t::string>
5437  {
5438  template<typename BasicJsonType>
5439  static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
5440  {
5441  j.m_data.m_value.destroy(j.m_data.m_type);
5442  j.m_data.m_type = value_t::string;
5443  j.m_data.m_value = s;
5444  j.assert_invariant();
5445  }
5446 
5447  template<typename BasicJsonType>
5448  static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
5449  {
5450  j.m_data.m_value.destroy(j.m_data.m_type);
5451  j.m_data.m_type = value_t::string;
5452  j.m_data.m_value = std::move(s);
5453  j.assert_invariant();
5454  }
5455 
5456  template < typename BasicJsonType, typename CompatibleStringType,
5457  enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
5458  int > = 0 >
5459  static void construct(BasicJsonType& j, const CompatibleStringType& str)
5460  {
5461  j.m_data.m_value.destroy(j.m_data.m_type);
5462  j.m_data.m_type = value_t::string;
5463  j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
5464  j.assert_invariant();
5465  }
5466  };
5467 
5468  template<>
5469  struct external_constructor<value_t::binary>
5470  {
5471  template<typename BasicJsonType>
5472  static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
5473  {
5474  j.m_data.m_value.destroy(j.m_data.m_type);
5475  j.m_data.m_type = value_t::binary;
5476  j.m_data.m_value = typename BasicJsonType::binary_t(b);
5477  j.assert_invariant();
5478  }
5479 
5480  template<typename BasicJsonType>
5481  static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
5482  {
5483  j.m_data.m_value.destroy(j.m_data.m_type);
5484  j.m_data.m_type = value_t::binary;
5485  j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
5486  j.assert_invariant();
5487  }
5488  };
5489 
5490  template<>
5491  struct external_constructor<value_t::number_float>
5492  {
5493  template<typename BasicJsonType>
5494  static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
5495  {
5496  j.m_data.m_value.destroy(j.m_data.m_type);
5497  j.m_data.m_type = value_t::number_float;
5498  j.m_data.m_value = val;
5499  j.assert_invariant();
5500  }
5501  };
5502 
5503  template<>
5504  struct external_constructor<value_t::number_unsigned>
5505  {
5506  template<typename BasicJsonType>
5507  static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
5508  {
5509  j.m_data.m_value.destroy(j.m_data.m_type);
5510  j.m_data.m_type = value_t::number_unsigned;
5511  j.m_data.m_value = val;
5512  j.assert_invariant();
5513  }
5514  };
5515 
5516  template<>
5517  struct external_constructor<value_t::number_integer>
5518  {
5519  template<typename BasicJsonType>
5520  static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
5521  {
5522  j.m_data.m_value.destroy(j.m_data.m_type);
5523  j.m_data.m_type = value_t::number_integer;
5524  j.m_data.m_value = val;
5525  j.assert_invariant();
5526  }
5527  };
5528 
5529  template<>
5530  struct external_constructor<value_t::array>
5531  {
5532  template<typename BasicJsonType>
5533  static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
5534  {
5535  j.m_data.m_value.destroy(j.m_data.m_type);
5536  j.m_data.m_type = value_t::array;
5537  j.m_data.m_value = arr;
5538  j.set_parents();
5539  j.assert_invariant();
5540  }
5541 
5542  template<typename BasicJsonType>
5543  static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
5544  {
5545  j.m_data.m_value.destroy(j.m_data.m_type);
5546  j.m_data.m_type = value_t::array;
5547  j.m_data.m_value = std::move(arr);
5548  j.set_parents();
5549  j.assert_invariant();
5550  }
5551 
5552  template < typename BasicJsonType, typename CompatibleArrayType,
5553  enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
5554  int > = 0 >
5555  static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
5556  {
5557  using std::begin;
5558  using std::end;
5559 
5560  j.m_data.m_value.destroy(j.m_data.m_type);
5561  j.m_data.m_type = value_t::array;
5562  j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
5563  j.set_parents();
5564  j.assert_invariant();
5565  }
5566 
5567  template<typename BasicJsonType>
5568  static void construct(BasicJsonType& j, const std::vector<bool>& arr)
5569  {
5570  j.m_data.m_value.destroy(j.m_data.m_type);
5571  j.m_data.m_type = value_t::array;
5572  j.m_data.m_value = value_t::array;
5573  j.m_data.m_value.array->reserve(arr.size());
5574  for (const bool x : arr)
5575  {
5576  j.m_data.m_value.array->push_back(x);
5577  j.set_parent(j.m_data.m_value.array->back());
5578  }
5579  j.assert_invariant();
5580  }
5581 
5582  template<typename BasicJsonType, typename T,
5583  enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
5584  static void construct(BasicJsonType& j, const std::valarray<T>& arr)
5585  {
5586  j.m_data.m_value.destroy(j.m_data.m_type);
5587  j.m_data.m_type = value_t::array;
5588  j.m_data.m_value = value_t::array;
5589  j.m_data.m_value.array->resize(arr.size());
5590  if (arr.size() > 0)
5591  {
5592  std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
5593  }
5594  j.set_parents();
5595  j.assert_invariant();
5596  }
5597  };
5598 
5599  template<>
5600  struct external_constructor<value_t::object>
5601  {
5602  template<typename BasicJsonType>
5603  static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
5604  {
5605  j.m_data.m_value.destroy(j.m_data.m_type);
5606  j.m_data.m_type = value_t::object;
5607  j.m_data.m_value = obj;
5608  j.set_parents();
5609  j.assert_invariant();
5610  }
5611 
5612  template<typename BasicJsonType>
5613  static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
5614  {
5615  j.m_data.m_value.destroy(j.m_data.m_type);
5616  j.m_data.m_type = value_t::object;
5617  j.m_data.m_value = std::move(obj);
5618  j.set_parents();
5619  j.assert_invariant();
5620  }
5621 
5622  template < typename BasicJsonType, typename CompatibleObjectType,
5623  enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
5624  static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
5625  {
5626  using std::begin;
5627  using std::end;
5628 
5629  j.m_data.m_value.destroy(j.m_data.m_type);
5630  j.m_data.m_type = value_t::object;
5631  j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
5632  j.set_parents();
5633  j.assert_invariant();
5634  }
5635  };
5636 
5638  // to_json //
5640 
5641  template<typename BasicJsonType, typename T,
5642  enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
5643  inline void to_json(BasicJsonType& j, T b) noexcept
5644  {
5645  external_constructor<value_t::boolean>::construct(j, b);
5646  }
5647 
5648  template < typename BasicJsonType, typename BoolRef,
5649  enable_if_t <
5650  ((std::is_same<std::vector<bool>::reference, BoolRef>::value
5651  && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
5652  || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
5653  && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
5654  typename BasicJsonType::boolean_t >::value))
5655  && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
5656  inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
5657  {
5658  external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
5659  }
5660 
5661  template<typename BasicJsonType, typename CompatibleString,
5662  enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
5663  inline void to_json(BasicJsonType& j, const CompatibleString& s)
5664  {
5665  external_constructor<value_t::string>::construct(j, s);
5666  }
5667 
5668  template<typename BasicJsonType>
5669  inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
5670  {
5671  external_constructor<value_t::string>::construct(j, std::move(s));
5672  }
5673 
5674  template<typename BasicJsonType, typename FloatType,
5675  enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
5676  inline void to_json(BasicJsonType& j, FloatType val) noexcept
5677  {
5678  external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
5679  }
5680 
5681  template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
5682  enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
5683  inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
5684  {
5685  external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
5686  }
5687 
5688  template<typename BasicJsonType, typename CompatibleNumberIntegerType,
5689  enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
5690  inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
5691  {
5692  external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
5693  }
5694 
5695 #if !JSON_DISABLE_ENUM_SERIALIZATION
5696  template<typename BasicJsonType, typename EnumType,
5697  enable_if_t<std::is_enum<EnumType>::value, int> = 0>
5698  inline void to_json(BasicJsonType& j, EnumType e) noexcept
5699  {
5700  using underlying_type = typename std::underlying_type<EnumType>::type;
5701  external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
5702  }
5703 #endif // JSON_DISABLE_ENUM_SERIALIZATION
5704 
5705  template<typename BasicJsonType>
5706  inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
5707  {
5708  external_constructor<value_t::array>::construct(j, e);
5709  }
5710 
5711  template < typename BasicJsonType, typename CompatibleArrayType,
5712  enable_if_t < is_compatible_array_type<BasicJsonType,
5713  CompatibleArrayType>::value &&
5714  !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value &&
5715  !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value &&
5716  !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value &&
5717  !is_basic_json<CompatibleArrayType>::value,
5718  int > = 0 >
5719  inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
5720  {
5721  external_constructor<value_t::array>::construct(j, arr);
5722  }
5723 
5724  template<typename BasicJsonType>
5725  inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
5726  {
5727  external_constructor<value_t::binary>::construct(j, bin);
5728  }
5729 
5730  template<typename BasicJsonType, typename T,
5731  enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
5732  inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
5733  {
5734  external_constructor<value_t::array>::construct(j, std::move(arr));
5735  }
5736 
5737  template<typename BasicJsonType>
5738  inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
5739  {
5740  external_constructor<value_t::array>::construct(j, std::move(arr));
5741  }
5742 
5743  template < typename BasicJsonType, typename CompatibleObjectType,
5744  enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value && !is_basic_json<CompatibleObjectType>::value, int > = 0 >
5745  inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
5746  {
5747  external_constructor<value_t::object>::construct(j, obj);
5748  }
5749 
5750  template<typename BasicJsonType>
5751  inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
5752  {
5753  external_constructor<value_t::object>::construct(j, std::move(obj));
5754  }
5755 
5756  template <
5757  typename BasicJsonType, typename T, std::size_t N,
5758  enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
5759  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5760  int > = 0 >
5761  inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5762  {
5763  external_constructor<value_t::array>::construct(j, arr);
5764  }
5765 
5766  template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
5767  inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
5768  {
5769  j = { p.first, p.second };
5770  }
5771 
5772  // for https://github.com/nlohmann/json/pull/1134
5773  template<typename BasicJsonType, typename T,
5774  enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
5775  inline void to_json(BasicJsonType& j, const T& b)
5776  {
5777  j = { {b.key(), b.value()} };
5778  }
5779 
5780  template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
5781  inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
5782  {
5783  j = { std::get<Idx>(t)... };
5784  }
5785 
5786  template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
5787  inline void to_json(BasicJsonType& j, const T& t)
5788  {
5789  to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
5790  }
5791 
5792 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
5793  template<typename BasicJsonType>
5794  inline void to_json(BasicJsonType& j, const std_fs::path& p)
5795  {
5796  j = p.string();
5797  }
5798 #endif
5799 
5800  struct to_json_fn
5801  {
5802  template<typename BasicJsonType, typename T>
5803  auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
5804  -> decltype(to_json(j, std::forward<T>(val)), void())
5805  {
5806  return to_json(j, std::forward<T>(val));
5807  }
5808  };
5809 } // namespace detail
5810 
5811 #ifndef JSON_HAS_CPP_17
5815 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
5816 {
5817 #endif
5818  JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
5819  detail::static_const<detail::to_json_fn>::value;
5820 #ifndef JSON_HAS_CPP_17
5821 } // namespace
5822 #endif
5823 
5824 NLOHMANN_JSON_NAMESPACE_END
5825 
5826 // #include <nlohmann/detail/meta/identity_tag.hpp>
5827 
5828 
5829 NLOHMANN_JSON_NAMESPACE_BEGIN
5830 
5832 template<typename ValueType, typename>
5833 struct adl_serializer
5834 {
5837  template<typename BasicJsonType, typename TargetType = ValueType>
5838  static auto from_json(BasicJsonType&& j, TargetType& val) noexcept(
5839  noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
5840  -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
5841  {
5842  ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
5843  }
5844 
5847  template<typename BasicJsonType, typename TargetType = ValueType>
5848  static auto from_json(BasicJsonType&& j) noexcept(
5849  noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
5850  -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
5851  {
5852  return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
5853  }
5854 
5857  template<typename BasicJsonType, typename TargetType = ValueType>
5858  static auto to_json(BasicJsonType& j, TargetType&& val) noexcept(
5859  noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
5860  -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
5861  {
5862  ::nlohmann::to_json(j, std::forward<TargetType>(val));
5863  }
5864 };
5865 
5866 NLOHMANN_JSON_NAMESPACE_END
5867 
5868 // #include <nlohmann/byte_container_with_subtype.hpp>
5869 // __ _____ _____ _____
5870 // __| | __| | | | JSON for Modern C++
5871 // | | |__ | | | | | | version 3.11.3
5872 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
5873 //
5874 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
5875 // SPDX-License-Identifier: MIT
5876 
5877 
5878 
5879 #include <cstdint> // uint8_t, uint64_t
5880 #include <tuple> // tie
5881 #include <utility> // move
5882 
5883 // #include <nlohmann/detail/abi_macros.hpp>
5884 
5885 
5886 NLOHMANN_JSON_NAMESPACE_BEGIN
5887 
5890 template<typename BinaryType>
5891 class byte_container_with_subtype : public BinaryType
5892 {
5893 public:
5894  using container_type = BinaryType;
5895  using subtype_type = std::uint64_t;
5896 
5898  byte_container_with_subtype() noexcept(noexcept(container_type()))
5899  : container_type()
5900  {}
5901 
5903  byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
5904  : container_type(b)
5905  {}
5906 
5908  byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
5909  : container_type(std::move(b))
5910  {}
5911 
5913  byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
5914  : container_type(b)
5915  , m_subtype(subtype_)
5916  , m_has_subtype(true)
5917  {}
5918 
5920  byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
5921  : container_type(std::move(b))
5922  , m_subtype(subtype_)
5923  , m_has_subtype(true)
5924  {}
5925 
5926  bool operator==(const byte_container_with_subtype& rhs) const
5927  {
5928  return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
5929  std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
5930  }
5931 
5932  bool operator!=(const byte_container_with_subtype& rhs) const
5933  {
5934  return !(rhs == *this);
5935  }
5936 
5939  void set_subtype(subtype_type subtype_) noexcept
5940  {
5941  m_subtype = subtype_;
5942  m_has_subtype = true;
5943  }
5944 
5947  constexpr subtype_type subtype() const noexcept
5948  {
5949  return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
5950  }
5951 
5954  constexpr bool has_subtype() const noexcept
5955  {
5956  return m_has_subtype;
5957  }
5958 
5961  void clear_subtype() noexcept
5962  {
5963  m_subtype = 0;
5964  m_has_subtype = false;
5965  }
5966 
5967 private:
5968  subtype_type m_subtype = 0;
5969  bool m_has_subtype = false;
5970 };
5971 
5972 NLOHMANN_JSON_NAMESPACE_END
5973 
5974 // #include <nlohmann/detail/conversions/from_json.hpp>
5975 
5976 // #include <nlohmann/detail/conversions/to_json.hpp>
5977 
5978 // #include <nlohmann/detail/exceptions.hpp>
5979 
5980 // #include <nlohmann/detail/hash.hpp>
5981 // __ _____ _____ _____
5982 // __| | __| | | | JSON for Modern C++
5983 // | | |__ | | | | | | version 3.11.3
5984 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
5985 //
5986 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
5987 // SPDX-License-Identifier: MIT
5988 
5989 
5990 
5991 #include <cstdint> // uint8_t
5992 #include <cstddef> // size_t
5993 #include <functional> // hash
5994 
5995 // #include <nlohmann/detail/abi_macros.hpp>
5996 
5997 // #include <nlohmann/detail/value_t.hpp>
5998 
5999 
6000 NLOHMANN_JSON_NAMESPACE_BEGIN
6001 namespace detail
6002 {
6003 
6004  // boost::hash_combine
6005  inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
6006  {
6007  seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
6008  return seed;
6009  }
6010 
6022  template<typename BasicJsonType>
6023  std::size_t hash(const BasicJsonType& j)
6024  {
6025  using string_t = typename BasicJsonType::string_t;
6026  using number_integer_t = typename BasicJsonType::number_integer_t;
6027  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6028  using number_float_t = typename BasicJsonType::number_float_t;
6029 
6030  const auto type = static_cast<std::size_t>(j.type());
6031  switch (j.type())
6032  {
6033  case BasicJsonType::value_t::null:
6034  case BasicJsonType::value_t::discarded:
6035  {
6036  return combine(type, 0);
6037  }
6038 
6039  case BasicJsonType::value_t::object:
6040  {
6041  auto seed = combine(type, j.size());
6042  for (const auto& element : j.items())
6043  {
6044  const auto h = std::hash<string_t>{}(element.key());
6045  seed = combine(seed, h);
6046  seed = combine(seed, hash(element.value()));
6047  }
6048  return seed;
6049  }
6050 
6051  case BasicJsonType::value_t::array:
6052  {
6053  auto seed = combine(type, j.size());
6054  for (const auto& element : j)
6055  {
6056  seed = combine(seed, hash(element));
6057  }
6058  return seed;
6059  }
6060 
6061  case BasicJsonType::value_t::string:
6062  {
6063  const auto h = std::hash<string_t>{}(j.template get_ref<const string_t&>());
6064  return combine(type, h);
6065  }
6066 
6067  case BasicJsonType::value_t::boolean:
6068  {
6069  const auto h = std::hash<bool>{}(j.template get<bool>());
6070  return combine(type, h);
6071  }
6072 
6073  case BasicJsonType::value_t::number_integer:
6074  {
6075  const auto h = std::hash<number_integer_t>{}(j.template get<number_integer_t>());
6076  return combine(type, h);
6077  }
6078 
6079  case BasicJsonType::value_t::number_unsigned:
6080  {
6081  const auto h = std::hash<number_unsigned_t>{}(j.template get<number_unsigned_t>());
6082  return combine(type, h);
6083  }
6084 
6085  case BasicJsonType::value_t::number_float:
6086  {
6087  const auto h = std::hash<number_float_t>{}(j.template get<number_float_t>());
6088  return combine(type, h);
6089  }
6090 
6091  case BasicJsonType::value_t::binary:
6092  {
6093  auto seed = combine(type, j.get_binary().size());
6094  const auto h = std::hash<bool>{}(j.get_binary().has_subtype());
6095  seed = combine(seed, h);
6096  seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
6097  for (const auto byte : j.get_binary())
6098  {
6099  seed = combine(seed, std::hash<std::uint8_t> {}(byte));
6100  }
6101  return seed;
6102  }
6103 
6104  default: // LCOV_EXCL_LINE
6105  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
6106  return 0; // LCOV_EXCL_LINE
6107  }
6108  }
6109 
6110 } // namespace detail
6111 NLOHMANN_JSON_NAMESPACE_END
6112 
6113 // #include <nlohmann/detail/input/binary_reader.hpp>
6114 // __ _____ _____ _____
6115 // __| | __| | | | JSON for Modern C++
6116 // | | |__ | | | | | | version 3.11.3
6117 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
6118 //
6119 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
6120 // SPDX-License-Identifier: MIT
6121 
6122 
6123 
6124 #include <algorithm> // generate_n
6125 #include <array> // array
6126 #include <cmath> // ldexp
6127 #include <cstddef> // size_t
6128 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
6129 #include <cstdio> // snprintf
6130 #include <cstring> // memcpy
6131 #include <iterator> // back_inserter
6132 #include <limits> // numeric_limits
6133 #include <string> // char_traits, string
6134 #include <utility> // make_pair, move
6135 #include <vector> // vector
6136 
6137 // #include <nlohmann/detail/exceptions.hpp>
6138 
6139 // #include <nlohmann/detail/input/input_adapters.hpp>
6140 // __ _____ _____ _____
6141 // __| | __| | | | JSON for Modern C++
6142 // | | |__ | | | | | | version 3.11.3
6143 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
6144 //
6145 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
6146 // SPDX-License-Identifier: MIT
6147 
6148 
6149 
6150 #include <array> // array
6151 #include <cstddef> // size_t
6152 #include <cstring> // strlen
6153 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
6154 #include <memory> // shared_ptr, make_shared, addressof
6155 #include <numeric> // accumulate
6156 #include <string> // string, char_traits
6157 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
6158 #include <utility> // pair, declval
6159 
6160 #ifndef JSON_NO_IO
6161 #include <cstdio> // FILE *
6162 #include <istream> // istream
6163 #endif // JSON_NO_IO
6164 
6165 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
6166 
6167 // #include <nlohmann/detail/macro_scope.hpp>
6168 
6169 // #include <nlohmann/detail/meta/type_traits.hpp>
6170 
6171 
6172 NLOHMANN_JSON_NAMESPACE_BEGIN
6173 namespace detail
6174 {
6175 
6177  enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
6178 
6180  // input adapters //
6182 
6183 #ifndef JSON_NO_IO
6188  class file_input_adapter
6189  {
6190  public:
6191  using char_type = char;
6192 
6193  JSON_HEDLEY_NON_NULL(2)
6194  explicit file_input_adapter(std::FILE* f) noexcept
6195  : m_file(f)
6196  {
6197  JSON_ASSERT(m_file != nullptr);
6198  }
6199 
6200  // make class move-only
6201  file_input_adapter(const file_input_adapter&) = delete;
6202  file_input_adapter(file_input_adapter&&) noexcept = default;
6203  file_input_adapter& operator=(const file_input_adapter&) = delete;
6204  file_input_adapter& operator=(file_input_adapter&&) = delete;
6205  ~file_input_adapter() = default;
6206 
6207  std::char_traits<char>::int_type get_character() noexcept
6208  {
6209  return std::fgetc(m_file);
6210  }
6211 
6212  private:
6214  std::FILE* m_file;
6215  };
6216 
6226  class input_stream_adapter
6227  {
6228  public:
6229  using char_type = char;
6230 
6231  ~input_stream_adapter()
6232  {
6233  // clear stream flags; we use underlying streambuf I/O, do not
6234  // maintain ifstream flags, except eof
6235  if (is != nullptr)
6236  {
6237  is->clear(is->rdstate() & std::ios::eofbit);
6238  }
6239  }
6240 
6241  explicit input_stream_adapter(std::istream& i)
6242  : is(&i), sb(i.rdbuf())
6243  {}
6244 
6245  // delete because of pointer members
6246  input_stream_adapter(const input_stream_adapter&) = delete;
6247  input_stream_adapter& operator=(input_stream_adapter&) = delete;
6248  input_stream_adapter& operator=(input_stream_adapter&&) = delete;
6249 
6250  input_stream_adapter(input_stream_adapter&& rhs) noexcept
6251  : is(rhs.is), sb(rhs.sb)
6252  {
6253  rhs.is = nullptr;
6254  rhs.sb = nullptr;
6255  }
6256 
6257  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
6258  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
6259  // end up as the same value, e.g. 0xFFFFFFFF.
6260  std::char_traits<char>::int_type get_character()
6261  {
6262  auto res = sb->sbumpc();
6263  // set eof manually, as we don't use the istream interface.
6264  if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
6265  {
6266  is->clear(is->rdstate() | std::ios::eofbit);
6267  }
6268  return res;
6269  }
6270 
6271  private:
6273  std::istream* is = nullptr;
6274  std::streambuf* sb = nullptr;
6275  };
6276 #endif // JSON_NO_IO
6277 
6278  // General-purpose iterator-based adapter. It might not be as fast as
6279  // theoretically possible for some containers, but it is extremely versatile.
6280  template<typename IteratorType>
6281  class iterator_input_adapter
6282  {
6283  public:
6284  using char_type = typename std::iterator_traits<IteratorType>::value_type;
6285 
6286  iterator_input_adapter(IteratorType first, IteratorType last)
6287  : current(std::move(first)), end(std::move(last))
6288  {}
6289 
6290  typename char_traits<char_type>::int_type get_character()
6291  {
6292  if (JSON_HEDLEY_LIKELY(current != end))
6293  {
6294  auto result = char_traits<char_type>::to_int_type(*current);
6295  std::advance(current, 1);
6296  return result;
6297  }
6298 
6299  return char_traits<char_type>::eof();
6300  }
6301 
6302  private:
6303  IteratorType current;
6304  IteratorType end;
6305 
6306  template<typename BaseInputAdapter, size_t T>
6307  friend struct wide_string_input_helper;
6308 
6309  bool empty() const
6310  {
6311  return current == end;
6312  }
6313  };
6314 
6315  template<typename BaseInputAdapter, size_t T>
6316  struct wide_string_input_helper;
6317 
6318  template<typename BaseInputAdapter>
6319  struct wide_string_input_helper<BaseInputAdapter, 4>
6320  {
6321  // UTF-32
6322  static void fill_buffer(BaseInputAdapter& input,
6323  std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
6324  size_t& utf8_bytes_index,
6325  size_t& utf8_bytes_filled)
6326  {
6327  utf8_bytes_index = 0;
6328 
6329  if (JSON_HEDLEY_UNLIKELY(input.empty()))
6330  {
6331  utf8_bytes[0] = std::char_traits<char>::eof();
6332  utf8_bytes_filled = 1;
6333  }
6334  else
6335  {
6336  // get the current character
6337  const auto wc = input.get_character();
6338 
6339  // UTF-32 to UTF-8 encoding
6340  if (wc < 0x80)
6341  {
6342  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6343  utf8_bytes_filled = 1;
6344  }
6345  else if (wc <= 0x7FF)
6346  {
6347  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
6348  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6349  utf8_bytes_filled = 2;
6350  }
6351  else if (wc <= 0xFFFF)
6352  {
6353  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
6354  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6355  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6356  utf8_bytes_filled = 3;
6357  }
6358  else if (wc <= 0x10FFFF)
6359  {
6360  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
6361  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
6362  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6363  utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6364  utf8_bytes_filled = 4;
6365  }
6366  else
6367  {
6368  // unknown character
6369  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6370  utf8_bytes_filled = 1;
6371  }
6372  }
6373  }
6374  };
6375 
6376  template<typename BaseInputAdapter>
6377  struct wide_string_input_helper<BaseInputAdapter, 2>
6378  {
6379  // UTF-16
6380  static void fill_buffer(BaseInputAdapter& input,
6381  std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
6382  size_t& utf8_bytes_index,
6383  size_t& utf8_bytes_filled)
6384  {
6385  utf8_bytes_index = 0;
6386 
6387  if (JSON_HEDLEY_UNLIKELY(input.empty()))
6388  {
6389  utf8_bytes[0] = std::char_traits<char>::eof();
6390  utf8_bytes_filled = 1;
6391  }
6392  else
6393  {
6394  // get the current character
6395  const auto wc = input.get_character();
6396 
6397  // UTF-16 to UTF-8 encoding
6398  if (wc < 0x80)
6399  {
6400  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6401  utf8_bytes_filled = 1;
6402  }
6403  else if (wc <= 0x7FF)
6404  {
6405  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
6406  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6407  utf8_bytes_filled = 2;
6408  }
6409  else if (0xD800 > wc || wc >= 0xE000)
6410  {
6411  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
6412  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6413  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6414  utf8_bytes_filled = 3;
6415  }
6416  else
6417  {
6418  if (JSON_HEDLEY_UNLIKELY(!input.empty()))
6419  {
6420  const auto wc2 = static_cast<unsigned int>(input.get_character());
6421  const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
6422  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
6423  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
6424  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
6425  utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
6426  utf8_bytes_filled = 4;
6427  }
6428  else
6429  {
6430  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6431  utf8_bytes_filled = 1;
6432  }
6433  }
6434  }
6435  }
6436  };
6437 
6438  // Wraps another input adapter to convert wide character types into individual bytes.
6439  template<typename BaseInputAdapter, typename WideCharType>
6440  class wide_string_input_adapter
6441  {
6442  public:
6443  using char_type = char;
6444 
6445  wide_string_input_adapter(BaseInputAdapter base)
6446  : base_adapter(base) {}
6447 
6448  typename std::char_traits<char>::int_type get_character() noexcept
6449  {
6450  // check if buffer needs to be filled
6451  if (utf8_bytes_index == utf8_bytes_filled)
6452  {
6453  fill_buffer<sizeof(WideCharType)>();
6454 
6455  JSON_ASSERT(utf8_bytes_filled > 0);
6456  JSON_ASSERT(utf8_bytes_index == 0);
6457  }
6458 
6459  // use buffer
6460  JSON_ASSERT(utf8_bytes_filled > 0);
6461  JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
6462  return utf8_bytes[utf8_bytes_index++];
6463  }
6464 
6465  private:
6466  BaseInputAdapter base_adapter;
6467 
6468  template<size_t T>
6469  void fill_buffer()
6470  {
6471  wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
6472  }
6473 
6475  std::array<std::char_traits<char>::int_type, 4> utf8_bytes = { {0, 0, 0, 0} };
6476 
6478  std::size_t utf8_bytes_index = 0;
6480  std::size_t utf8_bytes_filled = 0;
6481  };
6482 
6483  template<typename IteratorType, typename Enable = void>
6484  struct iterator_input_adapter_factory
6485  {
6486  using iterator_type = IteratorType;
6487  using char_type = typename std::iterator_traits<iterator_type>::value_type;
6488  using adapter_type = iterator_input_adapter<iterator_type>;
6489 
6490  static adapter_type create(IteratorType first, IteratorType last)
6491  {
6492  return adapter_type(std::move(first), std::move(last));
6493  }
6494  };
6495 
6496  template<typename T>
6497  struct is_iterator_of_multibyte
6498  {
6499  using value_type = typename std::iterator_traits<T>::value_type;
6500  enum
6501  {
6502  value = sizeof(value_type) > 1
6503  };
6504  };
6505 
6506  template<typename IteratorType>
6507  struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
6508  {
6509  using iterator_type = IteratorType;
6510  using char_type = typename std::iterator_traits<iterator_type>::value_type;
6511  using base_adapter_type = iterator_input_adapter<iterator_type>;
6512  using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
6513 
6514  static adapter_type create(IteratorType first, IteratorType last)
6515  {
6516  return adapter_type(base_adapter_type(std::move(first), std::move(last)));
6517  }
6518  };
6519 
6520  // General purpose iterator-based input
6521  template<typename IteratorType>
6522  typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
6523  {
6524  using factory_type = iterator_input_adapter_factory<IteratorType>;
6525  return factory_type::create(first, last);
6526  }
6527 
6528  // Convenience shorthand from container to iterator
6529  // Enables ADL on begin(container) and end(container)
6530  // Encloses the using declarations in namespace for not to leak them to outside scope
6531 
6532  namespace container_input_adapter_factory_impl
6533  {
6534 
6535  using std::begin;
6536  using std::end;
6537 
6538  template<typename ContainerType, typename Enable = void>
6539  struct container_input_adapter_factory {};
6540 
6541  template<typename ContainerType>
6542  struct container_input_adapter_factory< ContainerType,
6543  void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
6544  {
6545  using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
6546 
6547  static adapter_type create(const ContainerType& container)
6548  {
6549  return input_adapter(begin(container), end(container));
6550  }
6551  };
6552 
6553  } // namespace container_input_adapter_factory_impl
6554 
6555  template<typename ContainerType>
6556  typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
6557  {
6558  return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
6559  }
6560 
6561 #ifndef JSON_NO_IO
6562  // Special cases with fast paths
6563  inline file_input_adapter input_adapter(std::FILE* file)
6564  {
6565  return file_input_adapter(file);
6566  }
6567 
6568  inline input_stream_adapter input_adapter(std::istream& stream)
6569  {
6570  return input_stream_adapter(stream);
6571  }
6572 
6573  inline input_stream_adapter input_adapter(std::istream&& stream)
6574  {
6575  return input_stream_adapter(stream);
6576  }
6577 #endif // JSON_NO_IO
6578 
6579  using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
6580 
6581  // Null-delimited strings, and the like.
6582  template < typename CharT,
6583  typename std::enable_if <
6584  std::is_pointer<CharT>::value &&
6585  !std::is_array<CharT>::value&&
6586  std::is_integral<typename std::remove_pointer<CharT>::type>::value &&
6587  sizeof(typename std::remove_pointer<CharT>::type) == 1,
6588  int >::type = 0 >
6589  contiguous_bytes_input_adapter input_adapter(CharT b)
6590  {
6591  auto length = std::strlen(reinterpret_cast<const char*>(b));
6592  const auto* ptr = reinterpret_cast<const char*>(b);
6593  return input_adapter(ptr, ptr + length);
6594  }
6595 
6596  template<typename T, std::size_t N>
6597  auto input_adapter(T(&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
6598  {
6599  return input_adapter(array, array + N);
6600  }
6601 
6602  // This class only handles inputs of input_buffer_adapter type.
6603  // It's required so that expressions like {ptr, len} can be implicitly cast
6604  // to the correct adapter.
6605  class span_input_adapter
6606  {
6607  public:
6608  template < typename CharT,
6609  typename std::enable_if <
6610  std::is_pointer<CharT>::value&&
6611  std::is_integral<typename std::remove_pointer<CharT>::type>::value &&
6612  sizeof(typename std::remove_pointer<CharT>::type) == 1,
6613  int >::type = 0 >
6614  span_input_adapter(CharT b, std::size_t l)
6615  : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
6616 
6617  template<class IteratorType,
6618  typename std::enable_if<
6619  std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
6620  int>::type = 0>
6621  span_input_adapter(IteratorType first, IteratorType last)
6622  : ia(input_adapter(first, last)) {}
6623 
6624  contiguous_bytes_input_adapter&& get()
6625  {
6626  return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
6627  }
6628 
6629  private:
6630  contiguous_bytes_input_adapter ia;
6631  };
6632 
6633 } // namespace detail
6634 NLOHMANN_JSON_NAMESPACE_END
6635 
6636 // #include <nlohmann/detail/input/json_sax.hpp>
6637 // __ _____ _____ _____
6638 // __| | __| | | | JSON for Modern C++
6639 // | | |__ | | | | | | version 3.11.3
6640 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
6641 //
6642 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
6643 // SPDX-License-Identifier: MIT
6644 
6645 
6646 
6647 #include <cstddef>
6648 #include <string> // string
6649 #include <utility> // move
6650 #include <vector> // vector
6651 
6652 // #include <nlohmann/detail/exceptions.hpp>
6653 
6654 // #include <nlohmann/detail/macro_scope.hpp>
6655 
6656 // #include <nlohmann/detail/string_concat.hpp>
6657 
6658 
6659 NLOHMANN_JSON_NAMESPACE_BEGIN
6660 
6669 template<typename BasicJsonType>
6670 struct json_sax
6671 {
6672  using number_integer_t = typename BasicJsonType::number_integer_t;
6673  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6674  using number_float_t = typename BasicJsonType::number_float_t;
6675  using string_t = typename BasicJsonType::string_t;
6676  using binary_t = typename BasicJsonType::binary_t;
6677 
6682  virtual bool null() = 0;
6683 
6689  virtual bool boolean(bool val) = 0;
6690 
6696  virtual bool number_integer(number_integer_t val) = 0;
6697 
6703  virtual bool number_unsigned(number_unsigned_t val) = 0;
6704 
6711  virtual bool number_float(number_float_t val, const string_t& s) = 0;
6712 
6719  virtual bool string(string_t& val) = 0;
6720 
6727  virtual bool binary(binary_t& val) = 0;
6728 
6735  virtual bool start_object(std::size_t elements) = 0;
6736 
6743  virtual bool key(string_t& val) = 0;
6744 
6749  virtual bool end_object() = 0;
6750 
6757  virtual bool start_array(std::size_t elements) = 0;
6758 
6763  virtual bool end_array() = 0;
6764 
6772  virtual bool parse_error(std::size_t position,
6773  const std::string& last_token,
6774  const detail::exception& ex) = 0;
6775 
6776  json_sax() = default;
6777  json_sax(const json_sax&) = default;
6778  json_sax(json_sax&&) noexcept = default;
6779  json_sax& operator=(const json_sax&) = default;
6780  json_sax& operator=(json_sax&&) noexcept = default;
6781  virtual ~json_sax() = default;
6782 };
6783 
6784 namespace detail
6785 {
6799  template<typename BasicJsonType>
6800  class json_sax_dom_parser
6801  {
6802  public:
6803  using number_integer_t = typename BasicJsonType::number_integer_t;
6804  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6805  using number_float_t = typename BasicJsonType::number_float_t;
6806  using string_t = typename BasicJsonType::string_t;
6807  using binary_t = typename BasicJsonType::binary_t;
6808 
6814  explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
6815  : root(r), allow_exceptions(allow_exceptions_)
6816  {}
6817 
6818  // make class move-only
6819  json_sax_dom_parser(const json_sax_dom_parser&) = delete;
6820  json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6821  json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
6822  json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6823  ~json_sax_dom_parser() = default;
6824 
6825  bool null()
6826  {
6827  handle_value(nullptr);
6828  return true;
6829  }
6830 
6831  bool boolean(bool val)
6832  {
6833  handle_value(val);
6834  return true;
6835  }
6836 
6837  bool number_integer(number_integer_t val)
6838  {
6839  handle_value(val);
6840  return true;
6841  }
6842 
6843  bool number_unsigned(number_unsigned_t val)
6844  {
6845  handle_value(val);
6846  return true;
6847  }
6848 
6849  bool number_float(number_float_t val, const string_t& /*unused*/)
6850  {
6851  handle_value(val);
6852  return true;
6853  }
6854 
6855  bool string(string_t& val)
6856  {
6857  handle_value(val);
6858  return true;
6859  }
6860 
6861  bool binary(binary_t& val)
6862  {
6863  handle_value(std::move(val));
6864  return true;
6865  }
6866 
6867  bool start_object(std::size_t len)
6868  {
6869  ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
6870 
6871  if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6872  {
6873  JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
6874  }
6875 
6876  return true;
6877  }
6878 
6879  bool key(string_t& val)
6880  {
6881  JSON_ASSERT(!ref_stack.empty());
6882  JSON_ASSERT(ref_stack.back()->is_object());
6883 
6884  // add null at given key and store the reference for later
6885  object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
6886  return true;
6887  }
6888 
6889  bool end_object()
6890  {
6891  JSON_ASSERT(!ref_stack.empty());
6892  JSON_ASSERT(ref_stack.back()->is_object());
6893 
6894  ref_stack.back()->set_parents();
6895  ref_stack.pop_back();
6896  return true;
6897  }
6898 
6899  bool start_array(std::size_t len)
6900  {
6901  ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
6902 
6903  if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6904  {
6905  JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
6906  }
6907 
6908  return true;
6909  }
6910 
6911  bool end_array()
6912  {
6913  JSON_ASSERT(!ref_stack.empty());
6914  JSON_ASSERT(ref_stack.back()->is_array());
6915 
6916  ref_stack.back()->set_parents();
6917  ref_stack.pop_back();
6918  return true;
6919  }
6920 
6921  template<class Exception>
6922  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
6923  const Exception& ex)
6924  {
6925  errored = true;
6926  static_cast<void>(ex);
6927  if (allow_exceptions)
6928  {
6929  JSON_THROW(ex);
6930  }
6931  return false;
6932  }
6933 
6934  constexpr bool is_errored() const
6935  {
6936  return errored;
6937  }
6938 
6939  private:
6946  template<typename Value>
6947  JSON_HEDLEY_RETURNS_NON_NULL
6948  BasicJsonType* handle_value(Value&& v)
6949  {
6950  if (ref_stack.empty())
6951  {
6952  root = BasicJsonType(std::forward<Value>(v));
6953  return &root;
6954  }
6955 
6956  JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6957 
6958  if (ref_stack.back()->is_array())
6959  {
6960  ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
6961  return &(ref_stack.back()->m_data.m_value.array->back());
6962  }
6963 
6964  JSON_ASSERT(ref_stack.back()->is_object());
6965  JSON_ASSERT(object_element);
6966  *object_element = BasicJsonType(std::forward<Value>(v));
6967  return object_element;
6968  }
6969 
6971  BasicJsonType& root;
6973  std::vector<BasicJsonType*> ref_stack{};
6975  BasicJsonType* object_element = nullptr;
6977  bool errored = false;
6979  const bool allow_exceptions = true;
6980  };
6981 
6982  template<typename BasicJsonType>
6983  class json_sax_dom_callback_parser
6984  {
6985  public:
6986  using number_integer_t = typename BasicJsonType::number_integer_t;
6987  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6988  using number_float_t = typename BasicJsonType::number_float_t;
6989  using string_t = typename BasicJsonType::string_t;
6990  using binary_t = typename BasicJsonType::binary_t;
6991  using parser_callback_t = typename BasicJsonType::parser_callback_t;
6992  using parse_event_t = typename BasicJsonType::parse_event_t;
6993 
6994  json_sax_dom_callback_parser(BasicJsonType& r,
6995  const parser_callback_t cb,
6996  const bool allow_exceptions_ = true)
6997  : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6998  {
6999  keep_stack.push_back(true);
7000  }
7001 
7002  // make class move-only
7003  json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
7004  json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
7005  json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
7006  json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
7007  ~json_sax_dom_callback_parser() = default;
7008 
7009  bool null()
7010  {
7011  handle_value(nullptr);
7012  return true;
7013  }
7014 
7015  bool boolean(bool val)
7016  {
7017  handle_value(val);
7018  return true;
7019  }
7020 
7021  bool number_integer(number_integer_t val)
7022  {
7023  handle_value(val);
7024  return true;
7025  }
7026 
7027  bool number_unsigned(number_unsigned_t val)
7028  {
7029  handle_value(val);
7030  return true;
7031  }
7032 
7033  bool number_float(number_float_t val, const string_t& /*unused*/)
7034  {
7035  handle_value(val);
7036  return true;
7037  }
7038 
7039  bool string(string_t& val)
7040  {
7041  handle_value(val);
7042  return true;
7043  }
7044 
7045  bool binary(binary_t& val)
7046  {
7047  handle_value(std::move(val));
7048  return true;
7049  }
7050 
7051  bool start_object(std::size_t len)
7052  {
7053  // check callback for object start
7054  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
7055  keep_stack.push_back(keep);
7056 
7057  auto val = handle_value(BasicJsonType::value_t::object, true);
7058  ref_stack.push_back(val.second);
7059 
7060  // check object limit
7061  if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
7062  {
7063  JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
7064  }
7065 
7066  return true;
7067  }
7068 
7069  bool key(string_t& val)
7070  {
7071  BasicJsonType k = BasicJsonType(val);
7072 
7073  // check callback for key
7074  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
7075  key_keep_stack.push_back(keep);
7076 
7077  // add discarded value at given key and store the reference for later
7078  if (keep && ref_stack.back())
7079  {
7080  object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
7081  }
7082 
7083  return true;
7084  }
7085 
7086  bool end_object()
7087  {
7088  if (ref_stack.back())
7089  {
7090  if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
7091  {
7092  // discard object
7093  *ref_stack.back() = discarded;
7094  }
7095  else
7096  {
7097  ref_stack.back()->set_parents();
7098  }
7099  }
7100 
7101  JSON_ASSERT(!ref_stack.empty());
7102  JSON_ASSERT(!keep_stack.empty());
7103  ref_stack.pop_back();
7104  keep_stack.pop_back();
7105 
7106  if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
7107  {
7108  // remove discarded value
7109  for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
7110  {
7111  if (it->is_discarded())
7112  {
7113  ref_stack.back()->erase(it);
7114  break;
7115  }
7116  }
7117  }
7118 
7119  return true;
7120  }
7121 
7122  bool start_array(std::size_t len)
7123  {
7124  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
7125  keep_stack.push_back(keep);
7126 
7127  auto val = handle_value(BasicJsonType::value_t::array, true);
7128  ref_stack.push_back(val.second);
7129 
7130  // check array limit
7131  if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
7132  {
7133  JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
7134  }
7135 
7136  return true;
7137  }
7138 
7139  bool end_array()
7140  {
7141  bool keep = true;
7142 
7143  if (ref_stack.back())
7144  {
7145  keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
7146  if (keep)
7147  {
7148  ref_stack.back()->set_parents();
7149  }
7150  else
7151  {
7152  // discard array
7153  *ref_stack.back() = discarded;
7154  }
7155  }
7156 
7157  JSON_ASSERT(!ref_stack.empty());
7158  JSON_ASSERT(!keep_stack.empty());
7159  ref_stack.pop_back();
7160  keep_stack.pop_back();
7161 
7162  // remove discarded value
7163  if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
7164  {
7165  ref_stack.back()->m_data.m_value.array->pop_back();
7166  }
7167 
7168  return true;
7169  }
7170 
7171  template<class Exception>
7172  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
7173  const Exception& ex)
7174  {
7175  errored = true;
7176  static_cast<void>(ex);
7177  if (allow_exceptions)
7178  {
7179  JSON_THROW(ex);
7180  }
7181  return false;
7182  }
7183 
7184  constexpr bool is_errored() const
7185  {
7186  return errored;
7187  }
7188 
7189  private:
7205  template<typename Value>
7206  std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
7207  {
7208  JSON_ASSERT(!keep_stack.empty());
7209 
7210  // do not handle this value if we know it would be added to a discarded
7211  // container
7212  if (!keep_stack.back())
7213  {
7214  return { false, nullptr };
7215  }
7216 
7217  // create value
7218  auto value = BasicJsonType(std::forward<Value>(v));
7219 
7220  // check callback
7221  const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
7222 
7223  // do not handle this value if we just learnt it shall be discarded
7224  if (!keep)
7225  {
7226  return { false, nullptr };
7227  }
7228 
7229  if (ref_stack.empty())
7230  {
7231  root = std::move(value);
7232  return { true, &root };
7233  }
7234 
7235  // skip this value if we already decided to skip the parent
7236  // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
7237  if (!ref_stack.back())
7238  {
7239  return { false, nullptr };
7240  }
7241 
7242  // we now only expect arrays and objects
7243  JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
7244 
7245  // array
7246  if (ref_stack.back()->is_array())
7247  {
7248  ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
7249  return { true, &(ref_stack.back()->m_data.m_value.array->back()) };
7250  }
7251 
7252  // object
7253  JSON_ASSERT(ref_stack.back()->is_object());
7254  // check if we should store an element for the current key
7255  JSON_ASSERT(!key_keep_stack.empty());
7256  const bool store_element = key_keep_stack.back();
7257  key_keep_stack.pop_back();
7258 
7259  if (!store_element)
7260  {
7261  return { false, nullptr };
7262  }
7263 
7264  JSON_ASSERT(object_element);
7265  *object_element = std::move(value);
7266  return { true, object_element };
7267  }
7268 
7270  BasicJsonType& root;
7272  std::vector<BasicJsonType*> ref_stack{};
7274  std::vector<bool> keep_stack{};
7276  std::vector<bool> key_keep_stack{};
7278  BasicJsonType* object_element = nullptr;
7280  bool errored = false;
7282  const parser_callback_t callback = nullptr;
7284  const bool allow_exceptions = true;
7286  BasicJsonType discarded = BasicJsonType::value_t::discarded;
7287  };
7288 
7289  template<typename BasicJsonType>
7290  class json_sax_acceptor
7291  {
7292  public:
7293  using number_integer_t = typename BasicJsonType::number_integer_t;
7294  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7295  using number_float_t = typename BasicJsonType::number_float_t;
7296  using string_t = typename BasicJsonType::string_t;
7297  using binary_t = typename BasicJsonType::binary_t;
7298 
7299  bool null()
7300  {
7301  return true;
7302  }
7303 
7304  bool boolean(bool /*unused*/)
7305  {
7306  return true;
7307  }
7308 
7309  bool number_integer(number_integer_t /*unused*/)
7310  {
7311  return true;
7312  }
7313 
7314  bool number_unsigned(number_unsigned_t /*unused*/)
7315  {
7316  return true;
7317  }
7318 
7319  bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
7320  {
7321  return true;
7322  }
7323 
7324  bool string(string_t& /*unused*/)
7325  {
7326  return true;
7327  }
7328 
7329  bool binary(binary_t& /*unused*/)
7330  {
7331  return true;
7332  }
7333 
7334  bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
7335  {
7336  return true;
7337  }
7338 
7339  bool key(string_t& /*unused*/)
7340  {
7341  return true;
7342  }
7343 
7344  bool end_object()
7345  {
7346  return true;
7347  }
7348 
7349  bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
7350  {
7351  return true;
7352  }
7353 
7354  bool end_array()
7355  {
7356  return true;
7357  }
7358 
7359  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
7360  {
7361  return false;
7362  }
7363  };
7364 
7365 } // namespace detail
7366 NLOHMANN_JSON_NAMESPACE_END
7367 
7368 // #include <nlohmann/detail/input/lexer.hpp>
7369 // __ _____ _____ _____
7370 // __| | __| | | | JSON for Modern C++
7371 // | | |__ | | | | | | version 3.11.3
7372 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
7373 //
7374 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
7375 // SPDX-License-Identifier: MIT
7376 
7377 
7378 
7379 #include <array> // array
7380 #include <clocale> // localeconv
7381 #include <cstddef> // size_t
7382 #include <cstdio> // snprintf
7383 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
7384 #include <initializer_list> // initializer_list
7385 #include <string> // char_traits, string
7386 #include <utility> // move
7387 #include <vector> // vector
7388 
7389 // #include <nlohmann/detail/input/input_adapters.hpp>
7390 
7391 // #include <nlohmann/detail/input/position_t.hpp>
7392 
7393 // #include <nlohmann/detail/macro_scope.hpp>
7394 
7395 // #include <nlohmann/detail/meta/type_traits.hpp>
7396 
7397 
7398 NLOHMANN_JSON_NAMESPACE_BEGIN
7399 namespace detail
7400 {
7401 
7403  // lexer //
7405 
7406  template<typename BasicJsonType>
7407  class lexer_base
7408  {
7409  public:
7411  enum class token_type
7412  {
7413  uninitialized,
7414  literal_true,
7415  literal_false,
7416  literal_null,
7417  value_string,
7418  value_unsigned,
7419  value_integer,
7420  value_float,
7421  begin_array,
7422  begin_object,
7423  end_array,
7424  end_object,
7425  name_separator,
7426  value_separator,
7427  parse_error,
7428  end_of_input,
7429  literal_or_value
7430  };
7431 
7433  JSON_HEDLEY_RETURNS_NON_NULL
7434  JSON_HEDLEY_CONST
7435  static const char* token_type_name(const token_type t) noexcept
7436  {
7437  switch (t)
7438  {
7439  case token_type::uninitialized:
7440  return "<uninitialized>";
7441  case token_type::literal_true:
7442  return "true literal";
7443  case token_type::literal_false:
7444  return "false literal";
7445  case token_type::literal_null:
7446  return "null literal";
7447  case token_type::value_string:
7448  return "string literal";
7449  case token_type::value_unsigned:
7450  case token_type::value_integer:
7451  case token_type::value_float:
7452  return "number literal";
7453  case token_type::begin_array:
7454  return "'['";
7455  case token_type::begin_object:
7456  return "'{'";
7457  case token_type::end_array:
7458  return "']'";
7459  case token_type::end_object:
7460  return "'}'";
7461  case token_type::name_separator:
7462  return "':'";
7463  case token_type::value_separator:
7464  return "','";
7465  case token_type::parse_error:
7466  return "<parse error>";
7467  case token_type::end_of_input:
7468  return "end of input";
7469  case token_type::literal_or_value:
7470  return "'[', '{', or a literal";
7471  // LCOV_EXCL_START
7472  default: // catch non-enum values
7473  return "unknown token";
7474  // LCOV_EXCL_STOP
7475  }
7476  }
7477  };
7483  template<typename BasicJsonType, typename InputAdapterType>
7484  class lexer : public lexer_base<BasicJsonType>
7485  {
7486  using number_integer_t = typename BasicJsonType::number_integer_t;
7487  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7488  using number_float_t = typename BasicJsonType::number_float_t;
7489  using string_t = typename BasicJsonType::string_t;
7490  using char_type = typename InputAdapterType::char_type;
7491  using char_int_type = typename char_traits<char_type>::int_type;
7492 
7493  public:
7494  using token_type = typename lexer_base<BasicJsonType>::token_type;
7495 
7496  explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
7497  : ia(std::move(adapter))
7498  , ignore_comments(ignore_comments_)
7499  , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
7500  {}
7501 
7502  // delete because of pointer members
7503  lexer(const lexer&) = delete;
7504  lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
7505  lexer& operator=(lexer&) = delete;
7506  lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
7507  ~lexer() = default;
7508 
7509  private:
7511  // locales
7513 
7515  JSON_HEDLEY_PURE
7516  static char get_decimal_point() noexcept
7517  {
7518  const auto* loc = localeconv();
7519  JSON_ASSERT(loc != nullptr);
7520  return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
7521  }
7522 
7524  // scan functions
7526 
7542  int get_codepoint()
7543  {
7544  // this function only makes sense after reading `\u`
7545  JSON_ASSERT(current == 'u');
7546  int codepoint = 0;
7547 
7548  const auto factors = { 12u, 8u, 4u, 0u };
7549  for (const auto factor : factors)
7550  {
7551  get();
7552 
7553  if (current >= '0' && current <= '9')
7554  {
7555  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
7556  }
7557  else if (current >= 'A' && current <= 'F')
7558  {
7559  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
7560  }
7561  else if (current >= 'a' && current <= 'f')
7562  {
7563  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
7564  }
7565  else
7566  {
7567  return -1;
7568  }
7569  }
7570 
7571  JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
7572  return codepoint;
7573  }
7574 
7590  bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
7591  {
7592  JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
7593  add(current);
7594 
7595  for (auto range = ranges.begin(); range != ranges.end(); ++range)
7596  {
7597  get();
7598  if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
7599  {
7600  add(current);
7601  }
7602  else
7603  {
7604  error_message = "invalid string: ill-formed UTF-8 byte";
7605  return false;
7606  }
7607  }
7608 
7609  return true;
7610  }
7611 
7627  token_type scan_string()
7628  {
7629  // reset token_buffer (ignore opening quote)
7630  reset();
7631 
7632  // we entered the function by reading an open quote
7633  JSON_ASSERT(current == '\"');
7634 
7635  while (true)
7636  {
7637  // get next character
7638  switch (get())
7639  {
7640  // end of file while parsing string
7641  case char_traits<char_type>::eof():
7642  {
7643  error_message = "invalid string: missing closing quote";
7644  return token_type::parse_error;
7645  }
7646 
7647  // closing quote
7648  case '\"':
7649  {
7650  return token_type::value_string;
7651  }
7652 
7653  // escapes
7654  case '\\':
7655  {
7656  switch (get())
7657  {
7658  // quotation mark
7659  case '\"':
7660  add('\"');
7661  break;
7662  // reverse solidus
7663  case '\\':
7664  add('\\');
7665  break;
7666  // solidus
7667  case '/':
7668  add('/');
7669  break;
7670  // backspace
7671  case 'b':
7672  add('\b');
7673  break;
7674  // form feed
7675  case 'f':
7676  add('\f');
7677  break;
7678  // line feed
7679  case 'n':
7680  add('\n');
7681  break;
7682  // carriage return
7683  case 'r':
7684  add('\r');
7685  break;
7686  // tab
7687  case 't':
7688  add('\t');
7689  break;
7690 
7691  // unicode escapes
7692  case 'u':
7693  {
7694  const int codepoint1 = get_codepoint();
7695  int codepoint = codepoint1; // start with codepoint1
7696 
7697  if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
7698  {
7699  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
7700  return token_type::parse_error;
7701  }
7702 
7703  // check if code point is a high surrogate
7704  if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
7705  {
7706  // expect next \uxxxx entry
7707  if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
7708  {
7709  const int codepoint2 = get_codepoint();
7710 
7711  if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
7712  {
7713  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
7714  return token_type::parse_error;
7715  }
7716 
7717  // check if codepoint2 is a low surrogate
7718  if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
7719  {
7720  // overwrite codepoint
7721  codepoint = static_cast<int>(
7722  // high surrogate occupies the most significant 22 bits
7723  (static_cast<unsigned int>(codepoint1) << 10u)
7724  // low surrogate occupies the least significant 15 bits
7725  + static_cast<unsigned int>(codepoint2)
7726  // there is still the 0xD800, 0xDC00 and 0x10000 noise
7727  // in the result, so we have to subtract with:
7728  // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
7729  -0x35FDC00u);
7730  }
7731  else
7732  {
7733  error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
7734  return token_type::parse_error;
7735  }
7736  }
7737  else
7738  {
7739  error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
7740  return token_type::parse_error;
7741  }
7742  }
7743  else
7744  {
7745  if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
7746  {
7747  error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
7748  return token_type::parse_error;
7749  }
7750  }
7751 
7752  // result of the above calculation yields a proper codepoint
7753  JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
7754 
7755  // translate codepoint into bytes
7756  if (codepoint < 0x80)
7757  {
7758  // 1-byte characters: 0xxxxxxx (ASCII)
7759  add(static_cast<char_int_type>(codepoint));
7760  }
7761  else if (codepoint <= 0x7FF)
7762  {
7763  // 2-byte characters: 110xxxxx 10xxxxxx
7764  add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
7765  add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7766  }
7767  else if (codepoint <= 0xFFFF)
7768  {
7769  // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
7770  add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
7771  add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7772  add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7773  }
7774  else
7775  {
7776  // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
7777  add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
7778  add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
7779  add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7780  add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7781  }
7782 
7783  break;
7784  }
7785 
7786  // other characters after escape
7787  default:
7788  error_message = "invalid string: forbidden character after backslash";
7789  return token_type::parse_error;
7790  }
7791 
7792  break;
7793  }
7794 
7795  // invalid control characters
7796  case 0x00:
7797  {
7798  error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
7799  return token_type::parse_error;
7800  }
7801 
7802  case 0x01:
7803  {
7804  error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
7805  return token_type::parse_error;
7806  }
7807 
7808  case 0x02:
7809  {
7810  error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
7811  return token_type::parse_error;
7812  }
7813 
7814  case 0x03:
7815  {
7816  error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
7817  return token_type::parse_error;
7818  }
7819 
7820  case 0x04:
7821  {
7822  error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
7823  return token_type::parse_error;
7824  }
7825 
7826  case 0x05:
7827  {
7828  error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
7829  return token_type::parse_error;
7830  }
7831 
7832  case 0x06:
7833  {
7834  error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
7835  return token_type::parse_error;
7836  }
7837 
7838  case 0x07:
7839  {
7840  error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
7841  return token_type::parse_error;
7842  }
7843 
7844  case 0x08:
7845  {
7846  error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
7847  return token_type::parse_error;
7848  }
7849 
7850  case 0x09:
7851  {
7852  error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
7853  return token_type::parse_error;
7854  }
7855 
7856  case 0x0A:
7857  {
7858  error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
7859  return token_type::parse_error;
7860  }
7861 
7862  case 0x0B:
7863  {
7864  error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
7865  return token_type::parse_error;
7866  }
7867 
7868  case 0x0C:
7869  {
7870  error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
7871  return token_type::parse_error;
7872  }
7873 
7874  case 0x0D:
7875  {
7876  error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
7877  return token_type::parse_error;
7878  }
7879 
7880  case 0x0E:
7881  {
7882  error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
7883  return token_type::parse_error;
7884  }
7885 
7886  case 0x0F:
7887  {
7888  error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
7889  return token_type::parse_error;
7890  }
7891 
7892  case 0x10:
7893  {
7894  error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
7895  return token_type::parse_error;
7896  }
7897 
7898  case 0x11:
7899  {
7900  error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
7901  return token_type::parse_error;
7902  }
7903 
7904  case 0x12:
7905  {
7906  error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
7907  return token_type::parse_error;
7908  }
7909 
7910  case 0x13:
7911  {
7912  error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
7913  return token_type::parse_error;
7914  }
7915 
7916  case 0x14:
7917  {
7918  error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
7919  return token_type::parse_error;
7920  }
7921 
7922  case 0x15:
7923  {
7924  error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7925  return token_type::parse_error;
7926  }
7927 
7928  case 0x16:
7929  {
7930  error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7931  return token_type::parse_error;
7932  }
7933 
7934  case 0x17:
7935  {
7936  error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7937  return token_type::parse_error;
7938  }
7939 
7940  case 0x18:
7941  {
7942  error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7943  return token_type::parse_error;
7944  }
7945 
7946  case 0x19:
7947  {
7948  error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7949  return token_type::parse_error;
7950  }
7951 
7952  case 0x1A:
7953  {
7954  error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7955  return token_type::parse_error;
7956  }
7957 
7958  case 0x1B:
7959  {
7960  error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7961  return token_type::parse_error;
7962  }
7963 
7964  case 0x1C:
7965  {
7966  error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
7967  return token_type::parse_error;
7968  }
7969 
7970  case 0x1D:
7971  {
7972  error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
7973  return token_type::parse_error;
7974  }
7975 
7976  case 0x1E:
7977  {
7978  error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
7979  return token_type::parse_error;
7980  }
7981 
7982  case 0x1F:
7983  {
7984  error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
7985  return token_type::parse_error;
7986  }
7987 
7988  // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
7989  case 0x20:
7990  case 0x21:
7991  case 0x23:
7992  case 0x24:
7993  case 0x25:
7994  case 0x26:
7995  case 0x27:
7996  case 0x28:
7997  case 0x29:
7998  case 0x2A:
7999  case 0x2B:
8000  case 0x2C:
8001  case 0x2D:
8002  case 0x2E:
8003  case 0x2F:
8004  case 0x30:
8005  case 0x31:
8006  case 0x32:
8007  case 0x33:
8008  case 0x34:
8009  case 0x35:
8010  case 0x36:
8011  case 0x37:
8012  case 0x38:
8013  case 0x39:
8014  case 0x3A:
8015  case 0x3B:
8016  case 0x3C:
8017  case 0x3D:
8018  case 0x3E:
8019  case 0x3F:
8020  case 0x40:
8021  case 0x41:
8022  case 0x42:
8023  case 0x43:
8024  case 0x44:
8025  case 0x45:
8026  case 0x46:
8027  case 0x47:
8028  case 0x48:
8029  case 0x49:
8030  case 0x4A:
8031  case 0x4B:
8032  case 0x4C:
8033  case 0x4D:
8034  case 0x4E:
8035  case 0x4F:
8036  case 0x50:
8037  case 0x51:
8038  case 0x52:
8039  case 0x53:
8040  case 0x54:
8041  case 0x55:
8042  case 0x56:
8043  case 0x57:
8044  case 0x58:
8045  case 0x59:
8046  case 0x5A:
8047  case 0x5B:
8048  case 0x5D:
8049  case 0x5E:
8050  case 0x5F:
8051  case 0x60:
8052  case 0x61:
8053  case 0x62:
8054  case 0x63:
8055  case 0x64:
8056  case 0x65:
8057  case 0x66:
8058  case 0x67:
8059  case 0x68:
8060  case 0x69:
8061  case 0x6A:
8062  case 0x6B:
8063  case 0x6C:
8064  case 0x6D:
8065  case 0x6E:
8066  case 0x6F:
8067  case 0x70:
8068  case 0x71:
8069  case 0x72:
8070  case 0x73:
8071  case 0x74:
8072  case 0x75:
8073  case 0x76:
8074  case 0x77:
8075  case 0x78:
8076  case 0x79:
8077  case 0x7A:
8078  case 0x7B:
8079  case 0x7C:
8080  case 0x7D:
8081  case 0x7E:
8082  case 0x7F:
8083  {
8084  add(current);
8085  break;
8086  }
8087 
8088  // U+0080..U+07FF: bytes C2..DF 80..BF
8089  case 0xC2:
8090  case 0xC3:
8091  case 0xC4:
8092  case 0xC5:
8093  case 0xC6:
8094  case 0xC7:
8095  case 0xC8:
8096  case 0xC9:
8097  case 0xCA:
8098  case 0xCB:
8099  case 0xCC:
8100  case 0xCD:
8101  case 0xCE:
8102  case 0xCF:
8103  case 0xD0:
8104  case 0xD1:
8105  case 0xD2:
8106  case 0xD3:
8107  case 0xD4:
8108  case 0xD5:
8109  case 0xD6:
8110  case 0xD7:
8111  case 0xD8:
8112  case 0xD9:
8113  case 0xDA:
8114  case 0xDB:
8115  case 0xDC:
8116  case 0xDD:
8117  case 0xDE:
8118  case 0xDF:
8119  {
8120  if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({ 0x80, 0xBF })))
8121  {
8122  return token_type::parse_error;
8123  }
8124  break;
8125  }
8126 
8127  // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
8128  case 0xE0:
8129  {
8130  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({ 0xA0, 0xBF, 0x80, 0xBF }))))
8131  {
8132  return token_type::parse_error;
8133  }
8134  break;
8135  }
8136 
8137  // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
8138  // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
8139  case 0xE1:
8140  case 0xE2:
8141  case 0xE3:
8142  case 0xE4:
8143  case 0xE5:
8144  case 0xE6:
8145  case 0xE7:
8146  case 0xE8:
8147  case 0xE9:
8148  case 0xEA:
8149  case 0xEB:
8150  case 0xEC:
8151  case 0xEE:
8152  case 0xEF:
8153  {
8154  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({ 0x80, 0xBF, 0x80, 0xBF }))))
8155  {
8156  return token_type::parse_error;
8157  }
8158  break;
8159  }
8160 
8161  // U+D000..U+D7FF: bytes ED 80..9F 80..BF
8162  case 0xED:
8163  {
8164  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({ 0x80, 0x9F, 0x80, 0xBF }))))
8165  {
8166  return token_type::parse_error;
8167  }
8168  break;
8169  }
8170 
8171  // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
8172  case 0xF0:
8173  {
8174  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({ 0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF }))))
8175  {
8176  return token_type::parse_error;
8177  }
8178  break;
8179  }
8180 
8181  // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
8182  case 0xF1:
8183  case 0xF2:
8184  case 0xF3:
8185  {
8186  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({ 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF }))))
8187  {
8188  return token_type::parse_error;
8189  }
8190  break;
8191  }
8192 
8193  // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
8194  case 0xF4:
8195  {
8196  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({ 0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF }))))
8197  {
8198  return token_type::parse_error;
8199  }
8200  break;
8201  }
8202 
8203  // remaining bytes (80..C1 and F5..FF) are ill-formed
8204  default:
8205  {
8206  error_message = "invalid string: ill-formed UTF-8 byte";
8207  return token_type::parse_error;
8208  }
8209  }
8210  }
8211  }
8212 
8217  bool scan_comment()
8218  {
8219  switch (get())
8220  {
8221  // single-line comments skip input until a newline or EOF is read
8222  case '/':
8223  {
8224  while (true)
8225  {
8226  switch (get())
8227  {
8228  case '\n':
8229  case '\r':
8230  case char_traits<char_type>::eof():
8231  case '\0':
8232  return true;
8233 
8234  default:
8235  break;
8236  }
8237  }
8238  }
8239 
8240  // multi-line comments skip input until */ is read
8241  case '*':
8242  {
8243  while (true)
8244  {
8245  switch (get())
8246  {
8247  case char_traits<char_type>::eof():
8248  case '\0':
8249  {
8250  error_message = "invalid comment; missing closing '*/'";
8251  return false;
8252  }
8253 
8254  case '*':
8255  {
8256  switch (get())
8257  {
8258  case '/':
8259  return true;
8260 
8261  default:
8262  {
8263  unget();
8264  continue;
8265  }
8266  }
8267  }
8268 
8269  default:
8270  continue;
8271  }
8272  }
8273  }
8274 
8275  // unexpected character after reading '/'
8276  default:
8277  {
8278  error_message = "invalid comment; expecting '/' or '*' after '/'";
8279  return false;
8280  }
8281  }
8282  }
8283 
8284  JSON_HEDLEY_NON_NULL(2)
8285  static void strtof(float& f, const char* str, char** endptr) noexcept
8286  {
8287  f = std::strtof(str, endptr);
8288  }
8289 
8290  JSON_HEDLEY_NON_NULL(2)
8291  static void strtof(double& f, const char* str, char** endptr) noexcept
8292  {
8293  f = std::strtod(str, endptr);
8294  }
8295 
8296  JSON_HEDLEY_NON_NULL(2)
8297  static void strtof(long double& f, const char* str, char** endptr) noexcept
8298  {
8299  f = std::strtold(str, endptr);
8300  }
8301 
8342  token_type scan_number() // lgtm [cpp/use-of-goto]
8343  {
8344  // reset token_buffer to store the number's bytes
8345  reset();
8346 
8347  // the type of the parsed number; initially set to unsigned; will be
8348  // changed if minus sign, decimal point or exponent is read
8349  token_type number_type = token_type::value_unsigned;
8350 
8351  // state (init): we just found out we need to scan a number
8352  switch (current)
8353  {
8354  case '-':
8355  {
8356  add(current);
8357  goto scan_number_minus;
8358  }
8359 
8360  case '0':
8361  {
8362  add(current);
8363  goto scan_number_zero;
8364  }
8365 
8366  case '1':
8367  case '2':
8368  case '3':
8369  case '4':
8370  case '5':
8371  case '6':
8372  case '7':
8373  case '8':
8374  case '9':
8375  {
8376  add(current);
8377  goto scan_number_any1;
8378  }
8379 
8380  // all other characters are rejected outside scan_number()
8381  default: // LCOV_EXCL_LINE
8382  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
8383  }
8384 
8385  scan_number_minus:
8386  // state: we just parsed a leading minus sign
8387  number_type = token_type::value_integer;
8388  switch (get())
8389  {
8390  case '0':
8391  {
8392  add(current);
8393  goto scan_number_zero;
8394  }
8395 
8396  case '1':
8397  case '2':
8398  case '3':
8399  case '4':
8400  case '5':
8401  case '6':
8402  case '7':
8403  case '8':
8404  case '9':
8405  {
8406  add(current);
8407  goto scan_number_any1;
8408  }
8409 
8410  default:
8411  {
8412  error_message = "invalid number; expected digit after '-'";
8413  return token_type::parse_error;
8414  }
8415  }
8416 
8417  scan_number_zero:
8418  // state: we just parse a zero (maybe with a leading minus sign)
8419  switch (get())
8420  {
8421  case '.':
8422  {
8423  add(decimal_point_char);
8424  goto scan_number_decimal1;
8425  }
8426 
8427  case 'e':
8428  case 'E':
8429  {
8430  add(current);
8431  goto scan_number_exponent;
8432  }
8433 
8434  default:
8435  goto scan_number_done;
8436  }
8437 
8438  scan_number_any1:
8439  // state: we just parsed a number 0-9 (maybe with a leading minus sign)
8440  switch (get())
8441  {
8442  case '0':
8443  case '1':
8444  case '2':
8445  case '3':
8446  case '4':
8447  case '5':
8448  case '6':
8449  case '7':
8450  case '8':
8451  case '9':
8452  {
8453  add(current);
8454  goto scan_number_any1;
8455  }
8456 
8457  case '.':
8458  {
8459  add(decimal_point_char);
8460  goto scan_number_decimal1;
8461  }
8462 
8463  case 'e':
8464  case 'E':
8465  {
8466  add(current);
8467  goto scan_number_exponent;
8468  }
8469 
8470  default:
8471  goto scan_number_done;
8472  }
8473 
8474  scan_number_decimal1:
8475  // state: we just parsed a decimal point
8476  number_type = token_type::value_float;
8477  switch (get())
8478  {
8479  case '0':
8480  case '1':
8481  case '2':
8482  case '3':
8483  case '4':
8484  case '5':
8485  case '6':
8486  case '7':
8487  case '8':
8488  case '9':
8489  {
8490  add(current);
8491  goto scan_number_decimal2;
8492  }
8493 
8494  default:
8495  {
8496  error_message = "invalid number; expected digit after '.'";
8497  return token_type::parse_error;
8498  }
8499  }
8500 
8501  scan_number_decimal2:
8502  // we just parsed at least one number after a decimal point
8503  switch (get())
8504  {
8505  case '0':
8506  case '1':
8507  case '2':
8508  case '3':
8509  case '4':
8510  case '5':
8511  case '6':
8512  case '7':
8513  case '8':
8514  case '9':
8515  {
8516  add(current);
8517  goto scan_number_decimal2;
8518  }
8519 
8520  case 'e':
8521  case 'E':
8522  {
8523  add(current);
8524  goto scan_number_exponent;
8525  }
8526 
8527  default:
8528  goto scan_number_done;
8529  }
8530 
8531  scan_number_exponent:
8532  // we just parsed an exponent
8533  number_type = token_type::value_float;
8534  switch (get())
8535  {
8536  case '+':
8537  case '-':
8538  {
8539  add(current);
8540  goto scan_number_sign;
8541  }
8542 
8543  case '0':
8544  case '1':
8545  case '2':
8546  case '3':
8547  case '4':
8548  case '5':
8549  case '6':
8550  case '7':
8551  case '8':
8552  case '9':
8553  {
8554  add(current);
8555  goto scan_number_any2;
8556  }
8557 
8558  default:
8559  {
8560  error_message =
8561  "invalid number; expected '+', '-', or digit after exponent";
8562  return token_type::parse_error;
8563  }
8564  }
8565 
8566  scan_number_sign:
8567  // we just parsed an exponent sign
8568  switch (get())
8569  {
8570  case '0':
8571  case '1':
8572  case '2':
8573  case '3':
8574  case '4':
8575  case '5':
8576  case '6':
8577  case '7':
8578  case '8':
8579  case '9':
8580  {
8581  add(current);
8582  goto scan_number_any2;
8583  }
8584 
8585  default:
8586  {
8587  error_message = "invalid number; expected digit after exponent sign";
8588  return token_type::parse_error;
8589  }
8590  }
8591 
8592  scan_number_any2:
8593  // we just parsed a number after the exponent or exponent sign
8594  switch (get())
8595  {
8596  case '0':
8597  case '1':
8598  case '2':
8599  case '3':
8600  case '4':
8601  case '5':
8602  case '6':
8603  case '7':
8604  case '8':
8605  case '9':
8606  {
8607  add(current);
8608  goto scan_number_any2;
8609  }
8610 
8611  default:
8612  goto scan_number_done;
8613  }
8614 
8615  scan_number_done:
8616  // unget the character after the number (we only read it to know that
8617  // we are done scanning a number)
8618  unget();
8619 
8620  char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8621  errno = 0;
8622 
8623  // try to parse integers first and fall back to floats
8624  if (number_type == token_type::value_unsigned)
8625  {
8626  const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
8627 
8628  // we checked the number format before
8629  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
8630 
8631  if (errno == 0)
8632  {
8633  value_unsigned = static_cast<number_unsigned_t>(x);
8634  if (value_unsigned == x)
8635  {
8636  return token_type::value_unsigned;
8637  }
8638  }
8639  }
8640  else if (number_type == token_type::value_integer)
8641  {
8642  const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
8643 
8644  // we checked the number format before
8645  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
8646 
8647  if (errno == 0)
8648  {
8649  value_integer = static_cast<number_integer_t>(x);
8650  if (value_integer == x)
8651  {
8652  return token_type::value_integer;
8653  }
8654  }
8655  }
8656 
8657  // this code is reached if we parse a floating-point number or if an
8658  // integer conversion above failed
8659  strtof(value_float, token_buffer.data(), &endptr);
8660 
8661  // we checked the number format before
8662  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
8663 
8664  return token_type::value_float;
8665  }
8666 
8672  JSON_HEDLEY_NON_NULL(2)
8673  token_type scan_literal(const char_type* literal_text, const std::size_t length,
8674  token_type return_type)
8675  {
8676  JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
8677  for (std::size_t i = 1; i < length; ++i)
8678  {
8679  if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
8680  {
8681  error_message = "invalid literal";
8682  return token_type::parse_error;
8683  }
8684  }
8685  return return_type;
8686  }
8687 
8689  // input management
8691 
8693  void reset() noexcept
8694  {
8695  token_buffer.clear();
8696  token_string.clear();
8697  token_string.push_back(char_traits<char_type>::to_char_type(current));
8698  }
8699 
8700  /*
8701  @brief get next character from the input
8702 
8703  This function provides the interface to the used input adapter. It does
8704  not throw in case the input reached EOF, but returns a
8705  `char_traits<char>::eof()` in that case. Stores the scanned characters
8706  for use in error messages.
8707 
8708  @return character read from the input
8709  */
8710  char_int_type get()
8711  {
8712  ++position.chars_read_total;
8713  ++position.chars_read_current_line;
8714 
8715  if (next_unget)
8716  {
8717  // just reset the next_unget variable and work with current
8718  next_unget = false;
8719  }
8720  else
8721  {
8722  current = ia.get_character();
8723  }
8724 
8725  if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
8726  {
8727  token_string.push_back(char_traits<char_type>::to_char_type(current));
8728  }
8729 
8730  if (current == '\n')
8731  {
8732  ++position.lines_read;
8733  position.chars_read_current_line = 0;
8734  }
8735 
8736  return current;
8737  }
8738 
8747  void unget()
8748  {
8749  next_unget = true;
8750 
8751  --position.chars_read_total;
8752 
8753  // in case we "unget" a newline, we have to also decrement the lines_read
8754  if (position.chars_read_current_line == 0)
8755  {
8756  if (position.lines_read > 0)
8757  {
8758  --position.lines_read;
8759  }
8760  }
8761  else
8762  {
8763  --position.chars_read_current_line;
8764  }
8765 
8766  if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
8767  {
8768  JSON_ASSERT(!token_string.empty());
8769  token_string.pop_back();
8770  }
8771  }
8772 
8774  void add(char_int_type c)
8775  {
8776  token_buffer.push_back(static_cast<typename string_t::value_type>(c));
8777  }
8778 
8779  public:
8781  // value getters
8783 
8785  constexpr number_integer_t get_number_integer() const noexcept
8786  {
8787  return value_integer;
8788  }
8789 
8791  constexpr number_unsigned_t get_number_unsigned() const noexcept
8792  {
8793  return value_unsigned;
8794  }
8795 
8797  constexpr number_float_t get_number_float() const noexcept
8798  {
8799  return value_float;
8800  }
8801 
8803  string_t& get_string()
8804  {
8805  return token_buffer;
8806  }
8807 
8809  // diagnostics
8811 
8813  constexpr position_t get_position() const noexcept
8814  {
8815  return position;
8816  }
8817 
8821  std::string get_token_string() const
8822  {
8823  // escape control characters
8824  std::string result;
8825  for (const auto c : token_string)
8826  {
8827  if (static_cast<unsigned char>(c) <= '\x1F')
8828  {
8829  // escape control characters
8830  std::array<char, 9> cs{ {} };
8831  static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8832  result += cs.data();
8833  }
8834  else
8835  {
8836  // add character as is
8837  result.push_back(static_cast<std::string::value_type>(c));
8838  }
8839  }
8840 
8841  return result;
8842  }
8843 
8845  JSON_HEDLEY_RETURNS_NON_NULL
8846  constexpr const char* get_error_message() const noexcept
8847  {
8848  return error_message;
8849  }
8850 
8852  // actual scanner
8854 
8859  bool skip_bom()
8860  {
8861  if (get() == 0xEF)
8862  {
8863  // check if we completely parse the BOM
8864  return get() == 0xBB && get() == 0xBF;
8865  }
8866 
8867  // the first character is not the beginning of the BOM; unget it to
8868  // process is later
8869  unget();
8870  return true;
8871  }
8872 
8873  void skip_whitespace()
8874  {
8875  do
8876  {
8877  get();
8878  } while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
8879  }
8880 
8881  token_type scan()
8882  {
8883  // initially, skip the BOM
8884  if (position.chars_read_total == 0 && !skip_bom())
8885  {
8886  error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
8887  return token_type::parse_error;
8888  }
8889 
8890  // read next character and ignore whitespace
8891  skip_whitespace();
8892 
8893  // ignore comments
8894  while (ignore_comments && current == '/')
8895  {
8896  if (!scan_comment())
8897  {
8898  return token_type::parse_error;
8899  }
8900 
8901  // skip following whitespace
8902  skip_whitespace();
8903  }
8904 
8905  switch (current)
8906  {
8907  // structural characters
8908  case '[':
8909  return token_type::begin_array;
8910  case ']':
8911  return token_type::end_array;
8912  case '{':
8913  return token_type::begin_object;
8914  case '}':
8915  return token_type::end_object;
8916  case ':':
8917  return token_type::name_separator;
8918  case ',':
8919  return token_type::value_separator;
8920 
8921  // literals
8922  case 't':
8923  {
8924  std::array<char_type, 4> true_literal = { {static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')} };
8925  return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
8926  }
8927  case 'f':
8928  {
8929  std::array<char_type, 5> false_literal = { {static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')} };
8930  return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
8931  }
8932  case 'n':
8933  {
8934  std::array<char_type, 4> null_literal = { {static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')} };
8935  return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
8936  }
8937 
8938  // string
8939  case '\"':
8940  return scan_string();
8941 
8942  // number
8943  case '-':
8944  case '0':
8945  case '1':
8946  case '2':
8947  case '3':
8948  case '4':
8949  case '5':
8950  case '6':
8951  case '7':
8952  case '8':
8953  case '9':
8954  return scan_number();
8955 
8956  // end of input (the null byte is needed when parsing from
8957  // string literals)
8958  case '\0':
8959  case char_traits<char_type>::eof():
8960  return token_type::end_of_input;
8961 
8962  // error
8963  default:
8964  error_message = "invalid literal";
8965  return token_type::parse_error;
8966  }
8967  }
8968 
8969  private:
8971  InputAdapterType ia;
8972 
8974  const bool ignore_comments = false;
8975 
8977  char_int_type current = char_traits<char_type>::eof();
8978 
8980  bool next_unget = false;
8981 
8983  position_t position{};
8984 
8986  std::vector<char_type> token_string{};
8987 
8989  string_t token_buffer{};
8990 
8992  const char* error_message = "";
8993 
8994  // number values
8995  number_integer_t value_integer = 0;
8996  number_unsigned_t value_unsigned = 0;
8997  number_float_t value_float = 0;
8998 
9000  const char_int_type decimal_point_char = '.';
9001  };
9002 
9003 } // namespace detail
9004 NLOHMANN_JSON_NAMESPACE_END
9005 
9006 // #include <nlohmann/detail/macro_scope.hpp>
9007 
9008 // #include <nlohmann/detail/meta/is_sax.hpp>
9009 // __ _____ _____ _____
9010 // __| | __| | | | JSON for Modern C++
9011 // | | |__ | | | | | | version 3.11.3
9012 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
9013 //
9014 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
9015 // SPDX-License-Identifier: MIT
9016 
9017 
9018 
9019 #include <cstdint> // size_t
9020 #include <utility> // declval
9021 #include <string> // string
9022 
9023 // #include <nlohmann/detail/abi_macros.hpp>
9024 
9025 // #include <nlohmann/detail/meta/detected.hpp>
9026 
9027 // #include <nlohmann/detail/meta/type_traits.hpp>
9028 
9029 
9030 NLOHMANN_JSON_NAMESPACE_BEGIN
9031 namespace detail
9032 {
9033 
9034  template<typename T>
9035  using null_function_t = decltype(std::declval<T&>().null());
9036 
9037  template<typename T>
9038  using boolean_function_t =
9039  decltype(std::declval<T&>().boolean(std::declval<bool>()));
9040 
9041  template<typename T, typename Integer>
9042  using number_integer_function_t =
9043  decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
9044 
9045  template<typename T, typename Unsigned>
9046  using number_unsigned_function_t =
9047  decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
9048 
9049  template<typename T, typename Float, typename String>
9050  using number_float_function_t = decltype(std::declval<T&>().number_float(
9051  std::declval<Float>(), std::declval<const String&>()));
9052 
9053  template<typename T, typename String>
9054  using string_function_t =
9055  decltype(std::declval<T&>().string(std::declval<String&>()));
9056 
9057  template<typename T, typename Binary>
9058  using binary_function_t =
9059  decltype(std::declval<T&>().binary(std::declval<Binary&>()));
9060 
9061  template<typename T>
9062  using start_object_function_t =
9063  decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
9064 
9065  template<typename T, typename String>
9066  using key_function_t =
9067  decltype(std::declval<T&>().key(std::declval<String&>()));
9068 
9069  template<typename T>
9070  using end_object_function_t = decltype(std::declval<T&>().end_object());
9071 
9072  template<typename T>
9073  using start_array_function_t =
9074  decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
9075 
9076  template<typename T>
9077  using end_array_function_t = decltype(std::declval<T&>().end_array());
9078 
9079  template<typename T, typename Exception>
9080  using parse_error_function_t = decltype(std::declval<T&>().parse_error(
9081  std::declval<std::size_t>(), std::declval<const std::string&>(),
9082  std::declval<const Exception&>()));
9083 
9084  template<typename SAX, typename BasicJsonType>
9085  struct is_sax
9086  {
9087  private:
9088  static_assert(is_basic_json<BasicJsonType>::value,
9089  "BasicJsonType must be of type basic_json<...>");
9090 
9091  using number_integer_t = typename BasicJsonType::number_integer_t;
9092  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9093  using number_float_t = typename BasicJsonType::number_float_t;
9094  using string_t = typename BasicJsonType::string_t;
9095  using binary_t = typename BasicJsonType::binary_t;
9096  using exception_t = typename BasicJsonType::exception;
9097 
9098  public:
9099  static constexpr bool value =
9100  is_detected_exact<bool, null_function_t, SAX>::value&&
9101  is_detected_exact<bool, boolean_function_t, SAX>::value&&
9102  is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value&&
9103  is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value&&
9104  is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value&&
9105  is_detected_exact<bool, string_function_t, SAX, string_t>::value&&
9106  is_detected_exact<bool, binary_function_t, SAX, binary_t>::value&&
9107  is_detected_exact<bool, start_object_function_t, SAX>::value&&
9108  is_detected_exact<bool, key_function_t, SAX, string_t>::value&&
9109  is_detected_exact<bool, end_object_function_t, SAX>::value&&
9110  is_detected_exact<bool, start_array_function_t, SAX>::value&&
9111  is_detected_exact<bool, end_array_function_t, SAX>::value&&
9112  is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
9113  };
9114 
9115  template<typename SAX, typename BasicJsonType>
9116  struct is_sax_static_asserts
9117  {
9118  private:
9119  static_assert(is_basic_json<BasicJsonType>::value,
9120  "BasicJsonType must be of type basic_json<...>");
9121 
9122  using number_integer_t = typename BasicJsonType::number_integer_t;
9123  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9124  using number_float_t = typename BasicJsonType::number_float_t;
9125  using string_t = typename BasicJsonType::string_t;
9126  using binary_t = typename BasicJsonType::binary_t;
9127  using exception_t = typename BasicJsonType::exception;
9128 
9129  public:
9130  static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
9131  "Missing/invalid function: bool null()");
9132  static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
9133  "Missing/invalid function: bool boolean(bool)");
9134  static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
9135  "Missing/invalid function: bool boolean(bool)");
9136  static_assert(
9137  is_detected_exact<bool, number_integer_function_t, SAX,
9138  number_integer_t>::value,
9139  "Missing/invalid function: bool number_integer(number_integer_t)");
9140  static_assert(
9141  is_detected_exact<bool, number_unsigned_function_t, SAX,
9142  number_unsigned_t>::value,
9143  "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
9144  static_assert(is_detected_exact<bool, number_float_function_t, SAX,
9145  number_float_t, string_t>::value,
9146  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
9147  static_assert(
9148  is_detected_exact<bool, string_function_t, SAX, string_t>::value,
9149  "Missing/invalid function: bool string(string_t&)");
9150  static_assert(
9151  is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
9152  "Missing/invalid function: bool binary(binary_t&)");
9153  static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
9154  "Missing/invalid function: bool start_object(std::size_t)");
9155  static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
9156  "Missing/invalid function: bool key(string_t&)");
9157  static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
9158  "Missing/invalid function: bool end_object()");
9159  static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
9160  "Missing/invalid function: bool start_array(std::size_t)");
9161  static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
9162  "Missing/invalid function: bool end_array()");
9163  static_assert(
9164  is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
9165  "Missing/invalid function: bool parse_error(std::size_t, const "
9166  "std::string&, const exception&)");
9167  };
9168 
9169 } // namespace detail
9170 NLOHMANN_JSON_NAMESPACE_END
9171 
9172 // #include <nlohmann/detail/meta/type_traits.hpp>
9173 
9174 // #include <nlohmann/detail/string_concat.hpp>
9175 
9176 // #include <nlohmann/detail/value_t.hpp>
9177 
9178 
9179 NLOHMANN_JSON_NAMESPACE_BEGIN
9180 namespace detail
9181 {
9182 
9184  enum class cbor_tag_handler_t
9185  {
9186  error,
9187  ignore,
9188  store
9189  };
9190 
9198  static inline bool little_endianness(int num = 1) noexcept
9199  {
9200  return *reinterpret_cast<char*>(&num) == 1;
9201  }
9202 
9204  // binary reader //
9206 
9210  template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
9211  class binary_reader
9212  {
9213  using number_integer_t = typename BasicJsonType::number_integer_t;
9214  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9215  using number_float_t = typename BasicJsonType::number_float_t;
9216  using string_t = typename BasicJsonType::string_t;
9217  using binary_t = typename BasicJsonType::binary_t;
9218  using json_sax_t = SAX;
9219  using char_type = typename InputAdapterType::char_type;
9220  using char_int_type = typename char_traits<char_type>::int_type;
9221 
9222  public:
9228  explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
9229  {
9230  (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
9231  }
9232 
9233  // make class move-only
9234  binary_reader(const binary_reader&) = delete;
9235  binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
9236  binary_reader& operator=(const binary_reader&) = delete;
9237  binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
9238  ~binary_reader() = default;
9239 
9248  JSON_HEDLEY_NON_NULL(3)
9249  bool sax_parse(const input_format_t format,
9250  json_sax_t* sax_,
9251  const bool strict = true,
9252  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
9253  {
9254  sax = sax_;
9255  bool result = false;
9256 
9257  switch (format)
9258  {
9259  case input_format_t::bson:
9260  result = parse_bson_internal();
9261  break;
9262 
9263  case input_format_t::cbor:
9264  result = parse_cbor_internal(true, tag_handler);
9265  break;
9266 
9267  case input_format_t::msgpack:
9268  result = parse_msgpack_internal();
9269  break;
9270 
9271  case input_format_t::ubjson:
9272  case input_format_t::bjdata:
9273  result = parse_ubjson_internal();
9274  break;
9275 
9276  case input_format_t::json: // LCOV_EXCL_LINE
9277  default: // LCOV_EXCL_LINE
9278  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
9279  }
9280 
9281  // strict mode: next byte must be EOF
9282  if (result && strict)
9283  {
9284  if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
9285  {
9286  get_ignore_noop();
9287  }
9288  else
9289  {
9290  get();
9291  }
9292 
9293  if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
9294  {
9295  return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
9296  exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
9297  }
9298  }
9299 
9300  return result;
9301  }
9302 
9303  private:
9305  // BSON //
9307 
9312  bool parse_bson_internal()
9313  {
9314  std::int32_t document_size{};
9315  get_number<std::int32_t, true>(input_format_t::bson, document_size);
9316 
9317  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
9318  {
9319  return false;
9320  }
9321 
9322  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
9323  {
9324  return false;
9325  }
9326 
9327  return sax->end_object();
9328  }
9329 
9337  bool get_bson_cstr(string_t& result)
9338  {
9339  auto out = std::back_inserter(result);
9340  while (true)
9341  {
9342  get();
9343  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
9344  {
9345  return false;
9346  }
9347  if (current == 0x00)
9348  {
9349  return true;
9350  }
9351  *out++ = static_cast<typename string_t::value_type>(current);
9352  }
9353  }
9354 
9366  template<typename NumberType>
9367  bool get_bson_string(const NumberType len, string_t& result)
9368  {
9369  if (JSON_HEDLEY_UNLIKELY(len < 1))
9370  {
9371  auto last_token = get_token_string();
9372  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
9373  exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
9374  }
9375 
9376  return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
9377  }
9378 
9388  template<typename NumberType>
9389  bool get_bson_binary(const NumberType len, binary_t& result)
9390  {
9391  if (JSON_HEDLEY_UNLIKELY(len < 0))
9392  {
9393  auto last_token = get_token_string();
9394  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
9395  exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
9396  }
9397 
9398  // All BSON binary values have a subtype
9399  std::uint8_t subtype{};
9400  get_number<std::uint8_t>(input_format_t::bson, subtype);
9401  result.set_subtype(subtype);
9402 
9403  return get_binary(input_format_t::bson, len, result);
9404  }
9405 
9416  bool parse_bson_element_internal(const char_int_type element_type,
9417  const std::size_t element_type_parse_position)
9418  {
9419  switch (element_type)
9420  {
9421  case 0x01: // double
9422  {
9423  double number{};
9424  return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
9425  }
9426 
9427  case 0x02: // string
9428  {
9429  std::int32_t len{};
9430  string_t value;
9431  return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
9432  }
9433 
9434  case 0x03: // object
9435  {
9436  return parse_bson_internal();
9437  }
9438 
9439  case 0x04: // array
9440  {
9441  return parse_bson_array();
9442  }
9443 
9444  case 0x05: // binary
9445  {
9446  std::int32_t len{};
9447  binary_t value;
9448  return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
9449  }
9450 
9451  case 0x08: // boolean
9452  {
9453  return sax->boolean(get() != 0);
9454  }
9455 
9456  case 0x0A: // null
9457  {
9458  return sax->null();
9459  }
9460 
9461  case 0x10: // int32
9462  {
9463  std::int32_t value{};
9464  return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
9465  }
9466 
9467  case 0x12: // int64
9468  {
9469  std::int64_t value{};
9470  return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
9471  }
9472 
9473  default: // anything else not supported (yet)
9474  {
9475  std::array<char, 3> cr{ {} };
9476  static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
9477  const std::string cr_str{ cr.data() };
9478  return sax->parse_error(element_type_parse_position, cr_str,
9479  parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
9480  }
9481  }
9482  }
9483 
9496  bool parse_bson_element_list(const bool is_array)
9497  {
9498  string_t key;
9499 
9500  while (auto element_type = get())
9501  {
9502  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
9503  {
9504  return false;
9505  }
9506 
9507  const std::size_t element_type_parse_position = chars_read;
9508  if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
9509  {
9510  return false;
9511  }
9512 
9513  if (!is_array && !sax->key(key))
9514  {
9515  return false;
9516  }
9517 
9518  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
9519  {
9520  return false;
9521  }
9522 
9523  // get_bson_cstr only appends
9524  key.clear();
9525  }
9526 
9527  return true;
9528  }
9529 
9534  bool parse_bson_array()
9535  {
9536  std::int32_t document_size{};
9537  get_number<std::int32_t, true>(input_format_t::bson, document_size);
9538 
9539  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
9540  {
9541  return false;
9542  }
9543 
9544  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
9545  {
9546  return false;
9547  }
9548 
9549  return sax->end_array();
9550  }
9551 
9553  // CBOR //
9555 
9564  bool parse_cbor_internal(const bool get_char,
9565  const cbor_tag_handler_t tag_handler)
9566  {
9567  switch (get_char ? get() : current)
9568  {
9569  // EOF
9570  case char_traits<char_type>::eof():
9571  return unexpect_eof(input_format_t::cbor, "value");
9572 
9573  // Integer 0x00..0x17 (0..23)
9574  case 0x00:
9575  case 0x01:
9576  case 0x02:
9577  case 0x03:
9578  case 0x04:
9579  case 0x05:
9580  case 0x06:
9581  case 0x07:
9582  case 0x08:
9583  case 0x09:
9584  case 0x0A:
9585  case 0x0B:
9586  case 0x0C:
9587  case 0x0D:
9588  case 0x0E:
9589  case 0x0F:
9590  case 0x10:
9591  case 0x11:
9592  case 0x12:
9593  case 0x13:
9594  case 0x14:
9595  case 0x15:
9596  case 0x16:
9597  case 0x17:
9598  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
9599 
9600  case 0x18: // Unsigned integer (one-byte uint8_t follows)
9601  {
9602  std::uint8_t number{};
9603  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
9604  }
9605 
9606  case 0x19: // Unsigned integer (two-byte uint16_t follows)
9607  {
9608  std::uint16_t number{};
9609  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
9610  }
9611 
9612  case 0x1A: // Unsigned integer (four-byte uint32_t follows)
9613  {
9614  std::uint32_t number{};
9615  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
9616  }
9617 
9618  case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
9619  {
9620  std::uint64_t number{};
9621  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
9622  }
9623 
9624  // Negative integer -1-0x00..-1-0x17 (-1..-24)
9625  case 0x20:
9626  case 0x21:
9627  case 0x22:
9628  case 0x23:
9629  case 0x24:
9630  case 0x25:
9631  case 0x26:
9632  case 0x27:
9633  case 0x28:
9634  case 0x29:
9635  case 0x2A:
9636  case 0x2B:
9637  case 0x2C:
9638  case 0x2D:
9639  case 0x2E:
9640  case 0x2F:
9641  case 0x30:
9642  case 0x31:
9643  case 0x32:
9644  case 0x33:
9645  case 0x34:
9646  case 0x35:
9647  case 0x36:
9648  case 0x37:
9649  return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
9650 
9651  case 0x38: // Negative integer (one-byte uint8_t follows)
9652  {
9653  std::uint8_t number{};
9654  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
9655  }
9656 
9657  case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
9658  {
9659  std::uint16_t number{};
9660  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
9661  }
9662 
9663  case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
9664  {
9665  std::uint32_t number{};
9666  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
9667  }
9668 
9669  case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
9670  {
9671  std::uint64_t number{};
9672  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
9673  - static_cast<number_integer_t>(number));
9674  }
9675 
9676  // Binary data (0x00..0x17 bytes follow)
9677  case 0x40:
9678  case 0x41:
9679  case 0x42:
9680  case 0x43:
9681  case 0x44:
9682  case 0x45:
9683  case 0x46:
9684  case 0x47:
9685  case 0x48:
9686  case 0x49:
9687  case 0x4A:
9688  case 0x4B:
9689  case 0x4C:
9690  case 0x4D:
9691  case 0x4E:
9692  case 0x4F:
9693  case 0x50:
9694  case 0x51:
9695  case 0x52:
9696  case 0x53:
9697  case 0x54:
9698  case 0x55:
9699  case 0x56:
9700  case 0x57:
9701  case 0x58: // Binary data (one-byte uint8_t for n follows)
9702  case 0x59: // Binary data (two-byte uint16_t for n follow)
9703  case 0x5A: // Binary data (four-byte uint32_t for n follow)
9704  case 0x5B: // Binary data (eight-byte uint64_t for n follow)
9705  case 0x5F: // Binary data (indefinite length)
9706  {
9707  binary_t b;
9708  return get_cbor_binary(b) && sax->binary(b);
9709  }
9710 
9711  // UTF-8 string (0x00..0x17 bytes follow)
9712  case 0x60:
9713  case 0x61:
9714  case 0x62:
9715  case 0x63:
9716  case 0x64:
9717  case 0x65:
9718  case 0x66:
9719  case 0x67:
9720  case 0x68:
9721  case 0x69:
9722  case 0x6A:
9723  case 0x6B:
9724  case 0x6C:
9725  case 0x6D:
9726  case 0x6E:
9727  case 0x6F:
9728  case 0x70:
9729  case 0x71:
9730  case 0x72:
9731  case 0x73:
9732  case 0x74:
9733  case 0x75:
9734  case 0x76:
9735  case 0x77:
9736  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
9737  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
9738  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
9739  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
9740  case 0x7F: // UTF-8 string (indefinite length)
9741  {
9742  string_t s;
9743  return get_cbor_string(s) && sax->string(s);
9744  }
9745 
9746  // array (0x00..0x17 data items follow)
9747  case 0x80:
9748  case 0x81:
9749  case 0x82:
9750  case 0x83:
9751  case 0x84:
9752  case 0x85:
9753  case 0x86:
9754  case 0x87:
9755  case 0x88:
9756  case 0x89:
9757  case 0x8A:
9758  case 0x8B:
9759  case 0x8C:
9760  case 0x8D:
9761  case 0x8E:
9762  case 0x8F:
9763  case 0x90:
9764  case 0x91:
9765  case 0x92:
9766  case 0x93:
9767  case 0x94:
9768  case 0x95:
9769  case 0x96:
9770  case 0x97:
9771  return get_cbor_array(
9772  conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
9773 
9774  case 0x98: // array (one-byte uint8_t for n follows)
9775  {
9776  std::uint8_t len{};
9777  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
9778  }
9779 
9780  case 0x99: // array (two-byte uint16_t for n follow)
9781  {
9782  std::uint16_t len{};
9783  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
9784  }
9785 
9786  case 0x9A: // array (four-byte uint32_t for n follow)
9787  {
9788  std::uint32_t len{};
9789  return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
9790  }
9791 
9792  case 0x9B: // array (eight-byte uint64_t for n follow)
9793  {
9794  std::uint64_t len{};
9795  return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
9796  }
9797 
9798  case 0x9F: // array (indefinite length)
9799  return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
9800 
9801  // map (0x00..0x17 pairs of data items follow)
9802  case 0xA0:
9803  case 0xA1:
9804  case 0xA2:
9805  case 0xA3:
9806  case 0xA4:
9807  case 0xA5:
9808  case 0xA6:
9809  case 0xA7:
9810  case 0xA8:
9811  case 0xA9:
9812  case 0xAA:
9813  case 0xAB:
9814  case 0xAC:
9815  case 0xAD:
9816  case 0xAE:
9817  case 0xAF:
9818  case 0xB0:
9819  case 0xB1:
9820  case 0xB2:
9821  case 0xB3:
9822  case 0xB4:
9823  case 0xB5:
9824  case 0xB6:
9825  case 0xB7:
9826  return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
9827 
9828  case 0xB8: // map (one-byte uint8_t for n follows)
9829  {
9830  std::uint8_t len{};
9831  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
9832  }
9833 
9834  case 0xB9: // map (two-byte uint16_t for n follow)
9835  {
9836  std::uint16_t len{};
9837  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
9838  }
9839 
9840  case 0xBA: // map (four-byte uint32_t for n follow)
9841  {
9842  std::uint32_t len{};
9843  return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
9844  }
9845 
9846  case 0xBB: // map (eight-byte uint64_t for n follow)
9847  {
9848  std::uint64_t len{};
9849  return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
9850  }
9851 
9852  case 0xBF: // map (indefinite length)
9853  return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
9854 
9855  case 0xC6: // tagged item
9856  case 0xC7:
9857  case 0xC8:
9858  case 0xC9:
9859  case 0xCA:
9860  case 0xCB:
9861  case 0xCC:
9862  case 0xCD:
9863  case 0xCE:
9864  case 0xCF:
9865  case 0xD0:
9866  case 0xD1:
9867  case 0xD2:
9868  case 0xD3:
9869  case 0xD4:
9870  case 0xD8: // tagged item (1 bytes follow)
9871  case 0xD9: // tagged item (2 bytes follow)
9872  case 0xDA: // tagged item (4 bytes follow)
9873  case 0xDB: // tagged item (8 bytes follow)
9874  {
9875  switch (tag_handler)
9876  {
9877  case cbor_tag_handler_t::error:
9878  {
9879  auto last_token = get_token_string();
9880  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
9881  exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
9882  }
9883 
9884  case cbor_tag_handler_t::ignore:
9885  {
9886  // ignore binary subtype
9887  switch (current)
9888  {
9889  case 0xD8:
9890  {
9891  std::uint8_t subtype_to_ignore{};
9892  get_number(input_format_t::cbor, subtype_to_ignore);
9893  break;
9894  }
9895  case 0xD9:
9896  {
9897  std::uint16_t subtype_to_ignore{};
9898  get_number(input_format_t::cbor, subtype_to_ignore);
9899  break;
9900  }
9901  case 0xDA:
9902  {
9903  std::uint32_t subtype_to_ignore{};
9904  get_number(input_format_t::cbor, subtype_to_ignore);
9905  break;
9906  }
9907  case 0xDB:
9908  {
9909  std::uint64_t subtype_to_ignore{};
9910  get_number(input_format_t::cbor, subtype_to_ignore);
9911  break;
9912  }
9913  default:
9914  break;
9915  }
9916  return parse_cbor_internal(true, tag_handler);
9917  }
9918 
9919  case cbor_tag_handler_t::store:
9920  {
9921  binary_t b;
9922  // use binary subtype and store in binary container
9923  switch (current)
9924  {
9925  case 0xD8:
9926  {
9927  std::uint8_t subtype{};
9928  get_number(input_format_t::cbor, subtype);
9929  b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9930  break;
9931  }
9932  case 0xD9:
9933  {
9934  std::uint16_t subtype{};
9935  get_number(input_format_t::cbor, subtype);
9936  b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9937  break;
9938  }
9939  case 0xDA:
9940  {
9941  std::uint32_t subtype{};
9942  get_number(input_format_t::cbor, subtype);
9943  b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9944  break;
9945  }
9946  case 0xDB:
9947  {
9948  std::uint64_t subtype{};
9949  get_number(input_format_t::cbor, subtype);
9950  b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9951  break;
9952  }
9953  default:
9954  return parse_cbor_internal(true, tag_handler);
9955  }
9956  get();
9957  return get_cbor_binary(b) && sax->binary(b);
9958  }
9959 
9960  default: // LCOV_EXCL_LINE
9961  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
9962  return false; // LCOV_EXCL_LINE
9963  }
9964  }
9965 
9966  case 0xF4: // false
9967  return sax->boolean(false);
9968 
9969  case 0xF5: // true
9970  return sax->boolean(true);
9971 
9972  case 0xF6: // null
9973  return sax->null();
9974 
9975  case 0xF9: // Half-Precision Float (two-byte IEEE 754)
9976  {
9977  const auto byte1_raw = get();
9978  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
9979  {
9980  return false;
9981  }
9982  const auto byte2_raw = get();
9983  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
9984  {
9985  return false;
9986  }
9987 
9988  const auto byte1 = static_cast<unsigned char>(byte1_raw);
9989  const auto byte2 = static_cast<unsigned char>(byte2_raw);
9990 
9991  // code from RFC 7049, Appendix D, Figure 3:
9992  // As half-precision floating-point numbers were only added
9993  // to IEEE 754 in 2008, today's programming platforms often
9994  // still only have limited support for them. It is very
9995  // easy to include at least decoding support for them even
9996  // without such support. An example of a small decoder for
9997  // half-precision floating-point numbers in the C language
9998  // is shown in Fig. 3.
9999  const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
10000  const double val = [&half]
10001  {
10002  const int exp = (half >> 10u) & 0x1Fu;
10003  const unsigned int mant = half & 0x3FFu;
10004  JSON_ASSERT(0 <= exp && exp <= 32);
10005  JSON_ASSERT(mant <= 1024);
10006  switch (exp)
10007  {
10008  case 0:
10009  return std::ldexp(mant, -24);
10010  case 31:
10011  return (mant == 0)
10012  ? std::numeric_limits<double>::infinity()
10013  : std::numeric_limits<double>::quiet_NaN();
10014  default:
10015  return std::ldexp(mant + 1024, exp - 25);
10016  }
10017  }();
10018  return sax->number_float((half & 0x8000u) != 0
10019  ? static_cast<number_float_t>(-val)
10020  : static_cast<number_float_t>(val), "");
10021  }
10022 
10023  case 0xFA: // Single-Precision Float (four-byte IEEE 754)
10024  {
10025  float number{};
10026  return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
10027  }
10028 
10029  case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
10030  {
10031  double number{};
10032  return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
10033  }
10034 
10035  default: // anything else (0xFF is handled inside the other types)
10036  {
10037  auto last_token = get_token_string();
10038  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
10039  exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
10040  }
10041  }
10042  }
10043 
10055  bool get_cbor_string(string_t& result)
10056  {
10057  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
10058  {
10059  return false;
10060  }
10061 
10062  switch (current)
10063  {
10064  // UTF-8 string (0x00..0x17 bytes follow)
10065  case 0x60:
10066  case 0x61:
10067  case 0x62:
10068  case 0x63:
10069  case 0x64:
10070  case 0x65:
10071  case 0x66:
10072  case 0x67:
10073  case 0x68:
10074  case 0x69:
10075  case 0x6A:
10076  case 0x6B:
10077  case 0x6C:
10078  case 0x6D:
10079  case 0x6E:
10080  case 0x6F:
10081  case 0x70:
10082  case 0x71:
10083  case 0x72:
10084  case 0x73:
10085  case 0x74:
10086  case 0x75:
10087  case 0x76:
10088  case 0x77:
10089  {
10090  return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
10091  }
10092 
10093  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
10094  {
10095  std::uint8_t len{};
10096  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10097  }
10098 
10099  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
10100  {
10101  std::uint16_t len{};
10102  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10103  }
10104 
10105  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
10106  {
10107  std::uint32_t len{};
10108  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10109  }
10110 
10111  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
10112  {
10113  std::uint64_t len{};
10114  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10115  }
10116 
10117  case 0x7F: // UTF-8 string (indefinite length)
10118  {
10119  while (get() != 0xFF)
10120  {
10121  string_t chunk;
10122  if (!get_cbor_string(chunk))
10123  {
10124  return false;
10125  }
10126  result.append(chunk);
10127  }
10128  return true;
10129  }
10130 
10131  default:
10132  {
10133  auto last_token = get_token_string();
10134  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
10135  exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
10136  }
10137  }
10138  }
10139 
10151  bool get_cbor_binary(binary_t& result)
10152  {
10153  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
10154  {
10155  return false;
10156  }
10157 
10158  switch (current)
10159  {
10160  // Binary data (0x00..0x17 bytes follow)
10161  case 0x40:
10162  case 0x41:
10163  case 0x42:
10164  case 0x43:
10165  case 0x44:
10166  case 0x45:
10167  case 0x46:
10168  case 0x47:
10169  case 0x48:
10170  case 0x49:
10171  case 0x4A:
10172  case 0x4B:
10173  case 0x4C:
10174  case 0x4D:
10175  case 0x4E:
10176  case 0x4F:
10177  case 0x50:
10178  case 0x51:
10179  case 0x52:
10180  case 0x53:
10181  case 0x54:
10182  case 0x55:
10183  case 0x56:
10184  case 0x57:
10185  {
10186  return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
10187  }
10188 
10189  case 0x58: // Binary data (one-byte uint8_t for n follows)
10190  {
10191  std::uint8_t len{};
10192  return get_number(input_format_t::cbor, len) &&
10193  get_binary(input_format_t::cbor, len, result);
10194  }
10195 
10196  case 0x59: // Binary data (two-byte uint16_t for n follow)
10197  {
10198  std::uint16_t len{};
10199  return get_number(input_format_t::cbor, len) &&
10200  get_binary(input_format_t::cbor, len, result);
10201  }
10202 
10203  case 0x5A: // Binary data (four-byte uint32_t for n follow)
10204  {
10205  std::uint32_t len{};
10206  return get_number(input_format_t::cbor, len) &&
10207  get_binary(input_format_t::cbor, len, result);
10208  }
10209 
10210  case 0x5B: // Binary data (eight-byte uint64_t for n follow)
10211  {
10212  std::uint64_t len{};
10213  return get_number(input_format_t::cbor, len) &&
10214  get_binary(input_format_t::cbor, len, result);
10215  }
10216 
10217  case 0x5F: // Binary data (indefinite length)
10218  {
10219  while (get() != 0xFF)
10220  {
10221  binary_t chunk;
10222  if (!get_cbor_binary(chunk))
10223  {
10224  return false;
10225  }
10226  result.insert(result.end(), chunk.begin(), chunk.end());
10227  }
10228  return true;
10229  }
10230 
10231  default:
10232  {
10233  auto last_token = get_token_string();
10234  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
10235  exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
10236  }
10237  }
10238  }
10239 
10246  bool get_cbor_array(const std::size_t len,
10247  const cbor_tag_handler_t tag_handler)
10248  {
10249  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
10250  {
10251  return false;
10252  }
10253 
10254  if (len != static_cast<std::size_t>(-1))
10255  {
10256  for (std::size_t i = 0; i < len; ++i)
10257  {
10258  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
10259  {
10260  return false;
10261  }
10262  }
10263  }
10264  else
10265  {
10266  while (get() != 0xFF)
10267  {
10268  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
10269  {
10270  return false;
10271  }
10272  }
10273  }
10274 
10275  return sax->end_array();
10276  }
10277 
10284  bool get_cbor_object(const std::size_t len,
10285  const cbor_tag_handler_t tag_handler)
10286  {
10287  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
10288  {
10289  return false;
10290  }
10291 
10292  if (len != 0)
10293  {
10294  string_t key;
10295  if (len != static_cast<std::size_t>(-1))
10296  {
10297  for (std::size_t i = 0; i < len; ++i)
10298  {
10299  get();
10300  if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
10301  {
10302  return false;
10303  }
10304 
10305  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
10306  {
10307  return false;
10308  }
10309  key.clear();
10310  }
10311  }
10312  else
10313  {
10314  while (get() != 0xFF)
10315  {
10316  if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
10317  {
10318  return false;
10319  }
10320 
10321  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
10322  {
10323  return false;
10324  }
10325  key.clear();
10326  }
10327  }
10328  }
10329 
10330  return sax->end_object();
10331  }
10332 
10334  // MsgPack //
10336 
10340  bool parse_msgpack_internal()
10341  {
10342  switch (get())
10343  {
10344  // EOF
10345  case char_traits<char_type>::eof():
10346  return unexpect_eof(input_format_t::msgpack, "value");
10347 
10348  // positive fixint
10349  case 0x00:
10350  case 0x01:
10351  case 0x02:
10352  case 0x03:
10353  case 0x04:
10354  case 0x05:
10355  case 0x06:
10356  case 0x07:
10357  case 0x08:
10358  case 0x09:
10359  case 0x0A:
10360  case 0x0B:
10361  case 0x0C:
10362  case 0x0D:
10363  case 0x0E:
10364  case 0x0F:
10365  case 0x10:
10366  case 0x11:
10367  case 0x12:
10368  case 0x13:
10369  case 0x14:
10370  case 0x15:
10371  case 0x16:
10372  case 0x17:
10373  case 0x18:
10374  case 0x19:
10375  case 0x1A:
10376  case 0x1B:
10377  case 0x1C:
10378  case 0x1D:
10379  case 0x1E:
10380  case 0x1F:
10381  case 0x20:
10382  case 0x21:
10383  case 0x22:
10384  case 0x23:
10385  case 0x24:
10386  case 0x25:
10387  case 0x26:
10388  case 0x27:
10389  case 0x28:
10390  case 0x29:
10391  case 0x2A:
10392  case 0x2B:
10393  case 0x2C:
10394  case 0x2D:
10395  case 0x2E:
10396  case 0x2F:
10397  case 0x30:
10398  case 0x31:
10399  case 0x32:
10400  case 0x33:
10401  case 0x34:
10402  case 0x35:
10403  case 0x36:
10404  case 0x37:
10405  case 0x38:
10406  case 0x39:
10407  case 0x3A:
10408  case 0x3B:
10409  case 0x3C:
10410  case 0x3D:
10411  case 0x3E:
10412  case 0x3F:
10413  case 0x40:
10414  case 0x41:
10415  case 0x42:
10416  case 0x43:
10417  case 0x44:
10418  case 0x45:
10419  case 0x46:
10420  case 0x47:
10421  case 0x48:
10422  case 0x49:
10423  case 0x4A:
10424  case 0x4B:
10425  case 0x4C:
10426  case 0x4D:
10427  case 0x4E:
10428  case 0x4F:
10429  case 0x50:
10430  case 0x51:
10431  case 0x52:
10432  case 0x53:
10433  case 0x54:
10434  case 0x55:
10435  case 0x56:
10436  case 0x57:
10437  case 0x58:
10438  case 0x59:
10439  case 0x5A:
10440  case 0x5B:
10441  case 0x5C:
10442  case 0x5D:
10443  case 0x5E:
10444  case 0x5F:
10445  case 0x60:
10446  case 0x61:
10447  case 0x62:
10448  case 0x63:
10449  case 0x64:
10450  case 0x65:
10451  case 0x66:
10452  case 0x67:
10453  case 0x68:
10454  case 0x69:
10455  case 0x6A:
10456  case 0x6B:
10457  case 0x6C:
10458  case 0x6D:
10459  case 0x6E:
10460  case 0x6F:
10461  case 0x70:
10462  case 0x71:
10463  case 0x72:
10464  case 0x73:
10465  case 0x74:
10466  case 0x75:
10467  case 0x76:
10468  case 0x77:
10469  case 0x78:
10470  case 0x79:
10471  case 0x7A:
10472  case 0x7B:
10473  case 0x7C:
10474  case 0x7D:
10475  case 0x7E:
10476  case 0x7F:
10477  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
10478 
10479  // fixmap
10480  case 0x80:
10481  case 0x81:
10482  case 0x82:
10483  case 0x83:
10484  case 0x84:
10485  case 0x85:
10486  case 0x86:
10487  case 0x87:
10488  case 0x88:
10489  case 0x89:
10490  case 0x8A:
10491  case 0x8B:
10492  case 0x8C:
10493  case 0x8D:
10494  case 0x8E:
10495  case 0x8F:
10496  return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
10497 
10498  // fixarray
10499  case 0x90:
10500  case 0x91:
10501  case 0x92:
10502  case 0x93:
10503  case 0x94:
10504  case 0x95:
10505  case 0x96:
10506  case 0x97:
10507  case 0x98:
10508  case 0x99:
10509  case 0x9A:
10510  case 0x9B:
10511  case 0x9C:
10512  case 0x9D:
10513  case 0x9E:
10514  case 0x9F:
10515  return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
10516 
10517  // fixstr
10518  case 0xA0:
10519  case 0xA1:
10520  case 0xA2:
10521  case 0xA3:
10522  case 0xA4:
10523  case 0xA5:
10524  case 0xA6:
10525  case 0xA7:
10526  case 0xA8:
10527  case 0xA9:
10528  case 0xAA:
10529  case 0xAB:
10530  case 0xAC:
10531  case 0xAD:
10532  case 0xAE:
10533  case 0xAF:
10534  case 0xB0:
10535  case 0xB1:
10536  case 0xB2:
10537  case 0xB3:
10538  case 0xB4:
10539  case 0xB5:
10540  case 0xB6:
10541  case 0xB7:
10542  case 0xB8:
10543  case 0xB9:
10544  case 0xBA:
10545  case 0xBB:
10546  case 0xBC:
10547  case 0xBD:
10548  case 0xBE:
10549  case 0xBF:
10550  case 0xD9: // str 8
10551  case 0xDA: // str 16
10552  case 0xDB: // str 32
10553  {
10554  string_t s;
10555  return get_msgpack_string(s) && sax->string(s);
10556  }
10557 
10558  case 0xC0: // nil
10559  return sax->null();
10560 
10561  case 0xC2: // false
10562  return sax->boolean(false);
10563 
10564  case 0xC3: // true
10565  return sax->boolean(true);
10566 
10567  case 0xC4: // bin 8
10568  case 0xC5: // bin 16
10569  case 0xC6: // bin 32
10570  case 0xC7: // ext 8
10571  case 0xC8: // ext 16
10572  case 0xC9: // ext 32
10573  case 0xD4: // fixext 1
10574  case 0xD5: // fixext 2
10575  case 0xD6: // fixext 4
10576  case 0xD7: // fixext 8
10577  case 0xD8: // fixext 16
10578  {
10579  binary_t b;
10580  return get_msgpack_binary(b) && sax->binary(b);
10581  }
10582 
10583  case 0xCA: // float 32
10584  {
10585  float number{};
10586  return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
10587  }
10588 
10589  case 0xCB: // float 64
10590  {
10591  double number{};
10592  return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
10593  }
10594 
10595  case 0xCC: // uint 8
10596  {
10597  std::uint8_t number{};
10598  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
10599  }
10600 
10601  case 0xCD: // uint 16
10602  {
10603  std::uint16_t number{};
10604  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
10605  }
10606 
10607  case 0xCE: // uint 32
10608  {
10609  std::uint32_t number{};
10610  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
10611  }
10612 
10613  case 0xCF: // uint 64
10614  {
10615  std::uint64_t number{};
10616  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
10617  }
10618 
10619  case 0xD0: // int 8
10620  {
10621  std::int8_t number{};
10622  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
10623  }
10624 
10625  case 0xD1: // int 16
10626  {
10627  std::int16_t number{};
10628  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
10629  }
10630 
10631  case 0xD2: // int 32
10632  {
10633  std::int32_t number{};
10634  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
10635  }
10636 
10637  case 0xD3: // int 64
10638  {
10639  std::int64_t number{};
10640  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
10641  }
10642 
10643  case 0xDC: // array 16
10644  {
10645  std::uint16_t len{};
10646  return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
10647  }
10648 
10649  case 0xDD: // array 32
10650  {
10651  std::uint32_t len{};
10652  return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
10653  }
10654 
10655  case 0xDE: // map 16
10656  {
10657  std::uint16_t len{};
10658  return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
10659  }
10660 
10661  case 0xDF: // map 32
10662  {
10663  std::uint32_t len{};
10664  return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
10665  }
10666 
10667  // negative fixint
10668  case 0xE0:
10669  case 0xE1:
10670  case 0xE2:
10671  case 0xE3:
10672  case 0xE4:
10673  case 0xE5:
10674  case 0xE6:
10675  case 0xE7:
10676  case 0xE8:
10677  case 0xE9:
10678  case 0xEA:
10679  case 0xEB:
10680  case 0xEC:
10681  case 0xED:
10682  case 0xEE:
10683  case 0xEF:
10684  case 0xF0:
10685  case 0xF1:
10686  case 0xF2:
10687  case 0xF3:
10688  case 0xF4:
10689  case 0xF5:
10690  case 0xF6:
10691  case 0xF7:
10692  case 0xF8:
10693  case 0xF9:
10694  case 0xFA:
10695  case 0xFB:
10696  case 0xFC:
10697  case 0xFD:
10698  case 0xFE:
10699  case 0xFF:
10700  return sax->number_integer(static_cast<std::int8_t>(current));
10701 
10702  default: // anything else
10703  {
10704  auto last_token = get_token_string();
10705  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
10706  exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
10707  }
10708  }
10709  }
10710 
10721  bool get_msgpack_string(string_t& result)
10722  {
10723  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
10724  {
10725  return false;
10726  }
10727 
10728  switch (current)
10729  {
10730  // fixstr
10731  case 0xA0:
10732  case 0xA1:
10733  case 0xA2:
10734  case 0xA3:
10735  case 0xA4:
10736  case 0xA5:
10737  case 0xA6:
10738  case 0xA7:
10739  case 0xA8:
10740  case 0xA9:
10741  case 0xAA:
10742  case 0xAB:
10743  case 0xAC:
10744  case 0xAD:
10745  case 0xAE:
10746  case 0xAF:
10747  case 0xB0:
10748  case 0xB1:
10749  case 0xB2:
10750  case 0xB3:
10751  case 0xB4:
10752  case 0xB5:
10753  case 0xB6:
10754  case 0xB7:
10755  case 0xB8:
10756  case 0xB9:
10757  case 0xBA:
10758  case 0xBB:
10759  case 0xBC:
10760  case 0xBD:
10761  case 0xBE:
10762  case 0xBF:
10763  {
10764  return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
10765  }
10766 
10767  case 0xD9: // str 8
10768  {
10769  std::uint8_t len{};
10770  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10771  }
10772 
10773  case 0xDA: // str 16
10774  {
10775  std::uint16_t len{};
10776  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10777  }
10778 
10779  case 0xDB: // str 32
10780  {
10781  std::uint32_t len{};
10782  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10783  }
10784 
10785  default:
10786  {
10787  auto last_token = get_token_string();
10788  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
10789  exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
10790  }
10791  }
10792  }
10793 
10804  bool get_msgpack_binary(binary_t& result)
10805  {
10806  // helper function to set the subtype
10807  auto assign_and_return_true = [&result](std::int8_t subtype)
10808  {
10809  result.set_subtype(static_cast<std::uint8_t>(subtype));
10810  return true;
10811  };
10812 
10813  switch (current)
10814  {
10815  case 0xC4: // bin 8
10816  {
10817  std::uint8_t len{};
10818  return get_number(input_format_t::msgpack, len) &&
10819  get_binary(input_format_t::msgpack, len, result);
10820  }
10821 
10822  case 0xC5: // bin 16
10823  {
10824  std::uint16_t len{};
10825  return get_number(input_format_t::msgpack, len) &&
10826  get_binary(input_format_t::msgpack, len, result);
10827  }
10828 
10829  case 0xC6: // bin 32
10830  {
10831  std::uint32_t len{};
10832  return get_number(input_format_t::msgpack, len) &&
10833  get_binary(input_format_t::msgpack, len, result);
10834  }
10835 
10836  case 0xC7: // ext 8
10837  {
10838  std::uint8_t len{};
10839  std::int8_t subtype{};
10840  return get_number(input_format_t::msgpack, len) &&
10841  get_number(input_format_t::msgpack, subtype) &&
10842  get_binary(input_format_t::msgpack, len, result) &&
10843  assign_and_return_true(subtype);
10844  }
10845 
10846  case 0xC8: // ext 16
10847  {
10848  std::uint16_t len{};
10849  std::int8_t subtype{};
10850  return get_number(input_format_t::msgpack, len) &&
10851  get_number(input_format_t::msgpack, subtype) &&
10852  get_binary(input_format_t::msgpack, len, result) &&
10853  assign_and_return_true(subtype);
10854  }
10855 
10856  case 0xC9: // ext 32
10857  {
10858  std::uint32_t len{};
10859  std::int8_t subtype{};
10860  return get_number(input_format_t::msgpack, len) &&
10861  get_number(input_format_t::msgpack, subtype) &&
10862  get_binary(input_format_t::msgpack, len, result) &&
10863  assign_and_return_true(subtype);
10864  }
10865 
10866  case 0xD4: // fixext 1
10867  {
10868  std::int8_t subtype{};
10869  return get_number(input_format_t::msgpack, subtype) &&
10870  get_binary(input_format_t::msgpack, 1, result) &&
10871  assign_and_return_true(subtype);
10872  }
10873 
10874  case 0xD5: // fixext 2
10875  {
10876  std::int8_t subtype{};
10877  return get_number(input_format_t::msgpack, subtype) &&
10878  get_binary(input_format_t::msgpack, 2, result) &&
10879  assign_and_return_true(subtype);
10880  }
10881 
10882  case 0xD6: // fixext 4
10883  {
10884  std::int8_t subtype{};
10885  return get_number(input_format_t::msgpack, subtype) &&
10886  get_binary(input_format_t::msgpack, 4, result) &&
10887  assign_and_return_true(subtype);
10888  }
10889 
10890  case 0xD7: // fixext 8
10891  {
10892  std::int8_t subtype{};
10893  return get_number(input_format_t::msgpack, subtype) &&
10894  get_binary(input_format_t::msgpack, 8, result) &&
10895  assign_and_return_true(subtype);
10896  }
10897 
10898  case 0xD8: // fixext 16
10899  {
10900  std::int8_t subtype{};
10901  return get_number(input_format_t::msgpack, subtype) &&
10902  get_binary(input_format_t::msgpack, 16, result) &&
10903  assign_and_return_true(subtype);
10904  }
10905 
10906  default: // LCOV_EXCL_LINE
10907  return false; // LCOV_EXCL_LINE
10908  }
10909  }
10910 
10915  bool get_msgpack_array(const std::size_t len)
10916  {
10917  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
10918  {
10919  return false;
10920  }
10921 
10922  for (std::size_t i = 0; i < len; ++i)
10923  {
10924  if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
10925  {
10926  return false;
10927  }
10928  }
10929 
10930  return sax->end_array();
10931  }
10932 
10937  bool get_msgpack_object(const std::size_t len)
10938  {
10939  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
10940  {
10941  return false;
10942  }
10943 
10944  string_t key;
10945  for (std::size_t i = 0; i < len; ++i)
10946  {
10947  get();
10948  if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
10949  {
10950  return false;
10951  }
10952 
10953  if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
10954  {
10955  return false;
10956  }
10957  key.clear();
10958  }
10959 
10960  return sax->end_object();
10961  }
10962 
10964  // UBJSON //
10966 
10974  bool parse_ubjson_internal(const bool get_char = true)
10975  {
10976  return get_ubjson_value(get_char ? get_ignore_noop() : current);
10977  }
10978 
10993  bool get_ubjson_string(string_t& result, const bool get_char = true)
10994  {
10995  if (get_char)
10996  {
10997  get(); // TODO(niels): may we ignore N here?
10998  }
10999 
11000  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
11001  {
11002  return false;
11003  }
11004 
11005  switch (current)
11006  {
11007  case 'U':
11008  {
11009  std::uint8_t len{};
11010  return get_number(input_format, len) && get_string(input_format, len, result);
11011  }
11012 
11013  case 'i':
11014  {
11015  std::int8_t len{};
11016  return get_number(input_format, len) && get_string(input_format, len, result);
11017  }
11018 
11019  case 'I':
11020  {
11021  std::int16_t len{};
11022  return get_number(input_format, len) && get_string(input_format, len, result);
11023  }
11024 
11025  case 'l':
11026  {
11027  std::int32_t len{};
11028  return get_number(input_format, len) && get_string(input_format, len, result);
11029  }
11030 
11031  case 'L':
11032  {
11033  std::int64_t len{};
11034  return get_number(input_format, len) && get_string(input_format, len, result);
11035  }
11036 
11037  case 'u':
11038  {
11039  if (input_format != input_format_t::bjdata)
11040  {
11041  break;
11042  }
11043  std::uint16_t len{};
11044  return get_number(input_format, len) && get_string(input_format, len, result);
11045  }
11046 
11047  case 'm':
11048  {
11049  if (input_format != input_format_t::bjdata)
11050  {
11051  break;
11052  }
11053  std::uint32_t len{};
11054  return get_number(input_format, len) && get_string(input_format, len, result);
11055  }
11056 
11057  case 'M':
11058  {
11059  if (input_format != input_format_t::bjdata)
11060  {
11061  break;
11062  }
11063  std::uint64_t len{};
11064  return get_number(input_format, len) && get_string(input_format, len, result);
11065  }
11066 
11067  default:
11068  break;
11069  }
11070  auto last_token = get_token_string();
11071  std::string message;
11072 
11073  if (input_format != input_format_t::bjdata)
11074  {
11075  message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
11076  }
11077  else
11078  {
11079  message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
11080  }
11081  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
11082  }
11083 
11088  bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
11089  {
11090  std::pair<std::size_t, char_int_type> size_and_type;
11091  size_t dimlen = 0;
11092  bool no_ndarray = true;
11093 
11094  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
11095  {
11096  return false;
11097  }
11098 
11099  if (size_and_type.first != npos)
11100  {
11101  if (size_and_type.second != 0)
11102  {
11103  if (size_and_type.second != 'N')
11104  {
11105  for (std::size_t i = 0; i < size_and_type.first; ++i)
11106  {
11107  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
11108  {
11109  return false;
11110  }
11111  dim.push_back(dimlen);
11112  }
11113  }
11114  }
11115  else
11116  {
11117  for (std::size_t i = 0; i < size_and_type.first; ++i)
11118  {
11119  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
11120  {
11121  return false;
11122  }
11123  dim.push_back(dimlen);
11124  }
11125  }
11126  }
11127  else
11128  {
11129  while (current != ']')
11130  {
11131  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
11132  {
11133  return false;
11134  }
11135  dim.push_back(dimlen);
11136  get_ignore_noop();
11137  }
11138  }
11139  return true;
11140  }
11141 
11153  bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
11154  {
11155  if (prefix == 0)
11156  {
11157  prefix = get_ignore_noop();
11158  }
11159 
11160  switch (prefix)
11161  {
11162  case 'U':
11163  {
11164  std::uint8_t number{};
11165  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11166  {
11167  return false;
11168  }
11169  result = static_cast<std::size_t>(number);
11170  return true;
11171  }
11172 
11173  case 'i':
11174  {
11175  std::int8_t number{};
11176  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11177  {
11178  return false;
11179  }
11180  if (number < 0)
11181  {
11182  return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11183  exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11184  }
11185  result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
11186  return true;
11187  }
11188 
11189  case 'I':
11190  {
11191  std::int16_t number{};
11192  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11193  {
11194  return false;
11195  }
11196  if (number < 0)
11197  {
11198  return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11199  exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11200  }
11201  result = static_cast<std::size_t>(number);
11202  return true;
11203  }
11204 
11205  case 'l':
11206  {
11207  std::int32_t number{};
11208  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11209  {
11210  return false;
11211  }
11212  if (number < 0)
11213  {
11214  return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11215  exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11216  }
11217  result = static_cast<std::size_t>(number);
11218  return true;
11219  }
11220 
11221  case 'L':
11222  {
11223  std::int64_t number{};
11224  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11225  {
11226  return false;
11227  }
11228  if (number < 0)
11229  {
11230  return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11231  exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11232  }
11233  if (!value_in_range_of<std::size_t>(number))
11234  {
11235  return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
11236  exception_message(input_format, "integer value overflow", "size"), nullptr));
11237  }
11238  result = static_cast<std::size_t>(number);
11239  return true;
11240  }
11241 
11242  case 'u':
11243  {
11244  if (input_format != input_format_t::bjdata)
11245  {
11246  break;
11247  }
11248  std::uint16_t number{};
11249  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11250  {
11251  return false;
11252  }
11253  result = static_cast<std::size_t>(number);
11254  return true;
11255  }
11256 
11257  case 'm':
11258  {
11259  if (input_format != input_format_t::bjdata)
11260  {
11261  break;
11262  }
11263  std::uint32_t number{};
11264  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11265  {
11266  return false;
11267  }
11268  result = conditional_static_cast<std::size_t>(number);
11269  return true;
11270  }
11271 
11272  case 'M':
11273  {
11274  if (input_format != input_format_t::bjdata)
11275  {
11276  break;
11277  }
11278  std::uint64_t number{};
11279  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11280  {
11281  return false;
11282  }
11283  if (!value_in_range_of<std::size_t>(number))
11284  {
11285  return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
11286  exception_message(input_format, "integer value overflow", "size"), nullptr));
11287  }
11288  result = detail::conditional_static_cast<std::size_t>(number);
11289  return true;
11290  }
11291 
11292  case '[':
11293  {
11294  if (input_format != input_format_t::bjdata)
11295  {
11296  break;
11297  }
11298  if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array
11299  {
11300  return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
11301  }
11302  std::vector<size_t> dim;
11303  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
11304  {
11305  return false;
11306  }
11307  if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
11308  {
11309  result = dim.at(dim.size() - 1);
11310  return true;
11311  }
11312  if (!dim.empty()) // if ndarray, convert to an object in JData annotated array format
11313  {
11314  for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
11315  {
11316  if (i == 0)
11317  {
11318  result = 0;
11319  return true;
11320  }
11321  }
11322 
11323  string_t key = "_ArraySize_";
11324  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
11325  {
11326  return false;
11327  }
11328  result = 1;
11329  for (auto i : dim)
11330  {
11331  result *= i;
11332  if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
11333  {
11334  return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
11335  }
11336  if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
11337  {
11338  return false;
11339  }
11340  }
11341  is_ndarray = true;
11342  return sax->end_array();
11343  }
11344  result = 0;
11345  return true;
11346  }
11347 
11348  default:
11349  break;
11350  }
11351  auto last_token = get_token_string();
11352  std::string message;
11353 
11354  if (input_format != input_format_t::bjdata)
11355  {
11356  message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
11357  }
11358  else
11359  {
11360  message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
11361  }
11362  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
11363  }
11364 
11376  bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
11377  {
11378  result.first = npos; // size
11379  result.second = 0; // type
11380  bool is_ndarray = false;
11381 
11382  get_ignore_noop();
11383 
11384  if (current == '$')
11385  {
11386  result.second = get(); // must not ignore 'N', because 'N' maybe the type
11387  if (input_format == input_format_t::bjdata
11388  && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
11389  {
11390  auto last_token = get_token_string();
11391  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
11392  exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
11393  }
11394 
11395  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
11396  {
11397  return false;
11398  }
11399 
11400  get_ignore_noop();
11401  if (JSON_HEDLEY_UNLIKELY(current != '#'))
11402  {
11403  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
11404  {
11405  return false;
11406  }
11407  auto last_token = get_token_string();
11408  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
11409  exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
11410  }
11411 
11412  const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
11413  if (input_format == input_format_t::bjdata && is_ndarray)
11414  {
11415  if (inside_ndarray)
11416  {
11417  return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
11418  exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
11419  }
11420  result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
11421  }
11422  return is_error;
11423  }
11424 
11425  if (current == '#')
11426  {
11427  const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
11428  if (input_format == input_format_t::bjdata && is_ndarray)
11429  {
11430  return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
11431  exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
11432  }
11433  return is_error;
11434  }
11435 
11436  return true;
11437  }
11438 
11443  bool get_ubjson_value(const char_int_type prefix)
11444  {
11445  switch (prefix)
11446  {
11447  case char_traits<char_type>::eof(): // EOF
11448  return unexpect_eof(input_format, "value");
11449 
11450  case 'T': // true
11451  return sax->boolean(true);
11452  case 'F': // false
11453  return sax->boolean(false);
11454 
11455  case 'Z': // null
11456  return sax->null();
11457 
11458  case 'U':
11459  {
11460  std::uint8_t number{};
11461  return get_number(input_format, number) && sax->number_unsigned(number);
11462  }
11463 
11464  case 'i':
11465  {
11466  std::int8_t number{};
11467  return get_number(input_format, number) && sax->number_integer(number);
11468  }
11469 
11470  case 'I':
11471  {
11472  std::int16_t number{};
11473  return get_number(input_format, number) && sax->number_integer(number);
11474  }
11475 
11476  case 'l':
11477  {
11478  std::int32_t number{};
11479  return get_number(input_format, number) && sax->number_integer(number);
11480  }
11481 
11482  case 'L':
11483  {
11484  std::int64_t number{};
11485  return get_number(input_format, number) && sax->number_integer(number);
11486  }
11487 
11488  case 'u':
11489  {
11490  if (input_format != input_format_t::bjdata)
11491  {
11492  break;
11493  }
11494  std::uint16_t number{};
11495  return get_number(input_format, number) && sax->number_unsigned(number);
11496  }
11497 
11498  case 'm':
11499  {
11500  if (input_format != input_format_t::bjdata)
11501  {
11502  break;
11503  }
11504  std::uint32_t number{};
11505  return get_number(input_format, number) && sax->number_unsigned(number);
11506  }
11507 
11508  case 'M':
11509  {
11510  if (input_format != input_format_t::bjdata)
11511  {
11512  break;
11513  }
11514  std::uint64_t number{};
11515  return get_number(input_format, number) && sax->number_unsigned(number);
11516  }
11517 
11518  case 'h':
11519  {
11520  if (input_format != input_format_t::bjdata)
11521  {
11522  break;
11523  }
11524  const auto byte1_raw = get();
11525  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
11526  {
11527  return false;
11528  }
11529  const auto byte2_raw = get();
11530  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
11531  {
11532  return false;
11533  }
11534 
11535  const auto byte1 = static_cast<unsigned char>(byte1_raw);
11536  const auto byte2 = static_cast<unsigned char>(byte2_raw);
11537 
11538  // code from RFC 7049, Appendix D, Figure 3:
11539  // As half-precision floating-point numbers were only added
11540  // to IEEE 754 in 2008, today's programming platforms often
11541  // still only have limited support for them. It is very
11542  // easy to include at least decoding support for them even
11543  // without such support. An example of a small decoder for
11544  // half-precision floating-point numbers in the C language
11545  // is shown in Fig. 3.
11546  const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
11547  const double val = [&half]
11548  {
11549  const int exp = (half >> 10u) & 0x1Fu;
11550  const unsigned int mant = half & 0x3FFu;
11551  JSON_ASSERT(0 <= exp && exp <= 32);
11552  JSON_ASSERT(mant <= 1024);
11553  switch (exp)
11554  {
11555  case 0:
11556  return std::ldexp(mant, -24);
11557  case 31:
11558  return (mant == 0)
11559  ? std::numeric_limits<double>::infinity()
11560  : std::numeric_limits<double>::quiet_NaN();
11561  default:
11562  return std::ldexp(mant + 1024, exp - 25);
11563  }
11564  }();
11565  return sax->number_float((half & 0x8000u) != 0
11566  ? static_cast<number_float_t>(-val)
11567  : static_cast<number_float_t>(val), "");
11568  }
11569 
11570  case 'd':
11571  {
11572  float number{};
11573  return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
11574  }
11575 
11576  case 'D':
11577  {
11578  double number{};
11579  return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
11580  }
11581 
11582  case 'H':
11583  {
11584  return get_ubjson_high_precision_number();
11585  }
11586 
11587  case 'C': // char
11588  {
11589  get();
11590  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
11591  {
11592  return false;
11593  }
11594  if (JSON_HEDLEY_UNLIKELY(current > 127))
11595  {
11596  auto last_token = get_token_string();
11597  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
11598  exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
11599  }
11600  string_t s(1, static_cast<typename string_t::value_type>(current));
11601  return sax->string(s);
11602  }
11603 
11604  case 'S': // string
11605  {
11606  string_t s;
11607  return get_ubjson_string(s) && sax->string(s);
11608  }
11609 
11610  case '[': // array
11611  return get_ubjson_array();
11612 
11613  case '{': // object
11614  return get_ubjson_object();
11615 
11616  default: // anything else
11617  break;
11618  }
11619  auto last_token = get_token_string();
11620  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
11621  }
11622 
11626  bool get_ubjson_array()
11627  {
11628  std::pair<std::size_t, char_int_type> size_and_type;
11629  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
11630  {
11631  return false;
11632  }
11633 
11634  // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
11635  // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
11636 
11637  if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
11638  {
11639  size_and_type.second &= ~(static_cast<char_int_type>(1) << 8); // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
11640  auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type& p, char_int_type t)
11641  {
11642  return p.first < t;
11643  });
11644  string_t key = "_ArrayType_";
11645  if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
11646  {
11647  auto last_token = get_token_string();
11648  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
11649  exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
11650  }
11651 
11652  string_t type = it->second; // sax->string() takes a reference
11653  if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
11654  {
11655  return false;
11656  }
11657 
11658  if (size_and_type.second == 'C')
11659  {
11660  size_and_type.second = 'U';
11661  }
11662 
11663  key = "_ArrayData_";
11664  if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first)))
11665  {
11666  return false;
11667  }
11668 
11669  for (std::size_t i = 0; i < size_and_type.first; ++i)
11670  {
11671  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
11672  {
11673  return false;
11674  }
11675  }
11676 
11677  return (sax->end_array() && sax->end_object());
11678  }
11679 
11680  if (size_and_type.first != npos)
11681  {
11682  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
11683  {
11684  return false;
11685  }
11686 
11687  if (size_and_type.second != 0)
11688  {
11689  if (size_and_type.second != 'N')
11690  {
11691  for (std::size_t i = 0; i < size_and_type.first; ++i)
11692  {
11693  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
11694  {
11695  return false;
11696  }
11697  }
11698  }
11699  }
11700  else
11701  {
11702  for (std::size_t i = 0; i < size_and_type.first; ++i)
11703  {
11704  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
11705  {
11706  return false;
11707  }
11708  }
11709  }
11710  }
11711  else
11712  {
11713  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
11714  {
11715  return false;
11716  }
11717 
11718  while (current != ']')
11719  {
11720  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
11721  {
11722  return false;
11723  }
11724  get_ignore_noop();
11725  }
11726  }
11727 
11728  return sax->end_array();
11729  }
11730 
11734  bool get_ubjson_object()
11735  {
11736  std::pair<std::size_t, char_int_type> size_and_type;
11737  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
11738  {
11739  return false;
11740  }
11741 
11742  // do not accept ND-array size in objects in BJData
11743  if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
11744  {
11745  auto last_token = get_token_string();
11746  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
11747  exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
11748  }
11749 
11750  string_t key;
11751  if (size_and_type.first != npos)
11752  {
11753  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
11754  {
11755  return false;
11756  }
11757 
11758  if (size_and_type.second != 0)
11759  {
11760  for (std::size_t i = 0; i < size_and_type.first; ++i)
11761  {
11762  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
11763  {
11764  return false;
11765  }
11766  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
11767  {
11768  return false;
11769  }
11770  key.clear();
11771  }
11772  }
11773  else
11774  {
11775  for (std::size_t i = 0; i < size_and_type.first; ++i)
11776  {
11777  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
11778  {
11779  return false;
11780  }
11781  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
11782  {
11783  return false;
11784  }
11785  key.clear();
11786  }
11787  }
11788  }
11789  else
11790  {
11791  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
11792  {
11793  return false;
11794  }
11795 
11796  while (current != '}')
11797  {
11798  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
11799  {
11800  return false;
11801  }
11802  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
11803  {
11804  return false;
11805  }
11806  get_ignore_noop();
11807  key.clear();
11808  }
11809  }
11810 
11811  return sax->end_object();
11812  }
11813 
11814  // Note, no reader for UBJSON binary types is implemented because they do
11815  // not exist
11816 
11817  bool get_ubjson_high_precision_number()
11818  {
11819  // get size of following number string
11820  std::size_t size{};
11821  bool no_ndarray = true;
11822  auto res = get_ubjson_size_value(size, no_ndarray);
11823  if (JSON_HEDLEY_UNLIKELY(!res))
11824  {
11825  return res;
11826  }
11827 
11828  // get number string
11829  std::vector<char> number_vector;
11830  for (std::size_t i = 0; i < size; ++i)
11831  {
11832  get();
11833  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
11834  {
11835  return false;
11836  }
11837  number_vector.push_back(static_cast<char>(current));
11838  }
11839 
11840  // parse number string
11841  using ia_type = decltype(detail::input_adapter(number_vector));
11842  auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
11843  const auto result_number = number_lexer.scan();
11844  const auto number_string = number_lexer.get_token_string();
11845  const auto result_remainder = number_lexer.scan();
11846 
11847  using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
11848 
11849  if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
11850  {
11851  return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
11852  exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
11853  }
11854 
11855  switch (result_number)
11856  {
11857  case token_type::value_integer:
11858  return sax->number_integer(number_lexer.get_number_integer());
11859  case token_type::value_unsigned:
11860  return sax->number_unsigned(number_lexer.get_number_unsigned());
11861  case token_type::value_float:
11862  return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
11863  case token_type::uninitialized:
11864  case token_type::literal_true:
11865  case token_type::literal_false:
11866  case token_type::literal_null:
11867  case token_type::value_string:
11868  case token_type::begin_array:
11869  case token_type::begin_object:
11870  case token_type::end_array:
11871  case token_type::end_object:
11872  case token_type::name_separator:
11873  case token_type::value_separator:
11874  case token_type::parse_error:
11875  case token_type::end_of_input:
11876  case token_type::literal_or_value:
11877  default:
11878  return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
11879  exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
11880  }
11881  }
11882 
11884  // Utility functions //
11886 
11896  char_int_type get()
11897  {
11898  ++chars_read;
11899  return current = ia.get_character();
11900  }
11901 
11905  char_int_type get_ignore_noop()
11906  {
11907  do
11908  {
11909  get();
11910  } while (current == 'N');
11911 
11912  return current;
11913  }
11914 
11915  /*
11916  @brief read a number from the input
11917 
11918  @tparam NumberType the type of the number
11919  @param[in] format the current format (for diagnostics)
11920  @param[out] result number of type @a NumberType
11921 
11922  @return whether conversion completed
11923 
11924  @note This function needs to respect the system's endianness, because
11925  bytes in CBOR, MessagePack, and UBJSON are stored in network order
11926  (big endian) and therefore need reordering on little endian systems.
11927  On the other hand, BSON and BJData use little endian and should reorder
11928  on big endian systems.
11929  */
11930  template<typename NumberType, bool InputIsLittleEndian = false>
11931  bool get_number(const input_format_t format, NumberType& result)
11932  {
11933  // step 1: read input into array with system's byte order
11934  std::array<std::uint8_t, sizeof(NumberType)> vec{};
11935  for (std::size_t i = 0; i < sizeof(NumberType); ++i)
11936  {
11937  get();
11938  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
11939  {
11940  return false;
11941  }
11942 
11943  // reverse byte order prior to conversion if necessary
11944  if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
11945  {
11946  vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
11947  }
11948  else
11949  {
11950  vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
11951  }
11952  }
11953 
11954  // step 2: convert array into number of type T and return
11955  std::memcpy(&result, vec.data(), sizeof(NumberType));
11956  return true;
11957  }
11958 
11973  template<typename NumberType>
11974  bool get_string(const input_format_t format,
11975  const NumberType len,
11976  string_t& result)
11977  {
11978  bool success = true;
11979  for (NumberType i = 0; i < len; i++)
11980  {
11981  get();
11982  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
11983  {
11984  success = false;
11985  break;
11986  }
11987  result.push_back(static_cast<typename string_t::value_type>(current));
11988  }
11989  return success;
11990  }
11991 
12006  template<typename NumberType>
12007  bool get_binary(const input_format_t format,
12008  const NumberType len,
12009  binary_t& result)
12010  {
12011  bool success = true;
12012  for (NumberType i = 0; i < len; i++)
12013  {
12014  get();
12015  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
12016  {
12017  success = false;
12018  break;
12019  }
12020  result.push_back(static_cast<std::uint8_t>(current));
12021  }
12022  return success;
12023  }
12024 
12030  JSON_HEDLEY_NON_NULL(3)
12031  bool unexpect_eof(const input_format_t format, const char* context) const
12032  {
12033  if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
12034  {
12035  return sax->parse_error(chars_read, "<end of file>",
12036  parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
12037  }
12038  return true;
12039  }
12040 
12044  std::string get_token_string() const
12045  {
12046  std::array<char, 3> cr{ {} };
12047  static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
12048  return std::string{ cr.data() };
12049  }
12050 
12057  std::string exception_message(const input_format_t format,
12058  const std::string& detail,
12059  const std::string& context) const
12060  {
12061  std::string error_msg = "syntax error while parsing ";
12062 
12063  switch (format)
12064  {
12065  case input_format_t::cbor:
12066  error_msg += "CBOR";
12067  break;
12068 
12069  case input_format_t::msgpack:
12070  error_msg += "MessagePack";
12071  break;
12072 
12073  case input_format_t::ubjson:
12074  error_msg += "UBJSON";
12075  break;
12076 
12077  case input_format_t::bson:
12078  error_msg += "BSON";
12079  break;
12080 
12081  case input_format_t::bjdata:
12082  error_msg += "BJData";
12083  break;
12084 
12085  case input_format_t::json: // LCOV_EXCL_LINE
12086  default: // LCOV_EXCL_LINE
12087  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
12088  }
12089 
12090  return concat(error_msg, ' ', context, ": ", detail);
12091  }
12092 
12093  private:
12094  static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
12095 
12097  InputAdapterType ia;
12098 
12100  char_int_type current = char_traits<char_type>::eof();
12101 
12103  std::size_t chars_read = 0;
12104 
12106  const bool is_little_endian = little_endianness();
12107 
12109  const input_format_t input_format = input_format_t::json;
12110 
12112  json_sax_t* sax = nullptr;
12113 
12114  // excluded markers in bjdata optimized type
12115 #define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
12116  make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
12117 
12118 #define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
12119  make_array<bjd_type>( \
12120  bjd_type{'C', "char"}, \
12121  bjd_type{'D', "double"}, \
12122  bjd_type{'I', "int16"}, \
12123  bjd_type{'L', "int64"}, \
12124  bjd_type{'M', "uint64"}, \
12125  bjd_type{'U', "uint8"}, \
12126  bjd_type{'d', "single"}, \
12127  bjd_type{'i', "int8"}, \
12128  bjd_type{'l', "int32"}, \
12129  bjd_type{'m', "uint32"}, \
12130  bjd_type{'u', "uint16"})
12131 
12132  JSON_PRIVATE_UNLESS_TESTED:
12133  // lookup tables
12134  // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
12135  const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
12136  JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
12137 
12138  using bjd_type = std::pair<char_int_type, string_t>;
12139  // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
12140  const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
12141  JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
12142 
12143 #undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
12144 #undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
12145  };
12146 
12147 #ifndef JSON_HAS_CPP_17
12148  template<typename BasicJsonType, typename InputAdapterType, typename SAX>
12149  constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
12150 #endif
12151 
12152 } // namespace detail
12153 NLOHMANN_JSON_NAMESPACE_END
12154 
12155 // #include <nlohmann/detail/input/input_adapters.hpp>
12156 
12157 // #include <nlohmann/detail/input/lexer.hpp>
12158 
12159 // #include <nlohmann/detail/input/parser.hpp>
12160 // __ _____ _____ _____
12161 // __| | __| | | | JSON for Modern C++
12162 // | | |__ | | | | | | version 3.11.3
12163 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
12164 //
12165 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
12166 // SPDX-License-Identifier: MIT
12167 
12168 
12169 
12170 #include <cmath> // isfinite
12171 #include <cstdint> // uint8_t
12172 #include <functional> // function
12173 #include <string> // string
12174 #include <utility> // move
12175 #include <vector> // vector
12176 
12177 // #include <nlohmann/detail/exceptions.hpp>
12178 
12179 // #include <nlohmann/detail/input/input_adapters.hpp>
12180 
12181 // #include <nlohmann/detail/input/json_sax.hpp>
12182 
12183 // #include <nlohmann/detail/input/lexer.hpp>
12184 
12185 // #include <nlohmann/detail/macro_scope.hpp>
12186 
12187 // #include <nlohmann/detail/meta/is_sax.hpp>
12188 
12189 // #include <nlohmann/detail/string_concat.hpp>
12190 
12191 // #include <nlohmann/detail/value_t.hpp>
12192 
12193 
12194 NLOHMANN_JSON_NAMESPACE_BEGIN
12195 namespace detail
12196 {
12198  // parser //
12200 
12201  enum class parse_event_t : std::uint8_t
12202  {
12204  object_start,
12206  object_end,
12208  array_start,
12210  array_end,
12212  key,
12214  value
12215  };
12216 
12217  template<typename BasicJsonType>
12218  using parser_callback_t =
12219  std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
12220 
12226  template<typename BasicJsonType, typename InputAdapterType>
12227  class parser
12228  {
12229  using number_integer_t = typename BasicJsonType::number_integer_t;
12230  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
12231  using number_float_t = typename BasicJsonType::number_float_t;
12232  using string_t = typename BasicJsonType::string_t;
12233  using lexer_t = lexer<BasicJsonType, InputAdapterType>;
12234  using token_type = typename lexer_t::token_type;
12235 
12236  public:
12238  explicit parser(InputAdapterType&& adapter,
12239  const parser_callback_t<BasicJsonType> cb = nullptr,
12240  const bool allow_exceptions_ = true,
12241  const bool skip_comments = false)
12242  : callback(cb)
12243  , m_lexer(std::move(adapter), skip_comments)
12244  , allow_exceptions(allow_exceptions_)
12245  {
12246  // read first token
12247  get_token();
12248  }
12249 
12260  void parse(const bool strict, BasicJsonType& result)
12261  {
12262  if (callback)
12263  {
12264  json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
12265  sax_parse_internal(&sdp);
12266 
12267  // in strict mode, input must be completely read
12268  if (strict && (get_token() != token_type::end_of_input))
12269  {
12270  sdp.parse_error(m_lexer.get_position(),
12271  m_lexer.get_token_string(),
12272  parse_error::create(101, m_lexer.get_position(),
12273  exception_message(token_type::end_of_input, "value"), nullptr));
12274  }
12275 
12276  // in case of an error, return discarded value
12277  if (sdp.is_errored())
12278  {
12279  result = value_t::discarded;
12280  return;
12281  }
12282 
12283  // set top-level value to null if it was discarded by the callback
12284  // function
12285  if (result.is_discarded())
12286  {
12287  result = nullptr;
12288  }
12289  }
12290  else
12291  {
12292  json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
12293  sax_parse_internal(&sdp);
12294 
12295  // in strict mode, input must be completely read
12296  if (strict && (get_token() != token_type::end_of_input))
12297  {
12298  sdp.parse_error(m_lexer.get_position(),
12299  m_lexer.get_token_string(),
12300  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
12301  }
12302 
12303  // in case of an error, return discarded value
12304  if (sdp.is_errored())
12305  {
12306  result = value_t::discarded;
12307  return;
12308  }
12309  }
12310 
12311  result.assert_invariant();
12312  }
12313 
12320  bool accept(const bool strict = true)
12321  {
12322  json_sax_acceptor<BasicJsonType> sax_acceptor;
12323  return sax_parse(&sax_acceptor, strict);
12324  }
12325 
12326  template<typename SAX>
12327  JSON_HEDLEY_NON_NULL(2)
12328  bool sax_parse(SAX* sax, const bool strict = true)
12329  {
12330  (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
12331  const bool result = sax_parse_internal(sax);
12332 
12333  // strict mode: next byte must be EOF
12334  if (result && strict && (get_token() != token_type::end_of_input))
12335  {
12336  return sax->parse_error(m_lexer.get_position(),
12337  m_lexer.get_token_string(),
12338  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
12339  }
12340 
12341  return result;
12342  }
12343 
12344  private:
12345  template<typename SAX>
12346  JSON_HEDLEY_NON_NULL(2)
12347  bool sax_parse_internal(SAX* sax)
12348  {
12349  // stack to remember the hierarchy of structured values we are parsing
12350  // true = array; false = object
12351  std::vector<bool> states;
12352  // value to avoid a goto (see comment where set to true)
12353  bool skip_to_state_evaluation = false;
12354 
12355  while (true)
12356  {
12357  if (!skip_to_state_evaluation)
12358  {
12359  // invariant: get_token() was called before each iteration
12360  switch (last_token)
12361  {
12362  case token_type::begin_object:
12363  {
12364  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
12365  {
12366  return false;
12367  }
12368 
12369  // closing } -> we are done
12370  if (get_token() == token_type::end_object)
12371  {
12372  if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
12373  {
12374  return false;
12375  }
12376  break;
12377  }
12378 
12379  // parse key
12380  if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
12381  {
12382  return sax->parse_error(m_lexer.get_position(),
12383  m_lexer.get_token_string(),
12384  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
12385  }
12386  if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
12387  {
12388  return false;
12389  }
12390 
12391  // parse separator (:)
12392  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
12393  {
12394  return sax->parse_error(m_lexer.get_position(),
12395  m_lexer.get_token_string(),
12396  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
12397  }
12398 
12399  // remember we are now inside an object
12400  states.push_back(false);
12401 
12402  // parse values
12403  get_token();
12404  continue;
12405  }
12406 
12407  case token_type::begin_array:
12408  {
12409  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
12410  {
12411  return false;
12412  }
12413 
12414  // closing ] -> we are done
12415  if (get_token() == token_type::end_array)
12416  {
12417  if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
12418  {
12419  return false;
12420  }
12421  break;
12422  }
12423 
12424  // remember we are now inside an array
12425  states.push_back(true);
12426 
12427  // parse values (no need to call get_token)
12428  continue;
12429  }
12430 
12431  case token_type::value_float:
12432  {
12433  const auto res = m_lexer.get_number_float();
12434 
12435  if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
12436  {
12437  return sax->parse_error(m_lexer.get_position(),
12438  m_lexer.get_token_string(),
12439  out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
12440  }
12441 
12442  if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
12443  {
12444  return false;
12445  }
12446 
12447  break;
12448  }
12449 
12450  case token_type::literal_false:
12451  {
12452  if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
12453  {
12454  return false;
12455  }
12456  break;
12457  }
12458 
12459  case token_type::literal_null:
12460  {
12461  if (JSON_HEDLEY_UNLIKELY(!sax->null()))
12462  {
12463  return false;
12464  }
12465  break;
12466  }
12467 
12468  case token_type::literal_true:
12469  {
12470  if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
12471  {
12472  return false;
12473  }
12474  break;
12475  }
12476 
12477  case token_type::value_integer:
12478  {
12479  if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
12480  {
12481  return false;
12482  }
12483  break;
12484  }
12485 
12486  case token_type::value_string:
12487  {
12488  if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
12489  {
12490  return false;
12491  }
12492  break;
12493  }
12494 
12495  case token_type::value_unsigned:
12496  {
12497  if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
12498  {
12499  return false;
12500  }
12501  break;
12502  }
12503 
12504  case token_type::parse_error:
12505  {
12506  // using "uninitialized" to avoid "expected" message
12507  return sax->parse_error(m_lexer.get_position(),
12508  m_lexer.get_token_string(),
12509  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
12510  }
12511  case token_type::end_of_input:
12512  {
12513  if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
12514  {
12515  return sax->parse_error(m_lexer.get_position(),
12516  m_lexer.get_token_string(),
12517  parse_error::create(101, m_lexer.get_position(),
12518  "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
12519  }
12520 
12521  return sax->parse_error(m_lexer.get_position(),
12522  m_lexer.get_token_string(),
12523  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
12524  }
12525  case token_type::uninitialized:
12526  case token_type::end_array:
12527  case token_type::end_object:
12528  case token_type::name_separator:
12529  case token_type::value_separator:
12530  case token_type::literal_or_value:
12531  default: // the last token was unexpected
12532  {
12533  return sax->parse_error(m_lexer.get_position(),
12534  m_lexer.get_token_string(),
12535  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
12536  }
12537  }
12538  }
12539  else
12540  {
12541  skip_to_state_evaluation = false;
12542  }
12543 
12544  // we reached this line after we successfully parsed a value
12545  if (states.empty())
12546  {
12547  // empty stack: we reached the end of the hierarchy: done
12548  return true;
12549  }
12550 
12551  if (states.back()) // array
12552  {
12553  // comma -> next value
12554  if (get_token() == token_type::value_separator)
12555  {
12556  // parse a new value
12557  get_token();
12558  continue;
12559  }
12560 
12561  // closing ]
12562  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
12563  {
12564  if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
12565  {
12566  return false;
12567  }
12568 
12569  // We are done with this array. Before we can parse a
12570  // new value, we need to evaluate the new state first.
12571  // By setting skip_to_state_evaluation to false, we
12572  // are effectively jumping to the beginning of this if.
12573  JSON_ASSERT(!states.empty());
12574  states.pop_back();
12575  skip_to_state_evaluation = true;
12576  continue;
12577  }
12578 
12579  return sax->parse_error(m_lexer.get_position(),
12580  m_lexer.get_token_string(),
12581  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
12582  }
12583 
12584  // states.back() is false -> object
12585 
12586  // comma -> next value
12587  if (get_token() == token_type::value_separator)
12588  {
12589  // parse key
12590  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
12591  {
12592  return sax->parse_error(m_lexer.get_position(),
12593  m_lexer.get_token_string(),
12594  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
12595  }
12596 
12597  if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
12598  {
12599  return false;
12600  }
12601 
12602  // parse separator (:)
12603  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
12604  {
12605  return sax->parse_error(m_lexer.get_position(),
12606  m_lexer.get_token_string(),
12607  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
12608  }
12609 
12610  // parse values
12611  get_token();
12612  continue;
12613  }
12614 
12615  // closing }
12616  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
12617  {
12618  if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
12619  {
12620  return false;
12621  }
12622 
12623  // We are done with this object. Before we can parse a
12624  // new value, we need to evaluate the new state first.
12625  // By setting skip_to_state_evaluation to false, we
12626  // are effectively jumping to the beginning of this if.
12627  JSON_ASSERT(!states.empty());
12628  states.pop_back();
12629  skip_to_state_evaluation = true;
12630  continue;
12631  }
12632 
12633  return sax->parse_error(m_lexer.get_position(),
12634  m_lexer.get_token_string(),
12635  parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
12636  }
12637  }
12638 
12640  token_type get_token()
12641  {
12642  return last_token = m_lexer.scan();
12643  }
12644 
12645  std::string exception_message(const token_type expected, const std::string& context)
12646  {
12647  std::string error_msg = "syntax error ";
12648 
12649  if (!context.empty())
12650  {
12651  error_msg += concat("while parsing ", context, ' ');
12652  }
12653 
12654  error_msg += "- ";
12655 
12656  if (last_token == token_type::parse_error)
12657  {
12658  error_msg += concat(m_lexer.get_error_message(), "; last read: '",
12659  m_lexer.get_token_string(), '\'');
12660  }
12661  else
12662  {
12663  error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
12664  }
12665 
12666  if (expected != token_type::uninitialized)
12667  {
12668  error_msg += concat("; expected ", lexer_t::token_type_name(expected));
12669  }
12670 
12671  return error_msg;
12672  }
12673 
12674  private:
12676  const parser_callback_t<BasicJsonType> callback = nullptr;
12678  token_type last_token = token_type::uninitialized;
12680  lexer_t m_lexer;
12682  const bool allow_exceptions = true;
12683  };
12684 
12685 } // namespace detail
12686 NLOHMANN_JSON_NAMESPACE_END
12687 
12688 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
12689 // __ _____ _____ _____
12690 // __| | __| | | | JSON for Modern C++
12691 // | | |__ | | | | | | version 3.11.3
12692 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
12693 //
12694 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
12695 // SPDX-License-Identifier: MIT
12696 
12697 
12698 
12699 // #include <nlohmann/detail/abi_macros.hpp>
12700 
12701 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
12702 // __ _____ _____ _____
12703 // __| | __| | | | JSON for Modern C++
12704 // | | |__ | | | | | | version 3.11.3
12705 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
12706 //
12707 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
12708 // SPDX-License-Identifier: MIT
12709 
12710 
12711 
12712 #include <cstddef> // ptrdiff_t
12713 #include <limits> // numeric_limits
12714 
12715 // #include <nlohmann/detail/macro_scope.hpp>
12716 
12717 
12718 NLOHMANN_JSON_NAMESPACE_BEGIN
12719 namespace detail
12720 {
12721 
12722  /*
12723  @brief an iterator for primitive JSON types
12724 
12725  This class models an iterator for primitive JSON types (boolean, number,
12726  string). It's only purpose is to allow the iterator/const_iterator classes
12727  to "iterate" over primitive values. Internally, the iterator is modeled by
12728  a `difference_type` variable. Value begin_value (`0`) models the begin,
12729  end_value (`1`) models past the end.
12730  */
12731  class primitive_iterator_t
12732  {
12733  private:
12734  using difference_type = std::ptrdiff_t;
12735  static constexpr difference_type begin_value = 0;
12736  static constexpr difference_type end_value = begin_value + 1;
12737 
12738  JSON_PRIVATE_UNLESS_TESTED:
12740  difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
12741 
12742  public:
12743  constexpr difference_type get_value() const noexcept
12744  {
12745  return m_it;
12746  }
12747 
12749  void set_begin() noexcept
12750  {
12751  m_it = begin_value;
12752  }
12753 
12755  void set_end() noexcept
12756  {
12757  m_it = end_value;
12758  }
12759 
12761  constexpr bool is_begin() const noexcept
12762  {
12763  return m_it == begin_value;
12764  }
12765 
12767  constexpr bool is_end() const noexcept
12768  {
12769  return m_it == end_value;
12770  }
12771 
12772  friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
12773  {
12774  return lhs.m_it == rhs.m_it;
12775  }
12776 
12777  friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
12778  {
12779  return lhs.m_it < rhs.m_it;
12780  }
12781 
12782  primitive_iterator_t operator+(difference_type n) noexcept
12783  {
12784  auto result = *this;
12785  result += n;
12786  return result;
12787  }
12788 
12789  friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
12790  {
12791  return lhs.m_it - rhs.m_it;
12792  }
12793 
12794  primitive_iterator_t& operator++() noexcept
12795  {
12796  ++m_it;
12797  return *this;
12798  }
12799 
12800  primitive_iterator_t operator++(int)&noexcept // NOLINT(cert-dcl21-cpp)
12801  {
12802  auto result = *this;
12803  ++m_it;
12804  return result;
12805  }
12806 
12807  primitive_iterator_t& operator--() noexcept
12808  {
12809  --m_it;
12810  return *this;
12811  }
12812 
12813  primitive_iterator_t operator--(int)&noexcept // NOLINT(cert-dcl21-cpp)
12814  {
12815  auto result = *this;
12816  --m_it;
12817  return result;
12818  }
12819 
12820  primitive_iterator_t& operator+=(difference_type n) noexcept
12821  {
12822  m_it += n;
12823  return *this;
12824  }
12825 
12826  primitive_iterator_t& operator-=(difference_type n) noexcept
12827  {
12828  m_it -= n;
12829  return *this;
12830  }
12831  };
12832 
12833 } // namespace detail
12834 NLOHMANN_JSON_NAMESPACE_END
12835 
12836 
12837 NLOHMANN_JSON_NAMESPACE_BEGIN
12838 namespace detail
12839 {
12840 
12847  template<typename BasicJsonType> struct internal_iterator
12848  {
12850  typename BasicJsonType::object_t::iterator object_iterator{};
12852  typename BasicJsonType::array_t::iterator array_iterator{};
12854  primitive_iterator_t primitive_iterator{};
12855  };
12856 
12857 } // namespace detail
12858 NLOHMANN_JSON_NAMESPACE_END
12859 
12860 // #include <nlohmann/detail/iterators/iter_impl.hpp>
12861 // __ _____ _____ _____
12862 // __| | __| | | | JSON for Modern C++
12863 // | | |__ | | | | | | version 3.11.3
12864 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
12865 //
12866 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
12867 // SPDX-License-Identifier: MIT
12868 
12869 
12870 
12871 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
12872 #include <type_traits> // conditional, is_const, remove_const
12873 
12874 // #include <nlohmann/detail/exceptions.hpp>
12875 
12876 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
12877 
12878 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
12879 
12880 // #include <nlohmann/detail/macro_scope.hpp>
12881 
12882 // #include <nlohmann/detail/meta/cpp_future.hpp>
12883 
12884 // #include <nlohmann/detail/meta/type_traits.hpp>
12885 
12886 // #include <nlohmann/detail/value_t.hpp>
12887 
12888 
12889 NLOHMANN_JSON_NAMESPACE_BEGIN
12890 namespace detail
12891 {
12892 
12893  // forward declare, to be able to friend it later on
12894  template<typename IteratorType> class iteration_proxy;
12895  template<typename IteratorType> class iteration_proxy_value;
12896 
12913  template<typename BasicJsonType>
12914  class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
12915  {
12917  using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
12919  friend other_iter_impl;
12920  friend BasicJsonType;
12921  friend iteration_proxy<iter_impl>;
12922  friend iteration_proxy_value<iter_impl>;
12923 
12924  using object_t = typename BasicJsonType::object_t;
12925  using array_t = typename BasicJsonType::array_t;
12926  // make sure BasicJsonType is basic_json or const basic_json
12927  static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
12928  "iter_impl only accepts (const) basic_json");
12929  // superficial check for the LegacyBidirectionalIterator named requirement
12930  static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
12931  && std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
12932  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
12933 
12934  public:
12940  using iterator_category = std::bidirectional_iterator_tag;
12941 
12943  using value_type = typename BasicJsonType::value_type;
12945  using difference_type = typename BasicJsonType::difference_type;
12947  using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
12948  typename BasicJsonType::const_pointer,
12949  typename BasicJsonType::pointer>::type;
12951  using reference =
12952  typename std::conditional<std::is_const<BasicJsonType>::value,
12953  typename BasicJsonType::const_reference,
12954  typename BasicJsonType::reference>::type;
12955 
12956  iter_impl() = default;
12957  ~iter_impl() = default;
12958  iter_impl(iter_impl&&) noexcept = default;
12959  iter_impl& operator=(iter_impl&&) noexcept = default;
12960 
12967  explicit iter_impl(pointer object) noexcept : m_object(object)
12968  {
12969  JSON_ASSERT(m_object != nullptr);
12970 
12971  switch (m_object->m_data.m_type)
12972  {
12973  case value_t::object:
12974  {
12975  m_it.object_iterator = typename object_t::iterator();
12976  break;
12977  }
12978 
12979  case value_t::array:
12980  {
12981  m_it.array_iterator = typename array_t::iterator();
12982  break;
12983  }
12984 
12985  case value_t::null:
12986  case value_t::string:
12987  case value_t::boolean:
12988  case value_t::number_integer:
12989  case value_t::number_unsigned:
12990  case value_t::number_float:
12991  case value_t::binary:
12992  case value_t::discarded:
12993  default:
12994  {
12995  m_it.primitive_iterator = primitive_iterator_t();
12996  break;
12997  }
12998  }
12999  }
13000 
13017  iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
13018  : m_object(other.m_object), m_it(other.m_it)
13019  {}
13020 
13027  iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
13028  {
13029  if (&other != this)
13030  {
13031  m_object = other.m_object;
13032  m_it = other.m_it;
13033  }
13034  return *this;
13035  }
13036 
13042  iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
13043  : m_object(other.m_object), m_it(other.m_it)
13044  {}
13045 
13052  iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
13053  {
13054  m_object = other.m_object;
13055  m_it = other.m_it;
13056  return *this;
13057  }
13058 
13059  JSON_PRIVATE_UNLESS_TESTED:
13064  void set_begin() noexcept
13065  {
13066  JSON_ASSERT(m_object != nullptr);
13067 
13068  switch (m_object->m_data.m_type)
13069  {
13070  case value_t::object:
13071  {
13072  m_it.object_iterator = m_object->m_data.m_value.object->begin();
13073  break;
13074  }
13075 
13076  case value_t::array:
13077  {
13078  m_it.array_iterator = m_object->m_data.m_value.array->begin();
13079  break;
13080  }
13081 
13082  case value_t::null:
13083  {
13084  // set to end so begin()==end() is true: null is empty
13085  m_it.primitive_iterator.set_end();
13086  break;
13087  }
13088 
13089  case value_t::string:
13090  case value_t::boolean:
13091  case value_t::number_integer:
13092  case value_t::number_unsigned:
13093  case value_t::number_float:
13094  case value_t::binary:
13095  case value_t::discarded:
13096  default:
13097  {
13098  m_it.primitive_iterator.set_begin();
13099  break;
13100  }
13101  }
13102  }
13103 
13108  void set_end() noexcept
13109  {
13110  JSON_ASSERT(m_object != nullptr);
13111 
13112  switch (m_object->m_data.m_type)
13113  {
13114  case value_t::object:
13115  {
13116  m_it.object_iterator = m_object->m_data.m_value.object->end();
13117  break;
13118  }
13119 
13120  case value_t::array:
13121  {
13122  m_it.array_iterator = m_object->m_data.m_value.array->end();
13123  break;
13124  }
13125 
13126  case value_t::null:
13127  case value_t::string:
13128  case value_t::boolean:
13129  case value_t::number_integer:
13130  case value_t::number_unsigned:
13131  case value_t::number_float:
13132  case value_t::binary:
13133  case value_t::discarded:
13134  default:
13135  {
13136  m_it.primitive_iterator.set_end();
13137  break;
13138  }
13139  }
13140  }
13141 
13142  public:
13147  reference operator*() const
13148  {
13149  JSON_ASSERT(m_object != nullptr);
13150 
13151  switch (m_object->m_data.m_type)
13152  {
13153  case value_t::object:
13154  {
13155  JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
13156  return m_it.object_iterator->second;
13157  }
13158 
13159  case value_t::array:
13160  {
13161  JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
13162  return *m_it.array_iterator;
13163  }
13164 
13165  case value_t::null:
13166  JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13167 
13168  case value_t::string:
13169  case value_t::boolean:
13170  case value_t::number_integer:
13171  case value_t::number_unsigned:
13172  case value_t::number_float:
13173  case value_t::binary:
13174  case value_t::discarded:
13175  default:
13176  {
13177  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
13178  {
13179  return *m_object;
13180  }
13181 
13182  JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13183  }
13184  }
13185  }
13186 
13191  pointer operator->() const
13192  {
13193  JSON_ASSERT(m_object != nullptr);
13194 
13195  switch (m_object->m_data.m_type)
13196  {
13197  case value_t::object:
13198  {
13199  JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
13200  return &(m_it.object_iterator->second);
13201  }
13202 
13203  case value_t::array:
13204  {
13205  JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
13206  return &*m_it.array_iterator;
13207  }
13208 
13209  case value_t::null:
13210  case value_t::string:
13211  case value_t::boolean:
13212  case value_t::number_integer:
13213  case value_t::number_unsigned:
13214  case value_t::number_float:
13215  case value_t::binary:
13216  case value_t::discarded:
13217  default:
13218  {
13219  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
13220  {
13221  return m_object;
13222  }
13223 
13224  JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13225  }
13226  }
13227  }
13228 
13233  iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
13234  {
13235  auto result = *this;
13236  ++(*this);
13237  return result;
13238  }
13239 
13244  iter_impl& operator++()
13245  {
13246  JSON_ASSERT(m_object != nullptr);
13247 
13248  switch (m_object->m_data.m_type)
13249  {
13250  case value_t::object:
13251  {
13252  std::advance(m_it.object_iterator, 1);
13253  break;
13254  }
13255 
13256  case value_t::array:
13257  {
13258  std::advance(m_it.array_iterator, 1);
13259  break;
13260  }
13261 
13262  case value_t::null:
13263  case value_t::string:
13264  case value_t::boolean:
13265  case value_t::number_integer:
13266  case value_t::number_unsigned:
13267  case value_t::number_float:
13268  case value_t::binary:
13269  case value_t::discarded:
13270  default:
13271  {
13272  ++m_it.primitive_iterator;
13273  break;
13274  }
13275  }
13276 
13277  return *this;
13278  }
13279 
13284  iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
13285  {
13286  auto result = *this;
13287  --(*this);
13288  return result;
13289  }
13290 
13295  iter_impl& operator--()
13296  {
13297  JSON_ASSERT(m_object != nullptr);
13298 
13299  switch (m_object->m_data.m_type)
13300  {
13301  case value_t::object:
13302  {
13303  std::advance(m_it.object_iterator, -1);
13304  break;
13305  }
13306 
13307  case value_t::array:
13308  {
13309  std::advance(m_it.array_iterator, -1);
13310  break;
13311  }
13312 
13313  case value_t::null:
13314  case value_t::string:
13315  case value_t::boolean:
13316  case value_t::number_integer:
13317  case value_t::number_unsigned:
13318  case value_t::number_float:
13319  case value_t::binary:
13320  case value_t::discarded:
13321  default:
13322  {
13323  --m_it.primitive_iterator;
13324  break;
13325  }
13326  }
13327 
13328  return *this;
13329  }
13330 
13335  template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
13336  bool operator==(const IterImpl& other) const
13337  {
13338  // if objects are not the same, the comparison is undefined
13339  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
13340  {
13341  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
13342  }
13343 
13344  JSON_ASSERT(m_object != nullptr);
13345 
13346  switch (m_object->m_data.m_type)
13347  {
13348  case value_t::object:
13349  return (m_it.object_iterator == other.m_it.object_iterator);
13350 
13351  case value_t::array:
13352  return (m_it.array_iterator == other.m_it.array_iterator);
13353 
13354  case value_t::null:
13355  case value_t::string:
13356  case value_t::boolean:
13357  case value_t::number_integer:
13358  case value_t::number_unsigned:
13359  case value_t::number_float:
13360  case value_t::binary:
13361  case value_t::discarded:
13362  default:
13363  return (m_it.primitive_iterator == other.m_it.primitive_iterator);
13364  }
13365  }
13366 
13371  template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
13372  bool operator!=(const IterImpl& other) const
13373  {
13374  return !operator==(other);
13375  }
13376 
13381  bool operator<(const iter_impl& other) const
13382  {
13383  // if objects are not the same, the comparison is undefined
13384  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
13385  {
13386  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
13387  }
13388 
13389  JSON_ASSERT(m_object != nullptr);
13390 
13391  switch (m_object->m_data.m_type)
13392  {
13393  case value_t::object:
13394  JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
13395 
13396  case value_t::array:
13397  return (m_it.array_iterator < other.m_it.array_iterator);
13398 
13399  case value_t::null:
13400  case value_t::string:
13401  case value_t::boolean:
13402  case value_t::number_integer:
13403  case value_t::number_unsigned:
13404  case value_t::number_float:
13405  case value_t::binary:
13406  case value_t::discarded:
13407  default:
13408  return (m_it.primitive_iterator < other.m_it.primitive_iterator);
13409  }
13410  }
13411 
13416  bool operator<=(const iter_impl& other) const
13417  {
13418  return !other.operator < (*this);
13419  }
13420 
13425  bool operator>(const iter_impl& other) const
13426  {
13427  return !operator<=(other);
13428  }
13429 
13434  bool operator>=(const iter_impl& other) const
13435  {
13436  return !operator<(other);
13437  }
13438 
13443  iter_impl& operator+=(difference_type i)
13444  {
13445  JSON_ASSERT(m_object != nullptr);
13446 
13447  switch (m_object->m_data.m_type)
13448  {
13449  case value_t::object:
13450  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
13451 
13452  case value_t::array:
13453  {
13454  std::advance(m_it.array_iterator, i);
13455  break;
13456  }
13457 
13458  case value_t::null:
13459  case value_t::string:
13460  case value_t::boolean:
13461  case value_t::number_integer:
13462  case value_t::number_unsigned:
13463  case value_t::number_float:
13464  case value_t::binary:
13465  case value_t::discarded:
13466  default:
13467  {
13468  m_it.primitive_iterator += i;
13469  break;
13470  }
13471  }
13472 
13473  return *this;
13474  }
13475 
13480  iter_impl& operator-=(difference_type i)
13481  {
13482  return operator+=(-i);
13483  }
13484 
13489  iter_impl operator+(difference_type i) const
13490  {
13491  auto result = *this;
13492  result += i;
13493  return result;
13494  }
13495 
13500  friend iter_impl operator+(difference_type i, const iter_impl& it)
13501  {
13502  auto result = it;
13503  result += i;
13504  return result;
13505  }
13506 
13511  iter_impl operator-(difference_type i) const
13512  {
13513  auto result = *this;
13514  result -= i;
13515  return result;
13516  }
13517 
13522  difference_type operator-(const iter_impl& other) const
13523  {
13524  JSON_ASSERT(m_object != nullptr);
13525 
13526  switch (m_object->m_data.m_type)
13527  {
13528  case value_t::object:
13529  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
13530 
13531  case value_t::array:
13532  return m_it.array_iterator - other.m_it.array_iterator;
13533 
13534  case value_t::null:
13535  case value_t::string:
13536  case value_t::boolean:
13537  case value_t::number_integer:
13538  case value_t::number_unsigned:
13539  case value_t::number_float:
13540  case value_t::binary:
13541  case value_t::discarded:
13542  default:
13543  return m_it.primitive_iterator - other.m_it.primitive_iterator;
13544  }
13545  }
13546 
13551  reference operator[](difference_type n) const
13552  {
13553  JSON_ASSERT(m_object != nullptr);
13554 
13555  switch (m_object->m_data.m_type)
13556  {
13557  case value_t::object:
13558  JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
13559 
13560  case value_t::array:
13561  return *std::next(m_it.array_iterator, n);
13562 
13563  case value_t::null:
13564  JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13565 
13566  case value_t::string:
13567  case value_t::boolean:
13568  case value_t::number_integer:
13569  case value_t::number_unsigned:
13570  case value_t::number_float:
13571  case value_t::binary:
13572  case value_t::discarded:
13573  default:
13574  {
13575  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
13576  {
13577  return *m_object;
13578  }
13579 
13580  JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13581  }
13582  }
13583  }
13584 
13589  const typename object_t::key_type& key() const
13590  {
13591  JSON_ASSERT(m_object != nullptr);
13592 
13593  if (JSON_HEDLEY_LIKELY(m_object->is_object()))
13594  {
13595  return m_it.object_iterator->first;
13596  }
13597 
13598  JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
13599  }
13600 
13605  reference value() const
13606  {
13607  return operator*();
13608  }
13609 
13610  JSON_PRIVATE_UNLESS_TESTED:
13612  pointer m_object = nullptr;
13614  internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it{};
13615  };
13616 
13617 } // namespace detail
13618 NLOHMANN_JSON_NAMESPACE_END
13619 
13620 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
13621 
13622 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
13623 // __ _____ _____ _____
13624 // __| | __| | | | JSON for Modern C++
13625 // | | |__ | | | | | | version 3.11.3
13626 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
13627 //
13628 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
13629 // SPDX-License-Identifier: MIT
13630 
13631 
13632 
13633 #include <cstddef> // ptrdiff_t
13634 #include <iterator> // reverse_iterator
13635 #include <utility> // declval
13636 
13637 // #include <nlohmann/detail/abi_macros.hpp>
13638 
13639 
13640 NLOHMANN_JSON_NAMESPACE_BEGIN
13641 namespace detail
13642 {
13643 
13645  // reverse_iterator //
13647 
13666  template<typename Base>
13667  class json_reverse_iterator : public std::reverse_iterator<Base>
13668  {
13669  public:
13670  using difference_type = std::ptrdiff_t;
13672  using base_iterator = std::reverse_iterator<Base>;
13674  using reference = typename Base::reference;
13675 
13677  explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
13678  : base_iterator(it) {}
13679 
13681  explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
13682 
13684  json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
13685  {
13686  return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
13687  }
13688 
13690  json_reverse_iterator& operator++()
13691  {
13692  return static_cast<json_reverse_iterator&>(base_iterator::operator++());
13693  }
13694 
13696  json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
13697  {
13698  return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
13699  }
13700 
13702  json_reverse_iterator& operator--()
13703  {
13704  return static_cast<json_reverse_iterator&>(base_iterator::operator--());
13705  }
13706 
13708  json_reverse_iterator& operator+=(difference_type i)
13709  {
13710  return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
13711  }
13712 
13714  json_reverse_iterator operator+(difference_type i) const
13715  {
13716  return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
13717  }
13718 
13720  json_reverse_iterator operator-(difference_type i) const
13721  {
13722  return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
13723  }
13724 
13726  difference_type operator-(const json_reverse_iterator& other) const
13727  {
13728  return base_iterator(*this) - base_iterator(other);
13729  }
13730 
13732  reference operator[](difference_type n) const
13733  {
13734  return *(this->operator+(n));
13735  }
13736 
13738  auto key() const -> decltype(std::declval<Base>().key())
13739  {
13740  auto it = --this->base();
13741  return it.key();
13742  }
13743 
13745  reference value() const
13746  {
13747  auto it = --this->base();
13748  return it.operator * ();
13749  }
13750  };
13751 
13752 } // namespace detail
13753 NLOHMANN_JSON_NAMESPACE_END
13754 
13755 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
13756 
13757 // #include <nlohmann/detail/json_custom_base_class.hpp>
13758 // __ _____ _____ _____
13759 // __| | __| | | | JSON for Modern C++
13760 // | | |__ | | | | | | version 3.11.3
13761 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
13762 //
13763 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
13764 // SPDX-License-Identifier: MIT
13765 
13766 
13767 
13768 #include <type_traits> // conditional, is_same
13769 
13770 // #include <nlohmann/detail/abi_macros.hpp>
13771 
13772 
13773 NLOHMANN_JSON_NAMESPACE_BEGIN
13774 namespace detail
13775 {
13776 
13787  struct json_default_base {};
13788 
13789  template<class T>
13790  using json_base_class = typename std::conditional <
13791  std::is_same<T, void>::value,
13792  json_default_base,
13793  T
13794  >::type;
13795 
13796 } // namespace detail
13797 NLOHMANN_JSON_NAMESPACE_END
13798 
13799 // #include <nlohmann/detail/json_pointer.hpp>
13800 // __ _____ _____ _____
13801 // __| | __| | | | JSON for Modern C++
13802 // | | |__ | | | | | | version 3.11.3
13803 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
13804 //
13805 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
13806 // SPDX-License-Identifier: MIT
13807 
13808 
13809 
13810 #include <algorithm> // all_of
13811 #include <cctype> // isdigit
13812 #include <cerrno> // errno, ERANGE
13813 #include <cstdlib> // strtoull
13814 #ifndef JSON_NO_IO
13815 #include <iosfwd> // ostream
13816 #endif // JSON_NO_IO
13817 #include <limits> // max
13818 #include <numeric> // accumulate
13819 #include <string> // string
13820 #include <utility> // move
13821 #include <vector> // vector
13822 
13823 // #include <nlohmann/detail/exceptions.hpp>
13824 
13825 // #include <nlohmann/detail/macro_scope.hpp>
13826 
13827 // #include <nlohmann/detail/string_concat.hpp>
13828 
13829 // #include <nlohmann/detail/string_escape.hpp>
13830 
13831 // #include <nlohmann/detail/value_t.hpp>
13832 
13833 
13834 NLOHMANN_JSON_NAMESPACE_BEGIN
13835 
13838 template<typename RefStringType>
13839 class json_pointer
13840 {
13841  // allow basic_json to access private members
13842  NLOHMANN_BASIC_JSON_TPL_DECLARATION
13843  friend class basic_json;
13844 
13845  template<typename>
13846  friend class json_pointer;
13847 
13848  template<typename T>
13849  struct string_t_helper
13850  {
13851  using type = T;
13852  };
13853 
13854  NLOHMANN_BASIC_JSON_TPL_DECLARATION
13855  struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
13856  {
13857  using type = StringType;
13858  };
13859 
13860 public:
13861  // for backwards compatibility accept BasicJsonType
13862  using string_t = typename string_t_helper<RefStringType>::type;
13863 
13866  explicit json_pointer(const string_t& s = "")
13867  : reference_tokens(split(s))
13868  {}
13869 
13872  string_t to_string() const
13873  {
13874  return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
13875  string_t{},
13876  [](const string_t& a, const string_t& b)
13877  {
13878  return detail::concat(a, '/', detail::escape(b));
13879  });
13880  }
13881 
13884  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
13885  operator string_t() const
13886  {
13887  return to_string();
13888  }
13889 
13890 #ifndef JSON_NO_IO
13893  friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
13894  {
13895  o << ptr.to_string();
13896  return o;
13897  }
13898 #endif
13899 
13902  json_pointer& operator/=(const json_pointer& ptr)
13903  {
13904  reference_tokens.insert(reference_tokens.end(),
13905  ptr.reference_tokens.begin(),
13906  ptr.reference_tokens.end());
13907  return *this;
13908  }
13909 
13912  json_pointer& operator/=(string_t token)
13913  {
13914  push_back(std::move(token));
13915  return *this;
13916  }
13917 
13920  json_pointer& operator/=(std::size_t array_idx)
13921  {
13922  return *this /= std::to_string(array_idx);
13923  }
13924 
13927  friend json_pointer operator/(const json_pointer& lhs,
13928  const json_pointer& rhs)
13929  {
13930  return json_pointer(lhs) /= rhs;
13931  }
13932 
13935  friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
13936  {
13937  return json_pointer(lhs) /= std::move(token);
13938  }
13939 
13942  friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
13943  {
13944  return json_pointer(lhs) /= array_idx;
13945  }
13946 
13949  json_pointer parent_pointer() const
13950  {
13951  if (empty())
13952  {
13953  return *this;
13954  }
13955 
13956  json_pointer res = *this;
13957  res.pop_back();
13958  return res;
13959  }
13960 
13963  void pop_back()
13964  {
13965  if (JSON_HEDLEY_UNLIKELY(empty()))
13966  {
13967  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
13968  }
13969 
13970  reference_tokens.pop_back();
13971  }
13972 
13975  const string_t& back() const
13976  {
13977  if (JSON_HEDLEY_UNLIKELY(empty()))
13978  {
13979  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
13980  }
13981 
13982  return reference_tokens.back();
13983  }
13984 
13987  void push_back(const string_t& token)
13988  {
13989  reference_tokens.push_back(token);
13990  }
13991 
13994  void push_back(string_t&& token)
13995  {
13996  reference_tokens.push_back(std::move(token));
13997  }
13998 
14001  bool empty() const noexcept
14002  {
14003  return reference_tokens.empty();
14004  }
14005 
14006 private:
14017  template<typename BasicJsonType>
14018  static typename BasicJsonType::size_type array_index(const string_t& s)
14019  {
14020  using size_type = typename BasicJsonType::size_type;
14021 
14022  // error condition (cf. RFC 6901, Sect. 4)
14023  if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
14024  {
14025  JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
14026  }
14027 
14028  // error condition (cf. RFC 6901, Sect. 4)
14029  if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
14030  {
14031  JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
14032  }
14033 
14034  const char* p = s.c_str();
14035  char* p_end = nullptr;
14036  errno = 0; // strtoull doesn't reset errno
14037  const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
14038  if (p == p_end // invalid input or empty string
14039  || errno == ERANGE // out of range
14040  || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
14041  {
14042  JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
14043  }
14044 
14045  // only triggered on special platforms (like 32bit), see also
14046  // https://github.com/nlohmann/json/pull/2203
14047  if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)())) // NOLINT(runtime/int)
14048  {
14049  JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr)); // LCOV_EXCL_LINE
14050  }
14051 
14052  return static_cast<size_type>(res);
14053  }
14054 
14055 JSON_PRIVATE_UNLESS_TESTED:
14056  json_pointer top() const
14057  {
14058  if (JSON_HEDLEY_UNLIKELY(empty()))
14059  {
14060  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
14061  }
14062 
14063  json_pointer result = *this;
14064  result.reference_tokens = { reference_tokens[0] };
14065  return result;
14066  }
14067 
14068 private:
14077  template<typename BasicJsonType>
14078  BasicJsonType& get_and_create(BasicJsonType& j) const
14079  {
14080  auto* result = &j;
14081 
14082  // in case no reference tokens exist, return a reference to the JSON value
14083  // j which will be overwritten by a primitive value
14084  for (const auto& reference_token : reference_tokens)
14085  {
14086  switch (result->type())
14087  {
14088  case detail::value_t::null:
14089  {
14090  if (reference_token == "0")
14091  {
14092  // start a new array if reference token is 0
14093  result = &result->operator[](0);
14094  }
14095  else
14096  {
14097  // start a new object otherwise
14098  result = &result->operator[](reference_token);
14099  }
14100  break;
14101  }
14102 
14103  case detail::value_t::object:
14104  {
14105  // create an entry in the object
14106  result = &result->operator[](reference_token);
14107  break;
14108  }
14109 
14110  case detail::value_t::array:
14111  {
14112  // create an entry in the array
14113  result = &result->operator[](array_index<BasicJsonType>(reference_token));
14114  break;
14115  }
14116 
14117  /*
14118  The following code is only reached if there exists a reference
14119  token _and_ the current value is primitive. In this case, we have
14120  an error situation, because primitive values may only occur as
14121  single value; that is, with an empty list of reference tokens.
14122  */
14123  case detail::value_t::string:
14124  case detail::value_t::boolean:
14125  case detail::value_t::number_integer:
14126  case detail::value_t::number_unsigned:
14127  case detail::value_t::number_float:
14128  case detail::value_t::binary:
14129  case detail::value_t::discarded:
14130  default:
14131  JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
14132  }
14133  }
14134 
14135  return *result;
14136  }
14137 
14157  template<typename BasicJsonType>
14158  BasicJsonType& get_unchecked(BasicJsonType* ptr) const
14159  {
14160  for (const auto& reference_token : reference_tokens)
14161  {
14162  // convert null values to arrays or objects before continuing
14163  if (ptr->is_null())
14164  {
14165  // check if reference token is a number
14166  const bool nums =
14167  std::all_of(reference_token.begin(), reference_token.end(),
14168  [](const unsigned char x)
14169  {
14170  return std::isdigit(x);
14171  });
14172 
14173  // change value to array for numbers or "-" or to object otherwise
14174  *ptr = (nums || reference_token == "-")
14175  ? detail::value_t::array
14176  : detail::value_t::object;
14177  }
14178 
14179  switch (ptr->type())
14180  {
14181  case detail::value_t::object:
14182  {
14183  // use unchecked object access
14184  ptr = &ptr->operator[](reference_token);
14185  break;
14186  }
14187 
14188  case detail::value_t::array:
14189  {
14190  if (reference_token == "-")
14191  {
14192  // explicitly treat "-" as index beyond the end
14193  ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
14194  }
14195  else
14196  {
14197  // convert array index to number; unchecked access
14198  ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
14199  }
14200  break;
14201  }
14202 
14203  case detail::value_t::null:
14204  case detail::value_t::string:
14205  case detail::value_t::boolean:
14206  case detail::value_t::number_integer:
14207  case detail::value_t::number_unsigned:
14208  case detail::value_t::number_float:
14209  case detail::value_t::binary:
14210  case detail::value_t::discarded:
14211  default:
14212  JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
14213  }
14214  }
14215 
14216  return *ptr;
14217  }
14218 
14225  template<typename BasicJsonType>
14226  BasicJsonType& get_checked(BasicJsonType* ptr) const
14227  {
14228  for (const auto& reference_token : reference_tokens)
14229  {
14230  switch (ptr->type())
14231  {
14232  case detail::value_t::object:
14233  {
14234  // note: at performs range check
14235  ptr = &ptr->at(reference_token);
14236  break;
14237  }
14238 
14239  case detail::value_t::array:
14240  {
14241  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
14242  {
14243  // "-" always fails the range check
14244  JSON_THROW(detail::out_of_range::create(402, detail::concat(
14245  "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
14246  ") is out of range"), ptr));
14247  }
14248 
14249  // note: at performs range check
14250  ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
14251  break;
14252  }
14253 
14254  case detail::value_t::null:
14255  case detail::value_t::string:
14256  case detail::value_t::boolean:
14257  case detail::value_t::number_integer:
14258  case detail::value_t::number_unsigned:
14259  case detail::value_t::number_float:
14260  case detail::value_t::binary:
14261  case detail::value_t::discarded:
14262  default:
14263  JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
14264  }
14265  }
14266 
14267  return *ptr;
14268  }
14269 
14283  template<typename BasicJsonType>
14284  const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
14285  {
14286  for (const auto& reference_token : reference_tokens)
14287  {
14288  switch (ptr->type())
14289  {
14290  case detail::value_t::object:
14291  {
14292  // use unchecked object access
14293  ptr = &ptr->operator[](reference_token);
14294  break;
14295  }
14296 
14297  case detail::value_t::array:
14298  {
14299  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
14300  {
14301  // "-" cannot be used for const access
14302  JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
14303  }
14304 
14305  // use unchecked array access
14306  ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
14307  break;
14308  }
14309 
14310  case detail::value_t::null:
14311  case detail::value_t::string:
14312  case detail::value_t::boolean:
14313  case detail::value_t::number_integer:
14314  case detail::value_t::number_unsigned:
14315  case detail::value_t::number_float:
14316  case detail::value_t::binary:
14317  case detail::value_t::discarded:
14318  default:
14319  JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
14320  }
14321  }
14322 
14323  return *ptr;
14324  }
14325 
14332  template<typename BasicJsonType>
14333  const BasicJsonType& get_checked(const BasicJsonType* ptr) const
14334  {
14335  for (const auto& reference_token : reference_tokens)
14336  {
14337  switch (ptr->type())
14338  {
14339  case detail::value_t::object:
14340  {
14341  // note: at performs range check
14342  ptr = &ptr->at(reference_token);
14343  break;
14344  }
14345 
14346  case detail::value_t::array:
14347  {
14348  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
14349  {
14350  // "-" always fails the range check
14351  JSON_THROW(detail::out_of_range::create(402, detail::concat(
14352  "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
14353  ") is out of range"), ptr));
14354  }
14355 
14356  // note: at performs range check
14357  ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
14358  break;
14359  }
14360 
14361  case detail::value_t::null:
14362  case detail::value_t::string:
14363  case detail::value_t::boolean:
14364  case detail::value_t::number_integer:
14365  case detail::value_t::number_unsigned:
14366  case detail::value_t::number_float:
14367  case detail::value_t::binary:
14368  case detail::value_t::discarded:
14369  default:
14370  JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
14371  }
14372  }
14373 
14374  return *ptr;
14375  }
14376 
14381  template<typename BasicJsonType>
14382  bool contains(const BasicJsonType* ptr) const
14383  {
14384  for (const auto& reference_token : reference_tokens)
14385  {
14386  switch (ptr->type())
14387  {
14388  case detail::value_t::object:
14389  {
14390  if (!ptr->contains(reference_token))
14391  {
14392  // we did not find the key in the object
14393  return false;
14394  }
14395 
14396  ptr = &ptr->operator[](reference_token);
14397  break;
14398  }
14399 
14400  case detail::value_t::array:
14401  {
14402  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
14403  {
14404  // "-" always fails the range check
14405  return false;
14406  }
14407  if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
14408  {
14409  // invalid char
14410  return false;
14411  }
14412  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
14413  {
14414  if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
14415  {
14416  // first char should be between '1' and '9'
14417  return false;
14418  }
14419  for (std::size_t i = 1; i < reference_token.size(); i++)
14420  {
14421  if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
14422  {
14423  // other char should be between '0' and '9'
14424  return false;
14425  }
14426  }
14427  }
14428 
14429  const auto idx = array_index<BasicJsonType>(reference_token);
14430  if (idx >= ptr->size())
14431  {
14432  // index out of range
14433  return false;
14434  }
14435 
14436  ptr = &ptr->operator[](idx);
14437  break;
14438  }
14439 
14440  case detail::value_t::null:
14441  case detail::value_t::string:
14442  case detail::value_t::boolean:
14443  case detail::value_t::number_integer:
14444  case detail::value_t::number_unsigned:
14445  case detail::value_t::number_float:
14446  case detail::value_t::binary:
14447  case detail::value_t::discarded:
14448  default:
14449  {
14450  // we do not expect primitive values if there is still a
14451  // reference token to process
14452  return false;
14453  }
14454  }
14455  }
14456 
14457  // no reference token left means we found a primitive value
14458  return true;
14459  }
14460 
14470  static std::vector<string_t> split(const string_t& reference_string)
14471  {
14472  std::vector<string_t> result;
14473 
14474  // special case: empty reference string -> no reference tokens
14475  if (reference_string.empty())
14476  {
14477  return result;
14478  }
14479 
14480  // check if nonempty reference string begins with slash
14481  if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
14482  {
14483  JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
14484  }
14485 
14486  // extract the reference tokens:
14487  // - slash: position of the last read slash (or end of string)
14488  // - start: position after the previous slash
14489  for (
14490  // search for the first slash after the first character
14491  std::size_t slash = reference_string.find_first_of('/', 1),
14492  // set the beginning of the first reference token
14493  start = 1;
14494  // we can stop if start == 0 (if slash == string_t::npos)
14495  start != 0;
14496  // set the beginning of the next reference token
14497  // (will eventually be 0 if slash == string_t::npos)
14498  start = (slash == string_t::npos) ? 0 : slash + 1,
14499  // find next slash
14500  slash = reference_string.find_first_of('/', start))
14501  {
14502  // use the text between the beginning of the reference token
14503  // (start) and the last slash (slash).
14504  auto reference_token = reference_string.substr(start, slash - start);
14505 
14506  // check reference tokens are properly escaped
14507  for (std::size_t pos = reference_token.find_first_of('~');
14508  pos != string_t::npos;
14509  pos = reference_token.find_first_of('~', pos + 1))
14510  {
14511  JSON_ASSERT(reference_token[pos] == '~');
14512 
14513  // ~ must be followed by 0 or 1
14514  if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
14515  (reference_token[pos + 1] != '0' &&
14516  reference_token[pos + 1] != '1')))
14517  {
14518  JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
14519  }
14520  }
14521 
14522  // finally, store the reference token
14523  detail::unescape(reference_token);
14524  result.push_back(reference_token);
14525  }
14526 
14527  return result;
14528  }
14529 
14530 private:
14538  template<typename BasicJsonType>
14539  static void flatten(const string_t& reference_string,
14540  const BasicJsonType& value,
14541  BasicJsonType& result)
14542  {
14543  switch (value.type())
14544  {
14545  case detail::value_t::array:
14546  {
14547  if (value.m_data.m_value.array->empty())
14548  {
14549  // flatten empty array as null
14550  result[reference_string] = nullptr;
14551  }
14552  else
14553  {
14554  // iterate array and use index as reference string
14555  for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
14556  {
14557  flatten(detail::concat(reference_string, '/', std::to_string(i)),
14558  value.m_data.m_value.array->operator[](i), result);
14559  }
14560  }
14561  break;
14562  }
14563 
14564  case detail::value_t::object:
14565  {
14566  if (value.m_data.m_value.object->empty())
14567  {
14568  // flatten empty object as null
14569  result[reference_string] = nullptr;
14570  }
14571  else
14572  {
14573  // iterate object and use keys as reference string
14574  for (const auto& element : *value.m_data.m_value.object)
14575  {
14576  flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
14577  }
14578  }
14579  break;
14580  }
14581 
14582  case detail::value_t::null:
14583  case detail::value_t::string:
14584  case detail::value_t::boolean:
14585  case detail::value_t::number_integer:
14586  case detail::value_t::number_unsigned:
14587  case detail::value_t::number_float:
14588  case detail::value_t::binary:
14589  case detail::value_t::discarded:
14590  default:
14591  {
14592  // add primitive value with its reference string
14593  result[reference_string] = value;
14594  break;
14595  }
14596  }
14597  }
14598 
14609  template<typename BasicJsonType>
14610  static BasicJsonType
14611  unflatten(const BasicJsonType& value)
14612  {
14613  if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
14614  {
14615  JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
14616  }
14617 
14618  BasicJsonType result;
14619 
14620  // iterate the JSON object values
14621  for (const auto& element : *value.m_data.m_value.object)
14622  {
14623  if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
14624  {
14625  JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
14626  }
14627 
14628  // assign value to reference pointed to by JSON pointer; Note that if
14629  // the JSON pointer is "" (i.e., points to the whole value), function
14630  // get_and_create returns a reference to result itself. An assignment
14631  // will then create a primitive value.
14632  json_pointer(element.first).get_and_create(result) = element.second;
14633  }
14634 
14635  return result;
14636  }
14637 
14638  // can't use conversion operator because of ambiguity
14639  json_pointer<string_t> convert() const&
14640  {
14641  json_pointer<string_t> result;
14642  result.reference_tokens = reference_tokens;
14643  return result;
14644  }
14645 
14646  json_pointer<string_t> convert()&&
14647  {
14648  json_pointer<string_t> result;
14649  result.reference_tokens = std::move(reference_tokens);
14650  return result;
14651  }
14652 
14653 public:
14654 #if JSON_HAS_THREE_WAY_COMPARISON
14657  template<typename RefStringTypeRhs>
14658  bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
14659  {
14660  return reference_tokens == rhs.reference_tokens;
14661  }
14662 
14665  JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
14666  bool operator==(const string_t& rhs) const
14667  {
14668  return *this == json_pointer(rhs);
14669  }
14670 
14672  template<typename RefStringTypeRhs>
14673  std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
14674  {
14675  return reference_tokens <=> rhs.reference_tokens; // *NOPAD*
14676  }
14677 #else
14680  template<typename RefStringTypeLhs, typename RefStringTypeRhs>
14681  // NOLINTNEXTLINE(readability-redundant-declaration)
14682  friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14683  const json_pointer<RefStringTypeRhs>& rhs) noexcept;
14684 
14687  template<typename RefStringTypeLhs, typename StringType>
14688  // NOLINTNEXTLINE(readability-redundant-declaration)
14689  friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14690  const StringType& rhs);
14691 
14694  template<typename RefStringTypeRhs, typename StringType>
14695  // NOLINTNEXTLINE(readability-redundant-declaration)
14696  friend bool operator==(const StringType& lhs,
14697  const json_pointer<RefStringTypeRhs>& rhs);
14698 
14701  template<typename RefStringTypeLhs, typename RefStringTypeRhs>
14702  // NOLINTNEXTLINE(readability-redundant-declaration)
14703  friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14704  const json_pointer<RefStringTypeRhs>& rhs) noexcept;
14705 
14708  template<typename RefStringTypeLhs, typename StringType>
14709  // NOLINTNEXTLINE(readability-redundant-declaration)
14710  friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14711  const StringType& rhs);
14712 
14715  template<typename RefStringTypeRhs, typename StringType>
14716  // NOLINTNEXTLINE(readability-redundant-declaration)
14717  friend bool operator!=(const StringType& lhs,
14718  const json_pointer<RefStringTypeRhs>& rhs);
14719 
14721  template<typename RefStringTypeLhs, typename RefStringTypeRhs>
14722  // NOLINTNEXTLINE(readability-redundant-declaration)
14723  friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
14724  const json_pointer<RefStringTypeRhs>& rhs) noexcept;
14725 #endif
14726 
14727 private:
14729  std::vector<string_t> reference_tokens;
14730 };
14731 
14732 #if !JSON_HAS_THREE_WAY_COMPARISON
14733 // functions cannot be defined inside class due to ODR violations
14734 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
14735 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14736  const json_pointer<RefStringTypeRhs>& rhs) noexcept
14737 {
14738  return lhs.reference_tokens == rhs.reference_tokens;
14739 }
14740 
14741 template<typename RefStringTypeLhs,
14742  typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
14743 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
14744 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14745  const StringType& rhs)
14746 {
14747  return lhs == json_pointer<RefStringTypeLhs>(rhs);
14748 }
14749 
14750 template<typename RefStringTypeRhs,
14751  typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
14752 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
14753 inline bool operator==(const StringType& lhs,
14754  const json_pointer<RefStringTypeRhs>& rhs)
14755 {
14756  return json_pointer<RefStringTypeRhs>(lhs) == rhs;
14757 }
14758 
14759 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
14760 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14761  const json_pointer<RefStringTypeRhs>& rhs) noexcept
14762 {
14763  return !(lhs == rhs);
14764 }
14765 
14766 template<typename RefStringTypeLhs,
14767  typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
14768 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
14769 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14770  const StringType& rhs)
14771 {
14772  return !(lhs == rhs);
14773 }
14774 
14775 template<typename RefStringTypeRhs,
14776  typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
14777 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
14778 inline bool operator!=(const StringType& lhs,
14779  const json_pointer<RefStringTypeRhs>& rhs)
14780 {
14781  return !(lhs == rhs);
14782 }
14783 
14784 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
14785 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
14786  const json_pointer<RefStringTypeRhs>& rhs) noexcept
14787 {
14788  return lhs.reference_tokens < rhs.reference_tokens;
14789 }
14790 #endif
14791 
14792 NLOHMANN_JSON_NAMESPACE_END
14793 
14794 // #include <nlohmann/detail/json_ref.hpp>
14795 // __ _____ _____ _____
14796 // __| | __| | | | JSON for Modern C++
14797 // | | |__ | | | | | | version 3.11.3
14798 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
14799 //
14800 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
14801 // SPDX-License-Identifier: MIT
14802 
14803 
14804 
14805 #include <initializer_list>
14806 #include <utility>
14807 
14808 // #include <nlohmann/detail/abi_macros.hpp>
14809 
14810 // #include <nlohmann/detail/meta/type_traits.hpp>
14811 
14812 
14813 NLOHMANN_JSON_NAMESPACE_BEGIN
14814 namespace detail
14815 {
14816 
14817  template<typename BasicJsonType>
14818  class json_ref
14819  {
14820  public:
14821  using value_type = BasicJsonType;
14822 
14823  json_ref(value_type&& value)
14824  : owned_value(std::move(value))
14825  {}
14826 
14827  json_ref(const value_type& value)
14828  : value_ref(&value)
14829  {}
14830 
14831  json_ref(std::initializer_list<json_ref> init)
14832  : owned_value(init)
14833  {}
14834 
14835  template <
14836  class... Args,
14837  enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
14838  json_ref(Args && ... args)
14839  : owned_value(std::forward<Args>(args)...)
14840  {}
14841 
14842  // class should be movable only
14843  json_ref(json_ref&&) noexcept = default;
14844  json_ref(const json_ref&) = delete;
14845  json_ref& operator=(const json_ref&) = delete;
14846  json_ref& operator=(json_ref&&) = delete;
14847  ~json_ref() = default;
14848 
14849  value_type moved_or_copied() const
14850  {
14851  if (value_ref == nullptr)
14852  {
14853  return std::move(owned_value);
14854  }
14855  return *value_ref;
14856  }
14857 
14858  value_type const& operator*() const
14859  {
14860  return value_ref ? *value_ref : owned_value;
14861  }
14862 
14863  value_type const* operator->() const
14864  {
14865  return &**this;
14866  }
14867 
14868  private:
14869  mutable value_type owned_value = nullptr;
14870  value_type const* value_ref = nullptr;
14871  };
14872 
14873 } // namespace detail
14874 NLOHMANN_JSON_NAMESPACE_END
14875 
14876 // #include <nlohmann/detail/macro_scope.hpp>
14877 
14878 // #include <nlohmann/detail/string_concat.hpp>
14879 
14880 // #include <nlohmann/detail/string_escape.hpp>
14881 
14882 // #include <nlohmann/detail/meta/cpp_future.hpp>
14883 
14884 // #include <nlohmann/detail/meta/type_traits.hpp>
14885 
14886 // #include <nlohmann/detail/output/binary_writer.hpp>
14887 // __ _____ _____ _____
14888 // __| | __| | | | JSON for Modern C++
14889 // | | |__ | | | | | | version 3.11.3
14890 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
14891 //
14892 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
14893 // SPDX-License-Identifier: MIT
14894 
14895 
14896 
14897 #include <algorithm> // reverse
14898 #include <array> // array
14899 #include <map> // map
14900 #include <cmath> // isnan, isinf
14901 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
14902 #include <cstring> // memcpy
14903 #include <limits> // numeric_limits
14904 #include <string> // string
14905 #include <utility> // move
14906 #include <vector> // vector
14907 
14908 // #include <nlohmann/detail/input/binary_reader.hpp>
14909 
14910 // #include <nlohmann/detail/macro_scope.hpp>
14911 
14912 // #include <nlohmann/detail/output/output_adapters.hpp>
14913 // __ _____ _____ _____
14914 // __| | __| | | | JSON for Modern C++
14915 // | | |__ | | | | | | version 3.11.3
14916 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
14917 //
14918 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
14919 // SPDX-License-Identifier: MIT
14920 
14921 
14922 
14923 #include <algorithm> // copy
14924 #include <cstddef> // size_t
14925 #include <iterator> // back_inserter
14926 #include <memory> // shared_ptr, make_shared
14927 #include <string> // basic_string
14928 #include <vector> // vector
14929 
14930 #ifndef JSON_NO_IO
14931 #include <ios> // streamsize
14932 #include <ostream> // basic_ostream
14933 #endif // JSON_NO_IO
14934 
14935 // #include <nlohmann/detail/macro_scope.hpp>
14936 
14937 
14938 NLOHMANN_JSON_NAMESPACE_BEGIN
14939 namespace detail
14940 {
14941 
14943  template<typename CharType> struct output_adapter_protocol
14944  {
14945  virtual void write_character(CharType c) = 0;
14946  virtual void write_characters(const CharType* s, std::size_t length) = 0;
14947  virtual ~output_adapter_protocol() = default;
14948 
14949  output_adapter_protocol() = default;
14950  output_adapter_protocol(const output_adapter_protocol&) = default;
14951  output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
14952  output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
14953  output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
14954  };
14955 
14957  template<typename CharType>
14958  using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
14959 
14961  template<typename CharType, typename AllocatorType = std::allocator<CharType>>
14962  class output_vector_adapter : public output_adapter_protocol<CharType>
14963  {
14964  public:
14965  explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
14966  : v(vec)
14967  {}
14968 
14969  void write_character(CharType c) override
14970  {
14971  v.push_back(c);
14972  }
14973 
14974  JSON_HEDLEY_NON_NULL(2)
14975  void write_characters(const CharType* s, std::size_t length) override
14976  {
14977  v.insert(v.end(), s, s + length);
14978  }
14979 
14980  private:
14981  std::vector<CharType, AllocatorType>& v;
14982  };
14983 
14984 #ifndef JSON_NO_IO
14986  template<typename CharType>
14987  class output_stream_adapter : public output_adapter_protocol<CharType>
14988  {
14989  public:
14990  explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
14991  : stream(s)
14992  {}
14993 
14994  void write_character(CharType c) override
14995  {
14996  stream.put(c);
14997  }
14998 
14999  JSON_HEDLEY_NON_NULL(2)
15000  void write_characters(const CharType* s, std::size_t length) override
15001  {
15002  stream.write(s, static_cast<std::streamsize>(length));
15003  }
15004 
15005  private:
15006  std::basic_ostream<CharType>& stream;
15007  };
15008 #endif // JSON_NO_IO
15009 
15011  template<typename CharType, typename StringType = std::basic_string<CharType>>
15012  class output_string_adapter : public output_adapter_protocol<CharType>
15013  {
15014  public:
15015  explicit output_string_adapter(StringType& s) noexcept
15016  : str(s)
15017  {}
15018 
15019  void write_character(CharType c) override
15020  {
15021  str.push_back(c);
15022  }
15023 
15024  JSON_HEDLEY_NON_NULL(2)
15025  void write_characters(const CharType* s, std::size_t length) override
15026  {
15027  str.append(s, length);
15028  }
15029 
15030  private:
15031  StringType& str;
15032  };
15033 
15034  template<typename CharType, typename StringType = std::basic_string<CharType>>
15035  class output_adapter
15036  {
15037  public:
15038  template<typename AllocatorType = std::allocator<CharType>>
15039  output_adapter(std::vector<CharType, AllocatorType>& vec)
15040  : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
15041 
15042 #ifndef JSON_NO_IO
15043  output_adapter(std::basic_ostream<CharType>& s)
15044  : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
15045 #endif // JSON_NO_IO
15046 
15047  output_adapter(StringType& s)
15048  : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
15049 
15050  operator output_adapter_t<CharType>()
15051  {
15052  return oa;
15053  }
15054 
15055  private:
15056  output_adapter_t<CharType> oa = nullptr;
15057  };
15058 
15059 } // namespace detail
15060 NLOHMANN_JSON_NAMESPACE_END
15061 
15062 // #include <nlohmann/detail/string_concat.hpp>
15063 
15064 
15065 NLOHMANN_JSON_NAMESPACE_BEGIN
15066 namespace detail
15067 {
15068 
15070  // binary writer //
15072 
15076  template<typename BasicJsonType, typename CharType>
15077  class binary_writer
15078  {
15079  using string_t = typename BasicJsonType::string_t;
15080  using binary_t = typename BasicJsonType::binary_t;
15081  using number_float_t = typename BasicJsonType::number_float_t;
15082 
15083  public:
15089  explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
15090  {
15091  JSON_ASSERT(oa);
15092  }
15093 
15098  void write_bson(const BasicJsonType& j)
15099  {
15100  switch (j.type())
15101  {
15102  case value_t::object:
15103  {
15104  write_bson_object(*j.m_data.m_value.object);
15105  break;
15106  }
15107 
15108  case value_t::null:
15109  case value_t::array:
15110  case value_t::string:
15111  case value_t::boolean:
15112  case value_t::number_integer:
15113  case value_t::number_unsigned:
15114  case value_t::number_float:
15115  case value_t::binary:
15116  case value_t::discarded:
15117  default:
15118  {
15119  JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
15120  }
15121  }
15122  }
15123 
15127  void write_cbor(const BasicJsonType& j)
15128  {
15129  switch (j.type())
15130  {
15131  case value_t::null:
15132  {
15133  oa->write_character(to_char_type(0xF6));
15134  break;
15135  }
15136 
15137  case value_t::boolean:
15138  {
15139  oa->write_character(j.m_data.m_value.boolean
15140  ? to_char_type(0xF5)
15141  : to_char_type(0xF4));
15142  break;
15143  }
15144 
15145  case value_t::number_integer:
15146  {
15147  if (j.m_data.m_value.number_integer >= 0)
15148  {
15149  // CBOR does not differentiate between positive signed
15150  // integers and unsigned integers. Therefore, we used the
15151  // code from the value_t::number_unsigned case here.
15152  if (j.m_data.m_value.number_integer <= 0x17)
15153  {
15154  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15155  }
15156  else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
15157  {
15158  oa->write_character(to_char_type(0x18));
15159  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15160  }
15161  else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
15162  {
15163  oa->write_character(to_char_type(0x19));
15164  write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
15165  }
15166  else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
15167  {
15168  oa->write_character(to_char_type(0x1A));
15169  write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
15170  }
15171  else
15172  {
15173  oa->write_character(to_char_type(0x1B));
15174  write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
15175  }
15176  }
15177  else
15178  {
15179  // The conversions below encode the sign in the first
15180  // byte, and the value is converted to a positive number.
15181  const auto positive_number = -1 - j.m_data.m_value.number_integer;
15182  if (j.m_data.m_value.number_integer >= -24)
15183  {
15184  write_number(static_cast<std::uint8_t>(0x20 + positive_number));
15185  }
15186  else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
15187  {
15188  oa->write_character(to_char_type(0x38));
15189  write_number(static_cast<std::uint8_t>(positive_number));
15190  }
15191  else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
15192  {
15193  oa->write_character(to_char_type(0x39));
15194  write_number(static_cast<std::uint16_t>(positive_number));
15195  }
15196  else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
15197  {
15198  oa->write_character(to_char_type(0x3A));
15199  write_number(static_cast<std::uint32_t>(positive_number));
15200  }
15201  else
15202  {
15203  oa->write_character(to_char_type(0x3B));
15204  write_number(static_cast<std::uint64_t>(positive_number));
15205  }
15206  }
15207  break;
15208  }
15209 
15210  case value_t::number_unsigned:
15211  {
15212  if (j.m_data.m_value.number_unsigned <= 0x17)
15213  {
15214  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
15215  }
15216  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15217  {
15218  oa->write_character(to_char_type(0x18));
15219  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
15220  }
15221  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15222  {
15223  oa->write_character(to_char_type(0x19));
15224  write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
15225  }
15226  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15227  {
15228  oa->write_character(to_char_type(0x1A));
15229  write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
15230  }
15231  else
15232  {
15233  oa->write_character(to_char_type(0x1B));
15234  write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
15235  }
15236  break;
15237  }
15238 
15239  case value_t::number_float:
15240  {
15241  if (std::isnan(j.m_data.m_value.number_float))
15242  {
15243  // NaN is 0xf97e00 in CBOR
15244  oa->write_character(to_char_type(0xF9));
15245  oa->write_character(to_char_type(0x7E));
15246  oa->write_character(to_char_type(0x00));
15247  }
15248  else if (std::isinf(j.m_data.m_value.number_float))
15249  {
15250  // Infinity is 0xf97c00, -Infinity is 0xf9fc00
15251  oa->write_character(to_char_type(0xf9));
15252  oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
15253  oa->write_character(to_char_type(0x00));
15254  }
15255  else
15256  {
15257  write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
15258  }
15259  break;
15260  }
15261 
15262  case value_t::string:
15263  {
15264  // step 1: write control byte and the string length
15265  const auto N = j.m_data.m_value.string->size();
15266  if (N <= 0x17)
15267  {
15268  write_number(static_cast<std::uint8_t>(0x60 + N));
15269  }
15270  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15271  {
15272  oa->write_character(to_char_type(0x78));
15273  write_number(static_cast<std::uint8_t>(N));
15274  }
15275  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15276  {
15277  oa->write_character(to_char_type(0x79));
15278  write_number(static_cast<std::uint16_t>(N));
15279  }
15280  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15281  {
15282  oa->write_character(to_char_type(0x7A));
15283  write_number(static_cast<std::uint32_t>(N));
15284  }
15285  // LCOV_EXCL_START
15286  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15287  {
15288  oa->write_character(to_char_type(0x7B));
15289  write_number(static_cast<std::uint64_t>(N));
15290  }
15291  // LCOV_EXCL_STOP
15292 
15293  // step 2: write the string
15294  oa->write_characters(
15295  reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
15296  j.m_data.m_value.string->size());
15297  break;
15298  }
15299 
15300  case value_t::array:
15301  {
15302  // step 1: write control byte and the array size
15303  const auto N = j.m_data.m_value.array->size();
15304  if (N <= 0x17)
15305  {
15306  write_number(static_cast<std::uint8_t>(0x80 + N));
15307  }
15308  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15309  {
15310  oa->write_character(to_char_type(0x98));
15311  write_number(static_cast<std::uint8_t>(N));
15312  }
15313  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15314  {
15315  oa->write_character(to_char_type(0x99));
15316  write_number(static_cast<std::uint16_t>(N));
15317  }
15318  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15319  {
15320  oa->write_character(to_char_type(0x9A));
15321  write_number(static_cast<std::uint32_t>(N));
15322  }
15323  // LCOV_EXCL_START
15324  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15325  {
15326  oa->write_character(to_char_type(0x9B));
15327  write_number(static_cast<std::uint64_t>(N));
15328  }
15329  // LCOV_EXCL_STOP
15330 
15331  // step 2: write each element
15332  for (const auto& el : *j.m_data.m_value.array)
15333  {
15334  write_cbor(el);
15335  }
15336  break;
15337  }
15338 
15339  case value_t::binary:
15340  {
15341  if (j.m_data.m_value.binary->has_subtype())
15342  {
15343  if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
15344  {
15345  write_number(static_cast<std::uint8_t>(0xd8));
15346  write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
15347  }
15348  else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
15349  {
15350  write_number(static_cast<std::uint8_t>(0xd9));
15351  write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
15352  }
15353  else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
15354  {
15355  write_number(static_cast<std::uint8_t>(0xda));
15356  write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
15357  }
15358  else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
15359  {
15360  write_number(static_cast<std::uint8_t>(0xdb));
15361  write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
15362  }
15363  }
15364 
15365  // step 1: write control byte and the binary array size
15366  const auto N = j.m_data.m_value.binary->size();
15367  if (N <= 0x17)
15368  {
15369  write_number(static_cast<std::uint8_t>(0x40 + N));
15370  }
15371  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15372  {
15373  oa->write_character(to_char_type(0x58));
15374  write_number(static_cast<std::uint8_t>(N));
15375  }
15376  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15377  {
15378  oa->write_character(to_char_type(0x59));
15379  write_number(static_cast<std::uint16_t>(N));
15380  }
15381  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15382  {
15383  oa->write_character(to_char_type(0x5A));
15384  write_number(static_cast<std::uint32_t>(N));
15385  }
15386  // LCOV_EXCL_START
15387  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15388  {
15389  oa->write_character(to_char_type(0x5B));
15390  write_number(static_cast<std::uint64_t>(N));
15391  }
15392  // LCOV_EXCL_STOP
15393 
15394  // step 2: write each element
15395  oa->write_characters(
15396  reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
15397  N);
15398 
15399  break;
15400  }
15401 
15402  case value_t::object:
15403  {
15404  // step 1: write control byte and the object size
15405  const auto N = j.m_data.m_value.object->size();
15406  if (N <= 0x17)
15407  {
15408  write_number(static_cast<std::uint8_t>(0xA0 + N));
15409  }
15410  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15411  {
15412  oa->write_character(to_char_type(0xB8));
15413  write_number(static_cast<std::uint8_t>(N));
15414  }
15415  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15416  {
15417  oa->write_character(to_char_type(0xB9));
15418  write_number(static_cast<std::uint16_t>(N));
15419  }
15420  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15421  {
15422  oa->write_character(to_char_type(0xBA));
15423  write_number(static_cast<std::uint32_t>(N));
15424  }
15425  // LCOV_EXCL_START
15426  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15427  {
15428  oa->write_character(to_char_type(0xBB));
15429  write_number(static_cast<std::uint64_t>(N));
15430  }
15431  // LCOV_EXCL_STOP
15432 
15433  // step 2: write each element
15434  for (const auto& el : *j.m_data.m_value.object)
15435  {
15436  write_cbor(el.first);
15437  write_cbor(el.second);
15438  }
15439  break;
15440  }
15441 
15442  case value_t::discarded:
15443  default:
15444  break;
15445  }
15446  }
15447 
15451  void write_msgpack(const BasicJsonType& j)
15452  {
15453  switch (j.type())
15454  {
15455  case value_t::null: // nil
15456  {
15457  oa->write_character(to_char_type(0xC0));
15458  break;
15459  }
15460 
15461  case value_t::boolean: // true and false
15462  {
15463  oa->write_character(j.m_data.m_value.boolean
15464  ? to_char_type(0xC3)
15465  : to_char_type(0xC2));
15466  break;
15467  }
15468 
15469  case value_t::number_integer:
15470  {
15471  if (j.m_data.m_value.number_integer >= 0)
15472  {
15473  // MessagePack does not differentiate between positive
15474  // signed integers and unsigned integers. Therefore, we used
15475  // the code from the value_t::number_unsigned case here.
15476  if (j.m_data.m_value.number_unsigned < 128)
15477  {
15478  // positive fixnum
15479  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15480  }
15481  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15482  {
15483  // uint 8
15484  oa->write_character(to_char_type(0xCC));
15485  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15486  }
15487  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15488  {
15489  // uint 16
15490  oa->write_character(to_char_type(0xCD));
15491  write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
15492  }
15493  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15494  {
15495  // uint 32
15496  oa->write_character(to_char_type(0xCE));
15497  write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
15498  }
15499  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
15500  {
15501  // uint 64
15502  oa->write_character(to_char_type(0xCF));
15503  write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
15504  }
15505  }
15506  else
15507  {
15508  if (j.m_data.m_value.number_integer >= -32)
15509  {
15510  // negative fixnum
15511  write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
15512  }
15513  else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
15514  j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
15515  {
15516  // int 8
15517  oa->write_character(to_char_type(0xD0));
15518  write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
15519  }
15520  else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
15521  j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
15522  {
15523  // int 16
15524  oa->write_character(to_char_type(0xD1));
15525  write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
15526  }
15527  else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
15528  j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
15529  {
15530  // int 32
15531  oa->write_character(to_char_type(0xD2));
15532  write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
15533  }
15534  else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
15535  j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
15536  {
15537  // int 64
15538  oa->write_character(to_char_type(0xD3));
15539  write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
15540  }
15541  }
15542  break;
15543  }
15544 
15545  case value_t::number_unsigned:
15546  {
15547  if (j.m_data.m_value.number_unsigned < 128)
15548  {
15549  // positive fixnum
15550  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15551  }
15552  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15553  {
15554  // uint 8
15555  oa->write_character(to_char_type(0xCC));
15556  write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15557  }
15558  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15559  {
15560  // uint 16
15561  oa->write_character(to_char_type(0xCD));
15562  write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
15563  }
15564  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15565  {
15566  // uint 32
15567  oa->write_character(to_char_type(0xCE));
15568  write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
15569  }
15570  else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
15571  {
15572  // uint 64
15573  oa->write_character(to_char_type(0xCF));
15574  write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
15575  }
15576  break;
15577  }
15578 
15579  case value_t::number_float:
15580  {
15581  write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
15582  break;
15583  }
15584 
15585  case value_t::string:
15586  {
15587  // step 1: write control byte and the string length
15588  const auto N = j.m_data.m_value.string->size();
15589  if (N <= 31)
15590  {
15591  // fixstr
15592  write_number(static_cast<std::uint8_t>(0xA0 | N));
15593  }
15594  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15595  {
15596  // str 8
15597  oa->write_character(to_char_type(0xD9));
15598  write_number(static_cast<std::uint8_t>(N));
15599  }
15600  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15601  {
15602  // str 16
15603  oa->write_character(to_char_type(0xDA));
15604  write_number(static_cast<std::uint16_t>(N));
15605  }
15606  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15607  {
15608  // str 32
15609  oa->write_character(to_char_type(0xDB));
15610  write_number(static_cast<std::uint32_t>(N));
15611  }
15612 
15613  // step 2: write the string
15614  oa->write_characters(
15615  reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
15616  j.m_data.m_value.string->size());
15617  break;
15618  }
15619 
15620  case value_t::array:
15621  {
15622  // step 1: write control byte and the array size
15623  const auto N = j.m_data.m_value.array->size();
15624  if (N <= 15)
15625  {
15626  // fixarray
15627  write_number(static_cast<std::uint8_t>(0x90 | N));
15628  }
15629  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15630  {
15631  // array 16
15632  oa->write_character(to_char_type(0xDC));
15633  write_number(static_cast<std::uint16_t>(N));
15634  }
15635  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15636  {
15637  // array 32
15638  oa->write_character(to_char_type(0xDD));
15639  write_number(static_cast<std::uint32_t>(N));
15640  }
15641 
15642  // step 2: write each element
15643  for (const auto& el : *j.m_data.m_value.array)
15644  {
15645  write_msgpack(el);
15646  }
15647  break;
15648  }
15649 
15650  case value_t::binary:
15651  {
15652  // step 0: determine if the binary type has a set subtype to
15653  // determine whether or not to use the ext or fixext types
15654  const bool use_ext = j.m_data.m_value.binary->has_subtype();
15655 
15656  // step 1: write control byte and the byte string length
15657  const auto N = j.m_data.m_value.binary->size();
15658  if (N <= (std::numeric_limits<std::uint8_t>::max)())
15659  {
15660  std::uint8_t output_type{};
15661  bool fixed = true;
15662  if (use_ext)
15663  {
15664  switch (N)
15665  {
15666  case 1:
15667  output_type = 0xD4; // fixext 1
15668  break;
15669  case 2:
15670  output_type = 0xD5; // fixext 2
15671  break;
15672  case 4:
15673  output_type = 0xD6; // fixext 4
15674  break;
15675  case 8:
15676  output_type = 0xD7; // fixext 8
15677  break;
15678  case 16:
15679  output_type = 0xD8; // fixext 16
15680  break;
15681  default:
15682  output_type = 0xC7; // ext 8
15683  fixed = false;
15684  break;
15685  }
15686 
15687  }
15688  else
15689  {
15690  output_type = 0xC4; // bin 8
15691  fixed = false;
15692  }
15693 
15694  oa->write_character(to_char_type(output_type));
15695  if (!fixed)
15696  {
15697  write_number(static_cast<std::uint8_t>(N));
15698  }
15699  }
15700  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15701  {
15702  const std::uint8_t output_type = use_ext
15703  ? 0xC8 // ext 16
15704  : 0xC5; // bin 16
15705 
15706  oa->write_character(to_char_type(output_type));
15707  write_number(static_cast<std::uint16_t>(N));
15708  }
15709  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15710  {
15711  const std::uint8_t output_type = use_ext
15712  ? 0xC9 // ext 32
15713  : 0xC6; // bin 32
15714 
15715  oa->write_character(to_char_type(output_type));
15716  write_number(static_cast<std::uint32_t>(N));
15717  }
15718 
15719  // step 1.5: if this is an ext type, write the subtype
15720  if (use_ext)
15721  {
15722  write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
15723  }
15724 
15725  // step 2: write the byte string
15726  oa->write_characters(
15727  reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
15728  N);
15729 
15730  break;
15731  }
15732 
15733  case value_t::object:
15734  {
15735  // step 1: write control byte and the object size
15736  const auto N = j.m_data.m_value.object->size();
15737  if (N <= 15)
15738  {
15739  // fixmap
15740  write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
15741  }
15742  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15743  {
15744  // map 16
15745  oa->write_character(to_char_type(0xDE));
15746  write_number(static_cast<std::uint16_t>(N));
15747  }
15748  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15749  {
15750  // map 32
15751  oa->write_character(to_char_type(0xDF));
15752  write_number(static_cast<std::uint32_t>(N));
15753  }
15754 
15755  // step 2: write each element
15756  for (const auto& el : *j.m_data.m_value.object)
15757  {
15758  write_msgpack(el.first);
15759  write_msgpack(el.second);
15760  }
15761  break;
15762  }
15763 
15764  case value_t::discarded:
15765  default:
15766  break;
15767  }
15768  }
15769 
15777  void write_ubjson(const BasicJsonType& j, const bool use_count,
15778  const bool use_type, const bool add_prefix = true,
15779  const bool use_bjdata = false)
15780  {
15781  switch (j.type())
15782  {
15783  case value_t::null:
15784  {
15785  if (add_prefix)
15786  {
15787  oa->write_character(to_char_type('Z'));
15788  }
15789  break;
15790  }
15791 
15792  case value_t::boolean:
15793  {
15794  if (add_prefix)
15795  {
15796  oa->write_character(j.m_data.m_value.boolean
15797  ? to_char_type('T')
15798  : to_char_type('F'));
15799  }
15800  break;
15801  }
15802 
15803  case value_t::number_integer:
15804  {
15805  write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
15806  break;
15807  }
15808 
15809  case value_t::number_unsigned:
15810  {
15811  write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
15812  break;
15813  }
15814 
15815  case value_t::number_float:
15816  {
15817  write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
15818  break;
15819  }
15820 
15821  case value_t::string:
15822  {
15823  if (add_prefix)
15824  {
15825  oa->write_character(to_char_type('S'));
15826  }
15827  write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
15828  oa->write_characters(
15829  reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
15830  j.m_data.m_value.string->size());
15831  break;
15832  }
15833 
15834  case value_t::array:
15835  {
15836  if (add_prefix)
15837  {
15838  oa->write_character(to_char_type('['));
15839  }
15840 
15841  bool prefix_required = true;
15842  if (use_type && !j.m_data.m_value.array->empty())
15843  {
15844  JSON_ASSERT(use_count);
15845  const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
15846  const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
15847  [this, first_prefix, use_bjdata](const BasicJsonType& v)
15848  {
15849  return ubjson_prefix(v, use_bjdata) == first_prefix;
15850  });
15851 
15852  std::vector<CharType> bjdx = { '[', '{', 'S', 'H', 'T', 'F', 'N', 'Z' }; // excluded markers in bjdata optimized type
15853 
15854  if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
15855  {
15856  prefix_required = false;
15857  oa->write_character(to_char_type('$'));
15858  oa->write_character(first_prefix);
15859  }
15860  }
15861 
15862  if (use_count)
15863  {
15864  oa->write_character(to_char_type('#'));
15865  write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
15866  }
15867 
15868  for (const auto& el : *j.m_data.m_value.array)
15869  {
15870  write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
15871  }
15872 
15873  if (!use_count)
15874  {
15875  oa->write_character(to_char_type(']'));
15876  }
15877 
15878  break;
15879  }
15880 
15881  case value_t::binary:
15882  {
15883  if (add_prefix)
15884  {
15885  oa->write_character(to_char_type('['));
15886  }
15887 
15888  if (use_type && !j.m_data.m_value.binary->empty())
15889  {
15890  JSON_ASSERT(use_count);
15891  oa->write_character(to_char_type('$'));
15892  oa->write_character('U');
15893  }
15894 
15895  if (use_count)
15896  {
15897  oa->write_character(to_char_type('#'));
15898  write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
15899  }
15900 
15901  if (use_type)
15902  {
15903  oa->write_characters(
15904  reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
15905  j.m_data.m_value.binary->size());
15906  }
15907  else
15908  {
15909  for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
15910  {
15911  oa->write_character(to_char_type('U'));
15912  oa->write_character(j.m_data.m_value.binary->data()[i]);
15913  }
15914  }
15915 
15916  if (!use_count)
15917  {
15918  oa->write_character(to_char_type(']'));
15919  }
15920 
15921  break;
15922  }
15923 
15924  case value_t::object:
15925  {
15926  if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
15927  {
15928  if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type)) // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
15929  {
15930  break;
15931  }
15932  }
15933 
15934  if (add_prefix)
15935  {
15936  oa->write_character(to_char_type('{'));
15937  }
15938 
15939  bool prefix_required = true;
15940  if (use_type && !j.m_data.m_value.object->empty())
15941  {
15942  JSON_ASSERT(use_count);
15943  const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
15944  const bool same_prefix = std::all_of(j.begin(), j.end(),
15945  [this, first_prefix, use_bjdata](const BasicJsonType& v)
15946  {
15947  return ubjson_prefix(v, use_bjdata) == first_prefix;
15948  });
15949 
15950  std::vector<CharType> bjdx = { '[', '{', 'S', 'H', 'T', 'F', 'N', 'Z' }; // excluded markers in bjdata optimized type
15951 
15952  if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
15953  {
15954  prefix_required = false;
15955  oa->write_character(to_char_type('$'));
15956  oa->write_character(first_prefix);
15957  }
15958  }
15959 
15960  if (use_count)
15961  {
15962  oa->write_character(to_char_type('#'));
15963  write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
15964  }
15965 
15966  for (const auto& el : *j.m_data.m_value.object)
15967  {
15968  write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
15969  oa->write_characters(
15970  reinterpret_cast<const CharType*>(el.first.c_str()),
15971  el.first.size());
15972  write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);
15973  }
15974 
15975  if (!use_count)
15976  {
15977  oa->write_character(to_char_type('}'));
15978  }
15979 
15980  break;
15981  }
15982 
15983  case value_t::discarded:
15984  default:
15985  break;
15986  }
15987  }
15988 
15989  private:
15991  // BSON //
15993 
15998  static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
15999  {
16000  const auto it = name.find(static_cast<typename string_t::value_type>(0));
16001  if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
16002  {
16003  JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
16004  static_cast<void>(j);
16005  }
16006 
16007  return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
16008  }
16009 
16013  void write_bson_entry_header(const string_t& name,
16014  const std::uint8_t element_type)
16015  {
16016  oa->write_character(to_char_type(element_type)); // boolean
16017  oa->write_characters(
16018  reinterpret_cast<const CharType*>(name.c_str()),
16019  name.size() + 1u);
16020  }
16021 
16025  void write_bson_boolean(const string_t& name,
16026  const bool value)
16027  {
16028  write_bson_entry_header(name, 0x08);
16029  oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
16030  }
16031 
16035  void write_bson_double(const string_t& name,
16036  const double value)
16037  {
16038  write_bson_entry_header(name, 0x01);
16039  write_number<double>(value, true);
16040  }
16041 
16045  static std::size_t calc_bson_string_size(const string_t& value)
16046  {
16047  return sizeof(std::int32_t) + value.size() + 1ul;
16048  }
16049 
16053  void write_bson_string(const string_t& name,
16054  const string_t& value)
16055  {
16056  write_bson_entry_header(name, 0x02);
16057 
16058  write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
16059  oa->write_characters(
16060  reinterpret_cast<const CharType*>(value.c_str()),
16061  value.size() + 1);
16062  }
16063 
16067  void write_bson_null(const string_t& name)
16068  {
16069  write_bson_entry_header(name, 0x0A);
16070  }
16071 
16075  static std::size_t calc_bson_integer_size(const std::int64_t value)
16076  {
16077  return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
16078  ? sizeof(std::int32_t)
16079  : sizeof(std::int64_t);
16080  }
16081 
16085  void write_bson_integer(const string_t& name,
16086  const std::int64_t value)
16087  {
16088  if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
16089  {
16090  write_bson_entry_header(name, 0x10); // int32
16091  write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
16092  }
16093  else
16094  {
16095  write_bson_entry_header(name, 0x12); // int64
16096  write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
16097  }
16098  }
16099 
16103  static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
16104  {
16105  return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16106  ? sizeof(std::int32_t)
16107  : sizeof(std::int64_t);
16108  }
16109 
16113  void write_bson_unsigned(const string_t& name,
16114  const BasicJsonType& j)
16115  {
16116  if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16117  {
16118  write_bson_entry_header(name, 0x10 /* int32 */);
16119  write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
16120  }
16121  else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16122  {
16123  write_bson_entry_header(name, 0x12 /* int64 */);
16124  write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
16125  }
16126  else
16127  {
16128  JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
16129  }
16130  }
16131 
16135  void write_bson_object_entry(const string_t& name,
16136  const typename BasicJsonType::object_t& value)
16137  {
16138  write_bson_entry_header(name, 0x03); // object
16139  write_bson_object(value);
16140  }
16141 
16145  static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
16146  {
16147  std::size_t array_index = 0ul;
16148 
16149  const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type& el)
16150  {
16151  return result + calc_bson_element_size(std::to_string(array_index++), el);
16152  });
16153 
16154  return sizeof(std::int32_t) + embedded_document_size + 1ul;
16155  }
16156 
16160  static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
16161  {
16162  return sizeof(std::int32_t) + value.size() + 1ul;
16163  }
16164 
16168  void write_bson_array(const string_t& name,
16169  const typename BasicJsonType::array_t& value)
16170  {
16171  write_bson_entry_header(name, 0x04); // array
16172  write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
16173 
16174  std::size_t array_index = 0ul;
16175 
16176  for (const auto& el : value)
16177  {
16178  write_bson_element(std::to_string(array_index++), el);
16179  }
16180 
16181  oa->write_character(to_char_type(0x00));
16182  }
16183 
16187  void write_bson_binary(const string_t& name,
16188  const binary_t& value)
16189  {
16190  write_bson_entry_header(name, 0x05);
16191 
16192  write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
16193  write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
16194 
16195  oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
16196  }
16197 
16202  static std::size_t calc_bson_element_size(const string_t& name,
16203  const BasicJsonType& j)
16204  {
16205  const auto header_size = calc_bson_entry_header_size(name, j);
16206  switch (j.type())
16207  {
16208  case value_t::object:
16209  return header_size + calc_bson_object_size(*j.m_data.m_value.object);
16210 
16211  case value_t::array:
16212  return header_size + calc_bson_array_size(*j.m_data.m_value.array);
16213 
16214  case value_t::binary:
16215  return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
16216 
16217  case value_t::boolean:
16218  return header_size + 1ul;
16219 
16220  case value_t::number_float:
16221  return header_size + 8ul;
16222 
16223  case value_t::number_integer:
16224  return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
16225 
16226  case value_t::number_unsigned:
16227  return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
16228 
16229  case value_t::string:
16230  return header_size + calc_bson_string_size(*j.m_data.m_value.string);
16231 
16232  case value_t::null:
16233  return header_size + 0ul;
16234 
16235  // LCOV_EXCL_START
16236  case value_t::discarded:
16237  default:
16238  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
16239  return 0ul;
16240  // LCOV_EXCL_STOP
16241  }
16242  }
16243 
16250  void write_bson_element(const string_t& name,
16251  const BasicJsonType& j)
16252  {
16253  switch (j.type())
16254  {
16255  case value_t::object:
16256  return write_bson_object_entry(name, *j.m_data.m_value.object);
16257 
16258  case value_t::array:
16259  return write_bson_array(name, *j.m_data.m_value.array);
16260 
16261  case value_t::binary:
16262  return write_bson_binary(name, *j.m_data.m_value.binary);
16263 
16264  case value_t::boolean:
16265  return write_bson_boolean(name, j.m_data.m_value.boolean);
16266 
16267  case value_t::number_float:
16268  return write_bson_double(name, j.m_data.m_value.number_float);
16269 
16270  case value_t::number_integer:
16271  return write_bson_integer(name, j.m_data.m_value.number_integer);
16272 
16273  case value_t::number_unsigned:
16274  return write_bson_unsigned(name, j);
16275 
16276  case value_t::string:
16277  return write_bson_string(name, *j.m_data.m_value.string);
16278 
16279  case value_t::null:
16280  return write_bson_null(name);
16281 
16282  // LCOV_EXCL_START
16283  case value_t::discarded:
16284  default:
16285  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
16286  return;
16287  // LCOV_EXCL_STOP
16288  }
16289  }
16290 
16297  static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
16298  {
16299  const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
16300  [](size_t result, const typename BasicJsonType::object_t::value_type& el)
16301  {
16302  return result += calc_bson_element_size(el.first, el.second);
16303  });
16304 
16305  return sizeof(std::int32_t) + document_size + 1ul;
16306  }
16307 
16312  void write_bson_object(const typename BasicJsonType::object_t& value)
16313  {
16314  write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
16315 
16316  for (const auto& el : value)
16317  {
16318  write_bson_element(el.first, el.second);
16319  }
16320 
16321  oa->write_character(to_char_type(0x00));
16322  }
16323 
16325  // CBOR //
16327 
16328  static constexpr CharType get_cbor_float_prefix(float /*unused*/)
16329  {
16330  return to_char_type(0xFA); // Single-Precision Float
16331  }
16332 
16333  static constexpr CharType get_cbor_float_prefix(double /*unused*/)
16334  {
16335  return to_char_type(0xFB); // Double-Precision Float
16336  }
16337 
16339  // MsgPack //
16341 
16342  static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
16343  {
16344  return to_char_type(0xCA); // float 32
16345  }
16346 
16347  static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
16348  {
16349  return to_char_type(0xCB); // float 64
16350  }
16351 
16353  // UBJSON //
16355 
16356  // UBJSON: write number (floating point)
16357  template<typename NumberType, typename std::enable_if<
16358  std::is_floating_point<NumberType>::value, int>::type = 0>
16359  void write_number_with_ubjson_prefix(const NumberType n,
16360  const bool add_prefix,
16361  const bool use_bjdata)
16362  {
16363  if (add_prefix)
16364  {
16365  oa->write_character(get_ubjson_float_prefix(n));
16366  }
16367  write_number(n, use_bjdata);
16368  }
16369 
16370  // UBJSON: write number (unsigned integer)
16371  template<typename NumberType, typename std::enable_if<
16372  std::is_unsigned<NumberType>::value, int>::type = 0>
16373  void write_number_with_ubjson_prefix(const NumberType n,
16374  const bool add_prefix,
16375  const bool use_bjdata)
16376  {
16377  if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
16378  {
16379  if (add_prefix)
16380  {
16381  oa->write_character(to_char_type('i')); // int8
16382  }
16383  write_number(static_cast<std::uint8_t>(n), use_bjdata);
16384  }
16385  else if (n <= (std::numeric_limits<std::uint8_t>::max)())
16386  {
16387  if (add_prefix)
16388  {
16389  oa->write_character(to_char_type('U')); // uint8
16390  }
16391  write_number(static_cast<std::uint8_t>(n), use_bjdata);
16392  }
16393  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
16394  {
16395  if (add_prefix)
16396  {
16397  oa->write_character(to_char_type('I')); // int16
16398  }
16399  write_number(static_cast<std::int16_t>(n), use_bjdata);
16400  }
16401  else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
16402  {
16403  if (add_prefix)
16404  {
16405  oa->write_character(to_char_type('u')); // uint16 - bjdata only
16406  }
16407  write_number(static_cast<std::uint16_t>(n), use_bjdata);
16408  }
16409  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16410  {
16411  if (add_prefix)
16412  {
16413  oa->write_character(to_char_type('l')); // int32
16414  }
16415  write_number(static_cast<std::int32_t>(n), use_bjdata);
16416  }
16417  else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
16418  {
16419  if (add_prefix)
16420  {
16421  oa->write_character(to_char_type('m')); // uint32 - bjdata only
16422  }
16423  write_number(static_cast<std::uint32_t>(n), use_bjdata);
16424  }
16425  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16426  {
16427  if (add_prefix)
16428  {
16429  oa->write_character(to_char_type('L')); // int64
16430  }
16431  write_number(static_cast<std::int64_t>(n), use_bjdata);
16432  }
16433  else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
16434  {
16435  if (add_prefix)
16436  {
16437  oa->write_character(to_char_type('M')); // uint64 - bjdata only
16438  }
16439  write_number(static_cast<std::uint64_t>(n), use_bjdata);
16440  }
16441  else
16442  {
16443  if (add_prefix)
16444  {
16445  oa->write_character(to_char_type('H')); // high-precision number
16446  }
16447 
16448  const auto number = BasicJsonType(n).dump();
16449  write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
16450  for (std::size_t i = 0; i < number.size(); ++i)
16451  {
16452  oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
16453  }
16454  }
16455  }
16456 
16457  // UBJSON: write number (signed integer)
16458  template < typename NumberType, typename std::enable_if <
16459  std::is_signed<NumberType>::value &&
16460  !std::is_floating_point<NumberType>::value, int >::type = 0 >
16461  void write_number_with_ubjson_prefix(const NumberType n,
16462  const bool add_prefix,
16463  const bool use_bjdata)
16464  {
16465  if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
16466  {
16467  if (add_prefix)
16468  {
16469  oa->write_character(to_char_type('i')); // int8
16470  }
16471  write_number(static_cast<std::int8_t>(n), use_bjdata);
16472  }
16473  else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
16474  {
16475  if (add_prefix)
16476  {
16477  oa->write_character(to_char_type('U')); // uint8
16478  }
16479  write_number(static_cast<std::uint8_t>(n), use_bjdata);
16480  }
16481  else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
16482  {
16483  if (add_prefix)
16484  {
16485  oa->write_character(to_char_type('I')); // int16
16486  }
16487  write_number(static_cast<std::int16_t>(n), use_bjdata);
16488  }
16489  else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
16490  {
16491  if (add_prefix)
16492  {
16493  oa->write_character(to_char_type('u')); // uint16 - bjdata only
16494  }
16495  write_number(static_cast<uint16_t>(n), use_bjdata);
16496  }
16497  else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
16498  {
16499  if (add_prefix)
16500  {
16501  oa->write_character(to_char_type('l')); // int32
16502  }
16503  write_number(static_cast<std::int32_t>(n), use_bjdata);
16504  }
16505  else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
16506  {
16507  if (add_prefix)
16508  {
16509  oa->write_character(to_char_type('m')); // uint32 - bjdata only
16510  }
16511  write_number(static_cast<uint32_t>(n), use_bjdata);
16512  }
16513  else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
16514  {
16515  if (add_prefix)
16516  {
16517  oa->write_character(to_char_type('L')); // int64
16518  }
16519  write_number(static_cast<std::int64_t>(n), use_bjdata);
16520  }
16521  // LCOV_EXCL_START
16522  else
16523  {
16524  if (add_prefix)
16525  {
16526  oa->write_character(to_char_type('H')); // high-precision number
16527  }
16528 
16529  const auto number = BasicJsonType(n).dump();
16530  write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
16531  for (std::size_t i = 0; i < number.size(); ++i)
16532  {
16533  oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
16534  }
16535  }
16536  // LCOV_EXCL_STOP
16537  }
16538 
16542  CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
16543  {
16544  switch (j.type())
16545  {
16546  case value_t::null:
16547  return 'Z';
16548 
16549  case value_t::boolean:
16550  return j.m_data.m_value.boolean ? 'T' : 'F';
16551 
16552  case value_t::number_integer:
16553  {
16554  if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
16555  {
16556  return 'i';
16557  }
16558  if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
16559  {
16560  return 'U';
16561  }
16562  if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
16563  {
16564  return 'I';
16565  }
16566  if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
16567  {
16568  return 'u';
16569  }
16570  if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
16571  {
16572  return 'l';
16573  }
16574  if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
16575  {
16576  return 'm';
16577  }
16578  if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
16579  {
16580  return 'L';
16581  }
16582  // anything else is treated as high-precision number
16583  return 'H'; // LCOV_EXCL_LINE
16584  }
16585 
16586  case value_t::number_unsigned:
16587  {
16588  if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
16589  {
16590  return 'i';
16591  }
16592  if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
16593  {
16594  return 'U';
16595  }
16596  if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
16597  {
16598  return 'I';
16599  }
16600  if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
16601  {
16602  return 'u';
16603  }
16604  if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16605  {
16606  return 'l';
16607  }
16608  if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
16609  {
16610  return 'm';
16611  }
16612  if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16613  {
16614  return 'L';
16615  }
16616  if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
16617  {
16618  return 'M';
16619  }
16620  // anything else is treated as high-precision number
16621  return 'H'; // LCOV_EXCL_LINE
16622  }
16623 
16624  case value_t::number_float:
16625  return get_ubjson_float_prefix(j.m_data.m_value.number_float);
16626 
16627  case value_t::string:
16628  return 'S';
16629 
16630  case value_t::array: // fallthrough
16631  case value_t::binary:
16632  return '[';
16633 
16634  case value_t::object:
16635  return '{';
16636 
16637  case value_t::discarded:
16638  default: // discarded values
16639  return 'N';
16640  }
16641  }
16642 
16643  static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
16644  {
16645  return 'd'; // float 32
16646  }
16647 
16648  static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
16649  {
16650  return 'D'; // float 64
16651  }
16652 
16656  bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
16657  {
16658  std::map<string_t, CharType> bjdtype = { {"uint8", 'U'}, {"int8", 'i'}, {"uint16", 'u'}, {"int16", 'I'},
16659  {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}
16660  };
16661 
16662  string_t key = "_ArrayType_";
16663  auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
16664  if (it == bjdtype.end())
16665  {
16666  return true;
16667  }
16668  CharType dtype = it->second;
16669 
16670  key = "_ArraySize_";
16671  std::size_t len = (value.at(key).empty() ? 0 : 1);
16672  for (const auto& el : value.at(key))
16673  {
16674  len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
16675  }
16676 
16677  key = "_ArrayData_";
16678  if (value.at(key).size() != len)
16679  {
16680  return true;
16681  }
16682 
16683  oa->write_character('[');
16684  oa->write_character('$');
16685  oa->write_character(dtype);
16686  oa->write_character('#');
16687 
16688  key = "_ArraySize_";
16689  write_ubjson(value.at(key), use_count, use_type, true, true);
16690 
16691  key = "_ArrayData_";
16692  if (dtype == 'U' || dtype == 'C')
16693  {
16694  for (const auto& el : value.at(key))
16695  {
16696  write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
16697  }
16698  }
16699  else if (dtype == 'i')
16700  {
16701  for (const auto& el : value.at(key))
16702  {
16703  write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
16704  }
16705  }
16706  else if (dtype == 'u')
16707  {
16708  for (const auto& el : value.at(key))
16709  {
16710  write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
16711  }
16712  }
16713  else if (dtype == 'I')
16714  {
16715  for (const auto& el : value.at(key))
16716  {
16717  write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
16718  }
16719  }
16720  else if (dtype == 'm')
16721  {
16722  for (const auto& el : value.at(key))
16723  {
16724  write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
16725  }
16726  }
16727  else if (dtype == 'l')
16728  {
16729  for (const auto& el : value.at(key))
16730  {
16731  write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
16732  }
16733  }
16734  else if (dtype == 'M')
16735  {
16736  for (const auto& el : value.at(key))
16737  {
16738  write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
16739  }
16740  }
16741  else if (dtype == 'L')
16742  {
16743  for (const auto& el : value.at(key))
16744  {
16745  write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
16746  }
16747  }
16748  else if (dtype == 'd')
16749  {
16750  for (const auto& el : value.at(key))
16751  {
16752  write_number(static_cast<float>(el.m_data.m_value.number_float), true);
16753  }
16754  }
16755  else if (dtype == 'D')
16756  {
16757  for (const auto& el : value.at(key))
16758  {
16759  write_number(static_cast<double>(el.m_data.m_value.number_float), true);
16760  }
16761  }
16762  return false;
16763  }
16764 
16766  // Utility functions //
16768 
16769  /*
16770  @brief write a number to output input
16771  @param[in] n number of type @a NumberType
16772  @param[in] OutputIsLittleEndian Set to true if output data is
16773  required to be little endian
16774  @tparam NumberType the type of the number
16775 
16776  @note This function needs to respect the system's endianness, because bytes
16777  in CBOR, MessagePack, and UBJSON are stored in network order (big
16778  endian) and therefore need reordering on little endian systems.
16779  On the other hand, BSON and BJData use little endian and should reorder
16780  on big endian systems.
16781  */
16782  template<typename NumberType>
16783  void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
16784  {
16785  // step 1: write number to array of length NumberType
16786  std::array<CharType, sizeof(NumberType)> vec{};
16787  std::memcpy(vec.data(), &n, sizeof(NumberType));
16788 
16789  // step 2: write array to output (with possible reordering)
16790  if (is_little_endian != OutputIsLittleEndian)
16791  {
16792  // reverse byte order prior to conversion if necessary
16793  std::reverse(vec.begin(), vec.end());
16794  }
16795 
16796  oa->write_characters(vec.data(), sizeof(NumberType));
16797  }
16798 
16799  void write_compact_float(const number_float_t n, detail::input_format_t format)
16800  {
16801 #ifdef __GNUC__
16802 #pragma GCC diagnostic push
16803 #pragma GCC diagnostic ignored "-Wfloat-equal"
16804 #endif
16805  if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
16806  static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
16807  static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
16808  {
16809  oa->write_character(format == detail::input_format_t::cbor
16810  ? get_cbor_float_prefix(static_cast<float>(n))
16811  : get_msgpack_float_prefix(static_cast<float>(n)));
16812  write_number(static_cast<float>(n));
16813  }
16814  else
16815  {
16816  oa->write_character(format == detail::input_format_t::cbor
16817  ? get_cbor_float_prefix(n)
16818  : get_msgpack_float_prefix(n));
16819  write_number(n);
16820  }
16821 #ifdef __GNUC__
16822 #pragma GCC diagnostic pop
16823 #endif
16824  }
16825 
16826  public:
16827  // The following to_char_type functions are implement the conversion
16828  // between uint8_t and CharType. In case CharType is not unsigned,
16829  // such a conversion is required to allow values greater than 128.
16830  // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
16831  template < typename C = CharType,
16832  enable_if_t < std::is_signed<C>::value&& std::is_signed<char>::value >* = nullptr >
16833  static constexpr CharType to_char_type(std::uint8_t x) noexcept
16834  {
16835  return *reinterpret_cast<char*>(&x);
16836  }
16837 
16838  template < typename C = CharType,
16839  enable_if_t < std::is_signed<C>::value&& std::is_unsigned<char>::value >* = nullptr >
16840  static CharType to_char_type(std::uint8_t x) noexcept
16841  {
16842  static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
16843  static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
16844  CharType result;
16845  std::memcpy(&result, &x, sizeof(x));
16846  return result;
16847  }
16848 
16849  template<typename C = CharType,
16850  enable_if_t<std::is_unsigned<C>::value>* = nullptr>
16851  static constexpr CharType to_char_type(std::uint8_t x) noexcept
16852  {
16853  return x;
16854  }
16855 
16856  template < typename InputCharType, typename C = CharType,
16857  enable_if_t <
16858  std::is_signed<C>::value&&
16859  std::is_signed<char>::value&&
16860  std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
16861  >* = nullptr >
16862  static constexpr CharType to_char_type(InputCharType x) noexcept
16863  {
16864  return x;
16865  }
16866 
16867  private:
16869  const bool is_little_endian = little_endianness();
16870 
16872  output_adapter_t<CharType> oa = nullptr;
16873  };
16874 
16875 } // namespace detail
16876 NLOHMANN_JSON_NAMESPACE_END
16877 
16878 // #include <nlohmann/detail/output/output_adapters.hpp>
16879 
16880 // #include <nlohmann/detail/output/serializer.hpp>
16881 // __ _____ _____ _____
16882 // __| | __| | | | JSON for Modern C++
16883 // | | |__ | | | | | | version 3.11.3
16884 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
16885 //
16886 // SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>
16887 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
16888 // SPDX-License-Identifier: MIT
16889 
16890 
16891 
16892 #include <algorithm> // reverse, remove, fill, find, none_of
16893 #include <array> // array
16894 #include <clocale> // localeconv, lconv
16895 #include <cmath> // labs, isfinite, isnan, signbit
16896 #include <cstddef> // size_t, ptrdiff_t
16897 #include <cstdint> // uint8_t
16898 #include <cstdio> // snprintf
16899 #include <limits> // numeric_limits
16900 #include <string> // string, char_traits
16901 #include <iomanip> // setfill, setw
16902 #include <type_traits> // is_same
16903 #include <utility> // move
16904 
16905 // #include <nlohmann/detail/conversions/to_chars.hpp>
16906 // __ _____ _____ _____
16907 // __| | __| | | | JSON for Modern C++
16908 // | | |__ | | | | | | version 3.11.3
16909 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
16910 //
16911 // SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
16912 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
16913 // SPDX-License-Identifier: MIT
16914 
16915 
16916 
16917 #include <array> // array
16918 #include <cmath> // signbit, isfinite
16919 #include <cstdint> // intN_t, uintN_t
16920 #include <cstring> // memcpy, memmove
16921 #include <limits> // numeric_limits
16922 #include <type_traits> // conditional
16923 
16924 // #include <nlohmann/detail/macro_scope.hpp>
16925 
16926 
16927 NLOHMANN_JSON_NAMESPACE_BEGIN
16928 namespace detail
16929 {
16930 
16950  namespace dtoa_impl
16951  {
16952 
16953  template<typename Target, typename Source>
16954  Target reinterpret_bits(const Source source)
16955  {
16956  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
16957 
16958  Target target;
16959  std::memcpy(&target, &source, sizeof(Source));
16960  return target;
16961  }
16962 
16963  struct diyfp // f * 2^e
16964  {
16965  static constexpr int kPrecision = 64; // = q
16966 
16967  std::uint64_t f = 0;
16968  int e = 0;
16969 
16970  constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
16971 
16976  static diyfp sub(const diyfp& x, const diyfp& y) noexcept
16977  {
16978  JSON_ASSERT(x.e == y.e);
16979  JSON_ASSERT(x.f >= y.f);
16980 
16981  return { x.f - y.f, x.e };
16982  }
16983 
16988  static diyfp mul(const diyfp& x, const diyfp& y) noexcept
16989  {
16990  static_assert(kPrecision == 64, "internal error");
16991 
16992  // Computes:
16993  // f = round((x.f * y.f) / 2^q)
16994  // e = x.e + y.e + q
16995 
16996  // Emulate the 64-bit * 64-bit multiplication:
16997  //
16998  // p = u * v
16999  // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
17000  // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
17001  // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
17002  // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
17003  // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
17004  // = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
17005  // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
17006  //
17007  // (Since Q might be larger than 2^32 - 1)
17008  //
17009  // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
17010  //
17011  // (Q_hi + H does not overflow a 64-bit int)
17012  //
17013  // = p_lo + 2^64 p_hi
17014 
17015  const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
17016  const std::uint64_t u_hi = x.f >> 32u;
17017  const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
17018  const std::uint64_t v_hi = y.f >> 32u;
17019 
17020  const std::uint64_t p0 = u_lo * v_lo;
17021  const std::uint64_t p1 = u_lo * v_hi;
17022  const std::uint64_t p2 = u_hi * v_lo;
17023  const std::uint64_t p3 = u_hi * v_hi;
17024 
17025  const std::uint64_t p0_hi = p0 >> 32u;
17026  const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
17027  const std::uint64_t p1_hi = p1 >> 32u;
17028  const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
17029  const std::uint64_t p2_hi = p2 >> 32u;
17030 
17031  std::uint64_t Q = p0_hi + p1_lo + p2_lo;
17032 
17033  // The full product might now be computed as
17034  //
17035  // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
17036  // p_lo = p0_lo + (Q << 32)
17037  //
17038  // But in this particular case here, the full p_lo is not required.
17039  // Effectively we only need to add the highest bit in p_lo to p_hi (and
17040  // Q_hi + 1 does not overflow).
17041 
17042  Q += std::uint64_t{ 1 } << (64u - 32u - 1u); // round, ties up
17043 
17044  const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
17045 
17046  return { h, x.e + y.e + 64 };
17047  }
17048 
17053  static diyfp normalize(diyfp x) noexcept
17054  {
17055  JSON_ASSERT(x.f != 0);
17056 
17057  while ((x.f >> 63u) == 0)
17058  {
17059  x.f <<= 1u;
17060  x.e--;
17061  }
17062 
17063  return x;
17064  }
17065 
17070  static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
17071  {
17072  const int delta = x.e - target_exponent;
17073 
17074  JSON_ASSERT(delta >= 0);
17075  JSON_ASSERT(((x.f << delta) >> delta) == x.f);
17076 
17077  return { x.f << delta, target_exponent };
17078  }
17079  };
17080 
17081  struct boundaries
17082  {
17083  diyfp w;
17084  diyfp minus;
17085  diyfp plus;
17086  };
17087 
17094  template<typename FloatType>
17095  boundaries compute_boundaries(FloatType value)
17096  {
17097  JSON_ASSERT(std::isfinite(value));
17098  JSON_ASSERT(value > 0);
17099 
17100  // Convert the IEEE representation into a diyfp.
17101  //
17102  // If v is denormal:
17103  // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
17104  // If v is normalized:
17105  // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
17106 
17107  static_assert(std::numeric_limits<FloatType>::is_iec559,
17108  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
17109 
17110  constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
17111  constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
17112  constexpr int kMinExp = 1 - kBias;
17113  constexpr std::uint64_t kHiddenBit = std::uint64_t{ 1 } << (kPrecision - 1); // = 2^(p-1)
17114 
17115  using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
17116 
17117  const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
17118  const std::uint64_t E = bits >> (kPrecision - 1);
17119  const std::uint64_t F = bits & (kHiddenBit - 1);
17120 
17121  const bool is_denormal = E == 0;
17122  const diyfp v = is_denormal
17123  ? diyfp(F, kMinExp)
17124  : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
17125 
17126  // Compute the boundaries m- and m+ of the floating-point value
17127  // v = f * 2^e.
17128  //
17129  // Determine v- and v+, the floating-point predecessor and successor if v,
17130  // respectively.
17131  //
17132  // v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
17133  // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
17134  //
17135  // v+ = v + 2^e
17136  //
17137  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
17138  // between m- and m+ round to v, regardless of how the input rounding
17139  // algorithm breaks ties.
17140  //
17141  // ---+-------------+-------------+-------------+-------------+--- (A)
17142  // v- m- v m+ v+
17143  //
17144  // -----------------+------+------+-------------+-------------+--- (B)
17145  // v- m- v m+ v+
17146 
17147  const bool lower_boundary_is_closer = F == 0 && E > 1;
17148  const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
17149  const diyfp m_minus = lower_boundary_is_closer
17150  ? diyfp(4 * v.f - 1, v.e - 2) // (B)
17151  : diyfp(2 * v.f - 1, v.e - 1); // (A)
17152 
17153  // Determine the normalized w+ = m+.
17154  const diyfp w_plus = diyfp::normalize(m_plus);
17155 
17156  // Determine w- = m- such that e_(w-) = e_(w+).
17157  const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
17158 
17159  return { diyfp::normalize(v), w_minus, w_plus };
17160  }
17161 
17162  // Given normalized diyfp w, Grisu needs to find a (normalized) cached
17163  // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
17164  // within a certain range [alpha, gamma] (Definition 3.2 from [1])
17165  //
17166  // alpha <= e = e_c + e_w + q <= gamma
17167  //
17168  // or
17169  //
17170  // f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
17171  // <= f_c * f_w * 2^gamma
17172  //
17173  // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
17174  //
17175  // 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
17176  //
17177  // or
17178  //
17179  // 2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
17180  //
17181  // The choice of (alpha,gamma) determines the size of the table and the form of
17182  // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
17183  // in practice:
17184  //
17185  // The idea is to cut the number c * w = f * 2^e into two parts, which can be
17186  // processed independently: An integral part p1, and a fractional part p2:
17187  //
17188  // f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
17189  // = (f div 2^-e) + (f mod 2^-e) * 2^e
17190  // = p1 + p2 * 2^e
17191  //
17192  // The conversion of p1 into decimal form requires a series of divisions and
17193  // modulos by (a power of) 10. These operations are faster for 32-bit than for
17194  // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
17195  // achieved by choosing
17196  //
17197  // -e >= 32 or e <= -32 := gamma
17198  //
17199  // In order to convert the fractional part
17200  //
17201  // p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
17202  //
17203  // into decimal form, the fraction is repeatedly multiplied by 10 and the digits
17204  // d[-i] are extracted in order:
17205  //
17206  // (10 * p2) div 2^-e = d[-1]
17207  // (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
17208  //
17209  // The multiplication by 10 must not overflow. It is sufficient to choose
17210  //
17211  // 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
17212  //
17213  // Since p2 = f mod 2^-e < 2^-e,
17214  //
17215  // -e <= 60 or e >= -60 := alpha
17216 
17217  constexpr int kAlpha = -60;
17218  constexpr int kGamma = -32;
17219 
17220  struct cached_power // c = f * 2^e ~= 10^k
17221  {
17222  std::uint64_t f;
17223  int e;
17224  int k;
17225  };
17226 
17234  inline cached_power get_cached_power_for_binary_exponent(int e)
17235  {
17236  // Now
17237  //
17238  // alpha <= e_c + e + q <= gamma (1)
17239  // ==> f_c * 2^alpha <= c * 2^e * 2^q
17240  //
17241  // and since the c's are normalized, 2^(q-1) <= f_c,
17242  //
17243  // ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
17244  // ==> 2^(alpha - e - 1) <= c
17245  //
17246  // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
17247  //
17248  // k = ceil( log_10( 2^(alpha - e - 1) ) )
17249  // = ceil( (alpha - e - 1) * log_10(2) )
17250  //
17251  // From the paper:
17252  // "In theory the result of the procedure could be wrong since c is rounded,
17253  // and the computation itself is approximated [...]. In practice, however,
17254  // this simple function is sufficient."
17255  //
17256  // For IEEE double precision floating-point numbers converted into
17257  // normalized diyfp's w = f * 2^e, with q = 64,
17258  //
17259  // e >= -1022 (min IEEE exponent)
17260  // -52 (p - 1)
17261  // -52 (p - 1, possibly normalize denormal IEEE numbers)
17262  // -11 (normalize the diyfp)
17263  // = -1137
17264  //
17265  // and
17266  //
17267  // e <= +1023 (max IEEE exponent)
17268  // -52 (p - 1)
17269  // -11 (normalize the diyfp)
17270  // = 960
17271  //
17272  // This binary exponent range [-1137,960] results in a decimal exponent
17273  // range [-307,324]. One does not need to store a cached power for each
17274  // k in this range. For each such k it suffices to find a cached power
17275  // such that the exponent of the product lies in [alpha,gamma].
17276  // This implies that the difference of the decimal exponents of adjacent
17277  // table entries must be less than or equal to
17278  //
17279  // floor( (gamma - alpha) * log_10(2) ) = 8.
17280  //
17281  // (A smaller distance gamma-alpha would require a larger table.)
17282 
17283  // NB:
17284  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
17285 
17286  constexpr int kCachedPowersMinDecExp = -300;
17287  constexpr int kCachedPowersDecStep = 8;
17288 
17289  static constexpr std::array<cached_power, 79> kCachedPowers =
17290  {
17291  {
17292  { 0xAB70FE17C79AC6CA, -1060, -300 },
17293  { 0xFF77B1FCBEBCDC4F, -1034, -292 },
17294  { 0xBE5691EF416BD60C, -1007, -284 },
17295  { 0x8DD01FAD907FFC3C, -980, -276 },
17296  { 0xD3515C2831559A83, -954, -268 },
17297  { 0x9D71AC8FADA6C9B5, -927, -260 },
17298  { 0xEA9C227723EE8BCB, -901, -252 },
17299  { 0xAECC49914078536D, -874, -244 },
17300  { 0x823C12795DB6CE57, -847, -236 },
17301  { 0xC21094364DFB5637, -821, -228 },
17302  { 0x9096EA6F3848984F, -794, -220 },
17303  { 0xD77485CB25823AC7, -768, -212 },
17304  { 0xA086CFCD97BF97F4, -741, -204 },
17305  { 0xEF340A98172AACE5, -715, -196 },
17306  { 0xB23867FB2A35B28E, -688, -188 },
17307  { 0x84C8D4DFD2C63F3B, -661, -180 },
17308  { 0xC5DD44271AD3CDBA, -635, -172 },
17309  { 0x936B9FCEBB25C996, -608, -164 },
17310  { 0xDBAC6C247D62A584, -582, -156 },
17311  { 0xA3AB66580D5FDAF6, -555, -148 },
17312  { 0xF3E2F893DEC3F126, -529, -140 },
17313  { 0xB5B5ADA8AAFF80B8, -502, -132 },
17314  { 0x87625F056C7C4A8B, -475, -124 },
17315  { 0xC9BCFF6034C13053, -449, -116 },
17316  { 0x964E858C91BA2655, -422, -108 },
17317  { 0xDFF9772470297EBD, -396, -100 },
17318  { 0xA6DFBD9FB8E5B88F, -369, -92 },
17319  { 0xF8A95FCF88747D94, -343, -84 },
17320  { 0xB94470938FA89BCF, -316, -76 },
17321  { 0x8A08F0F8BF0F156B, -289, -68 },
17322  { 0xCDB02555653131B6, -263, -60 },
17323  { 0x993FE2C6D07B7FAC, -236, -52 },
17324  { 0xE45C10C42A2B3B06, -210, -44 },
17325  { 0xAA242499697392D3, -183, -36 },
17326  { 0xFD87B5F28300CA0E, -157, -28 },
17327  { 0xBCE5086492111AEB, -130, -20 },
17328  { 0x8CBCCC096F5088CC, -103, -12 },
17329  { 0xD1B71758E219652C, -77, -4 },
17330  { 0x9C40000000000000, -50, 4 },
17331  { 0xE8D4A51000000000, -24, 12 },
17332  { 0xAD78EBC5AC620000, 3, 20 },
17333  { 0x813F3978F8940984, 30, 28 },
17334  { 0xC097CE7BC90715B3, 56, 36 },
17335  { 0x8F7E32CE7BEA5C70, 83, 44 },
17336  { 0xD5D238A4ABE98068, 109, 52 },
17337  { 0x9F4F2726179A2245, 136, 60 },
17338  { 0xED63A231D4C4FB27, 162, 68 },
17339  { 0xB0DE65388CC8ADA8, 189, 76 },
17340  { 0x83C7088E1AAB65DB, 216, 84 },
17341  { 0xC45D1DF942711D9A, 242, 92 },
17342  { 0x924D692CA61BE758, 269, 100 },
17343  { 0xDA01EE641A708DEA, 295, 108 },
17344  { 0xA26DA3999AEF774A, 322, 116 },
17345  { 0xF209787BB47D6B85, 348, 124 },
17346  { 0xB454E4A179DD1877, 375, 132 },
17347  { 0x865B86925B9BC5C2, 402, 140 },
17348  { 0xC83553C5C8965D3D, 428, 148 },
17349  { 0x952AB45CFA97A0B3, 455, 156 },
17350  { 0xDE469FBD99A05FE3, 481, 164 },
17351  { 0xA59BC234DB398C25, 508, 172 },
17352  { 0xF6C69A72A3989F5C, 534, 180 },
17353  { 0xB7DCBF5354E9BECE, 561, 188 },
17354  { 0x88FCF317F22241E2, 588, 196 },
17355  { 0xCC20CE9BD35C78A5, 614, 204 },
17356  { 0x98165AF37B2153DF, 641, 212 },
17357  { 0xE2A0B5DC971F303A, 667, 220 },
17358  { 0xA8D9D1535CE3B396, 694, 228 },
17359  { 0xFB9B7CD9A4A7443C, 720, 236 },
17360  { 0xBB764C4CA7A44410, 747, 244 },
17361  { 0x8BAB8EEFB6409C1A, 774, 252 },
17362  { 0xD01FEF10A657842C, 800, 260 },
17363  { 0x9B10A4E5E9913129, 827, 268 },
17364  { 0xE7109BFBA19C0C9D, 853, 276 },
17365  { 0xAC2820D9623BF429, 880, 284 },
17366  { 0x80444B5E7AA7CF85, 907, 292 },
17367  { 0xBF21E44003ACDD2D, 933, 300 },
17368  { 0x8E679C2F5E44FF8F, 960, 308 },
17369  { 0xD433179D9C8CB841, 986, 316 },
17370  { 0x9E19DB92B4E31BA9, 1013, 324 },
17371  }
17372  };
17373 
17374  // This computation gives exactly the same results for k as
17375  // k = ceil((kAlpha - e - 1) * 0.30102999566398114)
17376  // for |e| <= 1500, but doesn't require floating-point operations.
17377  // NB: log_10(2) ~= 78913 / 2^18
17378  JSON_ASSERT(e >= -1500);
17379  JSON_ASSERT(e <= 1500);
17380  const int f = kAlpha - e - 1;
17381  const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
17382 
17383  const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
17384  JSON_ASSERT(index >= 0);
17385  JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
17386 
17387  const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
17388  JSON_ASSERT(kAlpha <= cached.e + e + 64);
17389  JSON_ASSERT(kGamma >= cached.e + e + 64);
17390 
17391  return cached;
17392  }
17393 
17398  inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
17399  {
17400  // LCOV_EXCL_START
17401  if (n >= 1000000000)
17402  {
17403  pow10 = 1000000000;
17404  return 10;
17405  }
17406  // LCOV_EXCL_STOP
17407  if (n >= 100000000)
17408  {
17409  pow10 = 100000000;
17410  return 9;
17411  }
17412  if (n >= 10000000)
17413  {
17414  pow10 = 10000000;
17415  return 8;
17416  }
17417  if (n >= 1000000)
17418  {
17419  pow10 = 1000000;
17420  return 7;
17421  }
17422  if (n >= 100000)
17423  {
17424  pow10 = 100000;
17425  return 6;
17426  }
17427  if (n >= 10000)
17428  {
17429  pow10 = 10000;
17430  return 5;
17431  }
17432  if (n >= 1000)
17433  {
17434  pow10 = 1000;
17435  return 4;
17436  }
17437  if (n >= 100)
17438  {
17439  pow10 = 100;
17440  return 3;
17441  }
17442  if (n >= 10)
17443  {
17444  pow10 = 10;
17445  return 2;
17446  }
17447 
17448  pow10 = 1;
17449  return 1;
17450  }
17451 
17452  inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
17453  std::uint64_t rest, std::uint64_t ten_k)
17454  {
17455  JSON_ASSERT(len >= 1);
17456  JSON_ASSERT(dist <= delta);
17457  JSON_ASSERT(rest <= delta);
17458  JSON_ASSERT(ten_k > 0);
17459 
17460  // <--------------------------- delta ---->
17461  // <---- dist --------->
17462  // --------------[------------------+-------------------]--------------
17463  // M- w M+
17464  //
17465  // ten_k
17466  // <------>
17467  // <---- rest ---->
17468  // --------------[------------------+----+--------------]--------------
17469  // w V
17470  // = buf * 10^k
17471  //
17472  // ten_k represents a unit-in-the-last-place in the decimal representation
17473  // stored in buf.
17474  // Decrement buf by ten_k while this takes buf closer to w.
17475 
17476  // The tests are written in this order to avoid overflow in unsigned
17477  // integer arithmetic.
17478 
17479  while (rest < dist
17480  && delta - rest >= ten_k
17481  && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
17482  {
17483  JSON_ASSERT(buf[len - 1] != '0');
17484  buf[len - 1]--;
17485  rest += ten_k;
17486  }
17487  }
17488 
17493  inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
17494  diyfp M_minus, diyfp w, diyfp M_plus)
17495  {
17496  static_assert(kAlpha >= -60, "internal error");
17497  static_assert(kGamma <= -32, "internal error");
17498 
17499  // Generates the digits (and the exponent) of a decimal floating-point
17500  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
17501  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
17502  //
17503  // <--------------------------- delta ---->
17504  // <---- dist --------->
17505  // --------------[------------------+-------------------]--------------
17506  // M- w M+
17507  //
17508  // Grisu2 generates the digits of M+ from left to right and stops as soon as
17509  // V is in [M-,M+].
17510 
17511  JSON_ASSERT(M_plus.e >= kAlpha);
17512  JSON_ASSERT(M_plus.e <= kGamma);
17513 
17514  std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
17515  std::uint64_t dist = diyfp::sub(M_plus, w).f; // (significand of (M+ - w ), implicit exponent is e)
17516 
17517  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
17518  //
17519  // M+ = f * 2^e
17520  // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
17521  // = ((p1 ) * 2^-e + (p2 )) * 2^e
17522  // = p1 + p2 * 2^e
17523 
17524  const diyfp one(std::uint64_t{ 1 } << -M_plus.e, M_plus.e);
17525 
17526  auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
17527  std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
17528 
17529  // 1)
17530  //
17531  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
17532 
17533  JSON_ASSERT(p1 > 0);
17534 
17535  std::uint32_t pow10{};
17536  const int k = find_largest_pow10(p1, pow10);
17537 
17538  // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
17539  //
17540  // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
17541  // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
17542  //
17543  // M+ = p1 + p2 * 2^e
17544  // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
17545  // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
17546  // = d[k-1] * 10^(k-1) + ( rest) * 2^e
17547  //
17548  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
17549  //
17550  // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
17551  //
17552  // but stop as soon as
17553  //
17554  // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
17555 
17556  int n = k;
17557  while (n > 0)
17558  {
17559  // Invariants:
17560  // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
17561  // pow10 = 10^(n-1) <= p1 < 10^n
17562  //
17563  const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
17564  const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
17565  //
17566  // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
17567  // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
17568  //
17569  JSON_ASSERT(d <= 9);
17570  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
17571  //
17572  // M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
17573  //
17574  p1 = r;
17575  n--;
17576  //
17577  // M+ = buffer * 10^n + (p1 + p2 * 2^e)
17578  // pow10 = 10^n
17579  //
17580 
17581  // Now check if enough digits have been generated.
17582  // Compute
17583  //
17584  // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
17585  //
17586  // Note:
17587  // Since rest and delta share the same exponent e, it suffices to
17588  // compare the significands.
17589  const std::uint64_t rest = (std::uint64_t{ p1 } << -one.e) + p2;
17590  if (rest <= delta)
17591  {
17592  // V = buffer * 10^n, with M- <= V <= M+.
17593 
17594  decimal_exponent += n;
17595 
17596  // We may now just stop. But instead look if the buffer could be
17597  // decremented to bring V closer to w.
17598  //
17599  // pow10 = 10^n is now 1 ulp in the decimal representation V.
17600  // The rounding procedure works with diyfp's with an implicit
17601  // exponent of e.
17602  //
17603  // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
17604  //
17605  const std::uint64_t ten_n = std::uint64_t{ pow10 } << -one.e;
17606  grisu2_round(buffer, length, dist, delta, rest, ten_n);
17607 
17608  return;
17609  }
17610 
17611  pow10 /= 10;
17612  //
17613  // pow10 = 10^(n-1) <= p1 < 10^n
17614  // Invariants restored.
17615  }
17616 
17617  // 2)
17618  //
17619  // The digits of the integral part have been generated:
17620  //
17621  // M+ = d[k-1]...d[1]d[0] + p2 * 2^e
17622  // = buffer + p2 * 2^e
17623  //
17624  // Now generate the digits of the fractional part p2 * 2^e.
17625  //
17626  // Note:
17627  // No decimal point is generated: the exponent is adjusted instead.
17628  //
17629  // p2 actually represents the fraction
17630  //
17631  // p2 * 2^e
17632  // = p2 / 2^-e
17633  // = d[-1] / 10^1 + d[-2] / 10^2 + ...
17634  //
17635  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
17636  //
17637  // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
17638  // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
17639  //
17640  // using
17641  //
17642  // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
17643  // = ( d) * 2^-e + ( r)
17644  //
17645  // or
17646  // 10^m * p2 * 2^e = d + r * 2^e
17647  //
17648  // i.e.
17649  //
17650  // M+ = buffer + p2 * 2^e
17651  // = buffer + 10^-m * (d + r * 2^e)
17652  // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
17653  //
17654  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
17655 
17656  JSON_ASSERT(p2 > delta);
17657 
17658  int m = 0;
17659  for (;;)
17660  {
17661  // Invariant:
17662  // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
17663  // = buffer * 10^-m + 10^-m * (p2 ) * 2^e
17664  // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
17665  // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
17666  //
17667  JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
17668  p2 *= 10;
17669  const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
17670  const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
17671  //
17672  // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
17673  // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
17674  // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
17675  //
17676  JSON_ASSERT(d <= 9);
17677  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
17678  //
17679  // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
17680  //
17681  p2 = r;
17682  m++;
17683  //
17684  // M+ = buffer * 10^-m + 10^-m * p2 * 2^e
17685  // Invariant restored.
17686 
17687  // Check if enough digits have been generated.
17688  //
17689  // 10^-m * p2 * 2^e <= delta * 2^e
17690  // p2 * 2^e <= 10^m * delta * 2^e
17691  // p2 <= 10^m * delta
17692  delta *= 10;
17693  dist *= 10;
17694  if (p2 <= delta)
17695  {
17696  break;
17697  }
17698  }
17699 
17700  // V = buffer * 10^-m, with M- <= V <= M+.
17701 
17702  decimal_exponent -= m;
17703 
17704  // 1 ulp in the decimal representation is now 10^-m.
17705  // Since delta and dist are now scaled by 10^m, we need to do the
17706  // same with ulp in order to keep the units in sync.
17707  //
17708  // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
17709  //
17710  const std::uint64_t ten_m = one.f;
17711  grisu2_round(buffer, length, dist, delta, p2, ten_m);
17712 
17713  // By construction this algorithm generates the shortest possible decimal
17714  // number (Loitsch, Theorem 6.2) which rounds back to w.
17715  // For an input number of precision p, at least
17716  //
17717  // N = 1 + ceil(p * log_10(2))
17718  //
17719  // decimal digits are sufficient to identify all binary floating-point
17720  // numbers (Matula, "In-and-Out conversions").
17721  // This implies that the algorithm does not produce more than N decimal
17722  // digits.
17723  //
17724  // N = 17 for p = 53 (IEEE double precision)
17725  // N = 9 for p = 24 (IEEE single precision)
17726  }
17727 
17733  JSON_HEDLEY_NON_NULL(1)
17734  inline void grisu2(char* buf, int& len, int& decimal_exponent,
17735  diyfp m_minus, diyfp v, diyfp m_plus)
17736  {
17737  JSON_ASSERT(m_plus.e == m_minus.e);
17738  JSON_ASSERT(m_plus.e == v.e);
17739 
17740  // --------(-----------------------+-----------------------)-------- (A)
17741  // m- v m+
17742  //
17743  // --------------------(-----------+-----------------------)-------- (B)
17744  // m- v m+
17745  //
17746  // First scale v (and m- and m+) such that the exponent is in the range
17747  // [alpha, gamma].
17748 
17749  const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
17750 
17751  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
17752 
17753  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
17754  const diyfp w = diyfp::mul(v, c_minus_k);
17755  const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
17756  const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
17757 
17758  // ----(---+---)---------------(---+---)---------------(---+---)----
17759  // w- w w+
17760  // = c*m- = c*v = c*m+
17761  //
17762  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
17763  // w+ are now off by a small amount.
17764  // In fact:
17765  //
17766  // w - v * 10^k < 1 ulp
17767  //
17768  // To account for this inaccuracy, add resp. subtract 1 ulp.
17769  //
17770  // --------+---[---------------(---+---)---------------]---+--------
17771  // w- M- w M+ w+
17772  //
17773  // Now any number in [M-, M+] (bounds included) will round to w when input,
17774  // regardless of how the input rounding algorithm breaks ties.
17775  //
17776  // And digit_gen generates the shortest possible such number in [M-, M+].
17777  // Note that this does not mean that Grisu2 always generates the shortest
17778  // possible number in the interval (m-, m+).
17779  const diyfp M_minus(w_minus.f + 1, w_minus.e);
17780  const diyfp M_plus(w_plus.f - 1, w_plus.e);
17781 
17782  decimal_exponent = -cached.k; // = -(-k) = k
17783 
17784  grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
17785  }
17786 
17792  template<typename FloatType>
17793  JSON_HEDLEY_NON_NULL(1)
17794  void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
17795  {
17796  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
17797  "internal error: not enough precision");
17798 
17799  JSON_ASSERT(std::isfinite(value));
17800  JSON_ASSERT(value > 0);
17801 
17802  // If the neighbors (and boundaries) of 'value' are always computed for double-precision
17803  // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
17804  // decimal representations are not exactly "short".
17805  //
17806  // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
17807  // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
17808  // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
17809  // does.
17810  // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
17811  // representation using the corresponding std::from_chars function recovers value exactly". That
17812  // indicates that single precision floating-point numbers should be recovered using
17813  // 'std::strtof'.
17814  //
17815  // NB: If the neighbors are computed for single-precision numbers, there is a single float
17816  // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
17817  // value is off by 1 ulp.
17818 #if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
17819  const boundaries w = compute_boundaries(static_cast<double>(value));
17820 #else
17821  const boundaries w = compute_boundaries(value);
17822 #endif
17823 
17824  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
17825  }
17826 
17832  JSON_HEDLEY_NON_NULL(1)
17833  JSON_HEDLEY_RETURNS_NON_NULL
17834  inline char* append_exponent(char* buf, int e)
17835  {
17836  JSON_ASSERT(e > -1000);
17837  JSON_ASSERT(e < 1000);
17838 
17839  if (e < 0)
17840  {
17841  e = -e;
17842  *buf++ = '-';
17843  }
17844  else
17845  {
17846  *buf++ = '+';
17847  }
17848 
17849  auto k = static_cast<std::uint32_t>(e);
17850  if (k < 10)
17851  {
17852  // Always print at least two digits in the exponent.
17853  // This is for compatibility with printf("%g").
17854  *buf++ = '0';
17855  *buf++ = static_cast<char>('0' + k);
17856  }
17857  else if (k < 100)
17858  {
17859  *buf++ = static_cast<char>('0' + k / 10);
17860  k %= 10;
17861  *buf++ = static_cast<char>('0' + k);
17862  }
17863  else
17864  {
17865  *buf++ = static_cast<char>('0' + k / 100);
17866  k %= 100;
17867  *buf++ = static_cast<char>('0' + k / 10);
17868  k %= 10;
17869  *buf++ = static_cast<char>('0' + k);
17870  }
17871 
17872  return buf;
17873  }
17874 
17884  JSON_HEDLEY_NON_NULL(1)
17885  JSON_HEDLEY_RETURNS_NON_NULL
17886  inline char* format_buffer(char* buf, int len, int decimal_exponent,
17887  int min_exp, int max_exp)
17888  {
17889  JSON_ASSERT(min_exp < 0);
17890  JSON_ASSERT(max_exp > 0);
17891 
17892  const int k = len;
17893  const int n = len + decimal_exponent;
17894 
17895  // v = buf * 10^(n-k)
17896  // k is the length of the buffer (number of decimal digits)
17897  // n is the position of the decimal point relative to the start of the buffer.
17898 
17899  if (k <= n && n <= max_exp)
17900  {
17901  // digits[000]
17902  // len <= max_exp + 2
17903 
17904  std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
17905  // Make it look like a floating-point number (#362, #378)
17906  buf[n + 0] = '.';
17907  buf[n + 1] = '0';
17908  return buf + (static_cast<size_t>(n) + 2);
17909  }
17910 
17911  if (0 < n && n <= max_exp)
17912  {
17913  // dig.its
17914  // len <= max_digits10 + 1
17915 
17916  JSON_ASSERT(k > n);
17917 
17918  std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
17919  buf[n] = '.';
17920  return buf + (static_cast<size_t>(k) + 1U);
17921  }
17922 
17923  if (min_exp < n && n <= 0)
17924  {
17925  // 0.[000]digits
17926  // len <= 2 + (-min_exp - 1) + max_digits10
17927 
17928  std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
17929  buf[0] = '0';
17930  buf[1] = '.';
17931  std::memset(buf + 2, '0', static_cast<size_t>(-n));
17932  return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
17933  }
17934 
17935  if (k == 1)
17936  {
17937  // dE+123
17938  // len <= 1 + 5
17939 
17940  buf += 1;
17941  }
17942  else
17943  {
17944  // d.igitsE+123
17945  // len <= max_digits10 + 1 + 5
17946 
17947  std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
17948  buf[1] = '.';
17949  buf += 1 + static_cast<size_t>(k);
17950  }
17951 
17952  *buf++ = 'e';
17953  return append_exponent(buf, n - 1);
17954  }
17955 
17956  } // namespace dtoa_impl
17957 
17968  template<typename FloatType>
17969  JSON_HEDLEY_NON_NULL(1, 2)
17970  JSON_HEDLEY_RETURNS_NON_NULL
17971  char* to_chars(char* first, const char* last, FloatType value)
17972  {
17973  static_cast<void>(last); // maybe unused - fix warning
17974  JSON_ASSERT(std::isfinite(value));
17975 
17976  // Use signbit(value) instead of (value < 0) since signbit works for -0.
17977  if (std::signbit(value))
17978  {
17979  value = -value;
17980  *first++ = '-';
17981  }
17982 
17983 #ifdef __GNUC__
17984 #pragma GCC diagnostic push
17985 #pragma GCC diagnostic ignored "-Wfloat-equal"
17986 #endif
17987  if (value == 0) // +-0
17988  {
17989  *first++ = '0';
17990  // Make it look like a floating-point number (#362, #378)
17991  *first++ = '.';
17992  *first++ = '0';
17993  return first;
17994  }
17995 #ifdef __GNUC__
17996 #pragma GCC diagnostic pop
17997 #endif
17998 
17999  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
18000 
18001  // Compute v = buffer * 10^decimal_exponent.
18002  // The decimal digits are stored in the buffer, which needs to be interpreted
18003  // as an unsigned decimal integer.
18004  // len is the length of the buffer, i.e. the number of decimal digits.
18005  int len = 0;
18006  int decimal_exponent = 0;
18007  dtoa_impl::grisu2(first, len, decimal_exponent, value);
18008 
18009  JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
18010 
18011  // Format the buffer like printf("%.*g", prec, value)
18012  constexpr int kMinExp = -4;
18013  // Use digits10 here to increase compatibility with version 2.
18014  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
18015 
18016  JSON_ASSERT(last - first >= kMaxExp + 2);
18017  JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
18018  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
18019 
18020  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
18021  }
18022 
18023 } // namespace detail
18024 NLOHMANN_JSON_NAMESPACE_END
18025 
18026 // #include <nlohmann/detail/exceptions.hpp>
18027 
18028 // #include <nlohmann/detail/macro_scope.hpp>
18029 
18030 // #include <nlohmann/detail/meta/cpp_future.hpp>
18031 
18032 // #include <nlohmann/detail/output/binary_writer.hpp>
18033 
18034 // #include <nlohmann/detail/output/output_adapters.hpp>
18035 
18036 // #include <nlohmann/detail/string_concat.hpp>
18037 
18038 // #include <nlohmann/detail/value_t.hpp>
18039 
18040 
18041 NLOHMANN_JSON_NAMESPACE_BEGIN
18042 namespace detail
18043 {
18044 
18046  // serialization //
18048 
18050  enum class error_handler_t
18051  {
18052  strict,
18053  replace,
18054  ignore
18055  };
18056 
18057  template<typename BasicJsonType>
18058  class serializer
18059  {
18060  using string_t = typename BasicJsonType::string_t;
18061  using number_float_t = typename BasicJsonType::number_float_t;
18062  using number_integer_t = typename BasicJsonType::number_integer_t;
18063  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
18064  using binary_char_t = typename BasicJsonType::binary_t::value_type;
18065  static constexpr std::uint8_t UTF8_ACCEPT = 0;
18066  static constexpr std::uint8_t UTF8_REJECT = 1;
18067 
18068  public:
18074  serializer(output_adapter_t<char> s, const char ichar,
18075  error_handler_t error_handler_ = error_handler_t::strict)
18076  : o(std::move(s))
18077  , loc(std::localeconv())
18078  , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(*(loc->thousands_sep)))
18079  , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(*(loc->decimal_point)))
18080  , indent_char(ichar)
18081  , indent_string(512, indent_char)
18082  , error_handler(error_handler_)
18083  {}
18084 
18085  // delete because of pointer members
18086  serializer(const serializer&) = delete;
18087  serializer& operator=(const serializer&) = delete;
18088  serializer(serializer&&) = delete;
18089  serializer& operator=(serializer&&) = delete;
18090  ~serializer() = default;
18091 
18114  void dump(const BasicJsonType& val,
18115  const bool pretty_print,
18116  const bool ensure_ascii,
18117  const unsigned int indent_step,
18118  const unsigned int current_indent = 0)
18119  {
18120  switch (val.m_data.m_type)
18121  {
18122  case value_t::object:
18123  {
18124  if (val.m_data.m_value.object->empty())
18125  {
18126  o->write_characters("{}", 2);
18127  return;
18128  }
18129 
18130  if (pretty_print)
18131  {
18132  o->write_characters("{\n", 2);
18133 
18134  // variable to hold indentation for recursive calls
18135  const auto new_indent = current_indent + indent_step;
18136  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
18137  {
18138  indent_string.resize(indent_string.size() * 2, ' ');
18139  }
18140 
18141  // first n-1 elements
18142  auto i = val.m_data.m_value.object->cbegin();
18143  for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
18144  {
18145  o->write_characters(indent_string.c_str(), new_indent);
18146  o->write_character('\"');
18147  dump_escaped(i->first, ensure_ascii);
18148  o->write_characters("\": ", 3);
18149  dump(i->second, true, ensure_ascii, indent_step, new_indent);
18150  o->write_characters(",\n", 2);
18151  }
18152 
18153  // last element
18154  JSON_ASSERT(i != val.m_data.m_value.object->cend());
18155  JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
18156  o->write_characters(indent_string.c_str(), new_indent);
18157  o->write_character('\"');
18158  dump_escaped(i->first, ensure_ascii);
18159  o->write_characters("\": ", 3);
18160  dump(i->second, true, ensure_ascii, indent_step, new_indent);
18161 
18162  o->write_character('\n');
18163  o->write_characters(indent_string.c_str(), current_indent);
18164  o->write_character('}');
18165  }
18166  else
18167  {
18168  o->write_character('{');
18169 
18170  // first n-1 elements
18171  auto i = val.m_data.m_value.object->cbegin();
18172  for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
18173  {
18174  o->write_character('\"');
18175  dump_escaped(i->first, ensure_ascii);
18176  o->write_characters("\":", 2);
18177  dump(i->second, false, ensure_ascii, indent_step, current_indent);
18178  o->write_character(',');
18179  }
18180 
18181  // last element
18182  JSON_ASSERT(i != val.m_data.m_value.object->cend());
18183  JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
18184  o->write_character('\"');
18185  dump_escaped(i->first, ensure_ascii);
18186  o->write_characters("\":", 2);
18187  dump(i->second, false, ensure_ascii, indent_step, current_indent);
18188 
18189  o->write_character('}');
18190  }
18191 
18192  return;
18193  }
18194 
18195  case value_t::array:
18196  {
18197  if (val.m_data.m_value.array->empty())
18198  {
18199  o->write_characters("[]", 2);
18200  return;
18201  }
18202 
18203  if (pretty_print)
18204  {
18205  o->write_characters("[\n", 2);
18206 
18207  // variable to hold indentation for recursive calls
18208  const auto new_indent = current_indent + indent_step;
18209  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
18210  {
18211  indent_string.resize(indent_string.size() * 2, ' ');
18212  }
18213 
18214  // first n-1 elements
18215  for (auto i = val.m_data.m_value.array->cbegin();
18216  i != val.m_data.m_value.array->cend() - 1; ++i)
18217  {
18218  o->write_characters(indent_string.c_str(), new_indent);
18219  dump(*i, true, ensure_ascii, indent_step, new_indent);
18220  o->write_characters(",\n", 2);
18221  }
18222 
18223  // last element
18224  JSON_ASSERT(!val.m_data.m_value.array->empty());
18225  o->write_characters(indent_string.c_str(), new_indent);
18226  dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
18227 
18228  o->write_character('\n');
18229  o->write_characters(indent_string.c_str(), current_indent);
18230  o->write_character(']');
18231  }
18232  else
18233  {
18234  o->write_character('[');
18235 
18236  // first n-1 elements
18237  for (auto i = val.m_data.m_value.array->cbegin();
18238  i != val.m_data.m_value.array->cend() - 1; ++i)
18239  {
18240  dump(*i, false, ensure_ascii, indent_step, current_indent);
18241  o->write_character(',');
18242  }
18243 
18244  // last element
18245  JSON_ASSERT(!val.m_data.m_value.array->empty());
18246  dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
18247 
18248  o->write_character(']');
18249  }
18250 
18251  return;
18252  }
18253 
18254  case value_t::string:
18255  {
18256  o->write_character('\"');
18257  dump_escaped(*val.m_data.m_value.string, ensure_ascii);
18258  o->write_character('\"');
18259  return;
18260  }
18261 
18262  case value_t::binary:
18263  {
18264  if (pretty_print)
18265  {
18266  o->write_characters("{\n", 2);
18267 
18268  // variable to hold indentation for recursive calls
18269  const auto new_indent = current_indent + indent_step;
18270  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
18271  {
18272  indent_string.resize(indent_string.size() * 2, ' ');
18273  }
18274 
18275  o->write_characters(indent_string.c_str(), new_indent);
18276 
18277  o->write_characters("\"bytes\": [", 10);
18278 
18279  if (!val.m_data.m_value.binary->empty())
18280  {
18281  for (auto i = val.m_data.m_value.binary->cbegin();
18282  i != val.m_data.m_value.binary->cend() - 1; ++i)
18283  {
18284  dump_integer(*i);
18285  o->write_characters(", ", 2);
18286  }
18287  dump_integer(val.m_data.m_value.binary->back());
18288  }
18289 
18290  o->write_characters("],\n", 3);
18291  o->write_characters(indent_string.c_str(), new_indent);
18292 
18293  o->write_characters("\"subtype\": ", 11);
18294  if (val.m_data.m_value.binary->has_subtype())
18295  {
18296  dump_integer(val.m_data.m_value.binary->subtype());
18297  }
18298  else
18299  {
18300  o->write_characters("null", 4);
18301  }
18302  o->write_character('\n');
18303  o->write_characters(indent_string.c_str(), current_indent);
18304  o->write_character('}');
18305  }
18306  else
18307  {
18308  o->write_characters("{\"bytes\":[", 10);
18309 
18310  if (!val.m_data.m_value.binary->empty())
18311  {
18312  for (auto i = val.m_data.m_value.binary->cbegin();
18313  i != val.m_data.m_value.binary->cend() - 1; ++i)
18314  {
18315  dump_integer(*i);
18316  o->write_character(',');
18317  }
18318  dump_integer(val.m_data.m_value.binary->back());
18319  }
18320 
18321  o->write_characters("],\"subtype\":", 12);
18322  if (val.m_data.m_value.binary->has_subtype())
18323  {
18324  dump_integer(val.m_data.m_value.binary->subtype());
18325  o->write_character('}');
18326  }
18327  else
18328  {
18329  o->write_characters("null}", 5);
18330  }
18331  }
18332  return;
18333  }
18334 
18335  case value_t::boolean:
18336  {
18337  if (val.m_data.m_value.boolean)
18338  {
18339  o->write_characters("true", 4);
18340  }
18341  else
18342  {
18343  o->write_characters("false", 5);
18344  }
18345  return;
18346  }
18347 
18348  case value_t::number_integer:
18349  {
18350  dump_integer(val.m_data.m_value.number_integer);
18351  return;
18352  }
18353 
18354  case value_t::number_unsigned:
18355  {
18356  dump_integer(val.m_data.m_value.number_unsigned);
18357  return;
18358  }
18359 
18360  case value_t::number_float:
18361  {
18362  dump_float(val.m_data.m_value.number_float);
18363  return;
18364  }
18365 
18366  case value_t::discarded:
18367  {
18368  o->write_characters("<discarded>", 11);
18369  return;
18370  }
18371 
18372  case value_t::null:
18373  {
18374  o->write_characters("null", 4);
18375  return;
18376  }
18377 
18378  default: // LCOV_EXCL_LINE
18379  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
18380  }
18381  }
18382 
18383  JSON_PRIVATE_UNLESS_TESTED:
18398  void dump_escaped(const string_t& s, const bool ensure_ascii)
18399  {
18400  std::uint32_t codepoint{};
18401  std::uint8_t state = UTF8_ACCEPT;
18402  std::size_t bytes = 0; // number of bytes written to string_buffer
18403 
18404  // number of bytes written at the point of the last valid byte
18405  std::size_t bytes_after_last_accept = 0;
18406  std::size_t undumped_chars = 0;
18407 
18408  for (std::size_t i = 0; i < s.size(); ++i)
18409  {
18410  const auto byte = static_cast<std::uint8_t>(s[i]);
18411 
18412  switch (decode(state, codepoint, byte))
18413  {
18414  case UTF8_ACCEPT: // decode found a new code point
18415  {
18416  switch (codepoint)
18417  {
18418  case 0x08: // backspace
18419  {
18420  string_buffer[bytes++] = '\\';
18421  string_buffer[bytes++] = 'b';
18422  break;
18423  }
18424 
18425  case 0x09: // horizontal tab
18426  {
18427  string_buffer[bytes++] = '\\';
18428  string_buffer[bytes++] = 't';
18429  break;
18430  }
18431 
18432  case 0x0A: // newline
18433  {
18434  string_buffer[bytes++] = '\\';
18435  string_buffer[bytes++] = 'n';
18436  break;
18437  }
18438 
18439  case 0x0C: // formfeed
18440  {
18441  string_buffer[bytes++] = '\\';
18442  string_buffer[bytes++] = 'f';
18443  break;
18444  }
18445 
18446  case 0x0D: // carriage return
18447  {
18448  string_buffer[bytes++] = '\\';
18449  string_buffer[bytes++] = 'r';
18450  break;
18451  }
18452 
18453  case 0x22: // quotation mark
18454  {
18455  string_buffer[bytes++] = '\\';
18456  string_buffer[bytes++] = '\"';
18457  break;
18458  }
18459 
18460  case 0x5C: // reverse solidus
18461  {
18462  string_buffer[bytes++] = '\\';
18463  string_buffer[bytes++] = '\\';
18464  break;
18465  }
18466 
18467  default:
18468  {
18469  // escape control characters (0x00..0x1F) or, if
18470  // ensure_ascii parameter is used, non-ASCII characters
18471  if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
18472  {
18473  if (codepoint <= 0xFFFF)
18474  {
18475  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
18476  static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
18477  static_cast<std::uint16_t>(codepoint)));
18478  bytes += 6;
18479  }
18480  else
18481  {
18482  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
18483  static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
18484  static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
18485  static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
18486  bytes += 12;
18487  }
18488  }
18489  else
18490  {
18491  // copy byte to buffer (all previous bytes
18492  // been copied have in default case above)
18493  string_buffer[bytes++] = s[i];
18494  }
18495  break;
18496  }
18497  }
18498 
18499  // write buffer and reset index; there must be 13 bytes
18500  // left, as this is the maximal number of bytes to be
18501  // written ("\uxxxx\uxxxx\0") for one code point
18502  if (string_buffer.size() - bytes < 13)
18503  {
18504  o->write_characters(string_buffer.data(), bytes);
18505  bytes = 0;
18506  }
18507 
18508  // remember the byte position of this accept
18509  bytes_after_last_accept = bytes;
18510  undumped_chars = 0;
18511  break;
18512  }
18513 
18514  case UTF8_REJECT: // decode found invalid UTF-8 byte
18515  {
18516  switch (error_handler)
18517  {
18518  case error_handler_t::strict:
18519  {
18520  JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
18521  }
18522 
18523  case error_handler_t::ignore:
18524  case error_handler_t::replace:
18525  {
18526  // in case we saw this character the first time, we
18527  // would like to read it again, because the byte
18528  // may be OK for itself, but just not OK for the
18529  // previous sequence
18530  if (undumped_chars > 0)
18531  {
18532  --i;
18533  }
18534 
18535  // reset length buffer to the last accepted index;
18536  // thus removing/ignoring the invalid characters
18537  bytes = bytes_after_last_accept;
18538 
18539  if (error_handler == error_handler_t::replace)
18540  {
18541  // add a replacement character
18542  if (ensure_ascii)
18543  {
18544  string_buffer[bytes++] = '\\';
18545  string_buffer[bytes++] = 'u';
18546  string_buffer[bytes++] = 'f';
18547  string_buffer[bytes++] = 'f';
18548  string_buffer[bytes++] = 'f';
18549  string_buffer[bytes++] = 'd';
18550  }
18551  else
18552  {
18553  string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
18554  string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
18555  string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
18556  }
18557 
18558  // write buffer and reset index; there must be 13 bytes
18559  // left, as this is the maximal number of bytes to be
18560  // written ("\uxxxx\uxxxx\0") for one code point
18561  if (string_buffer.size() - bytes < 13)
18562  {
18563  o->write_characters(string_buffer.data(), bytes);
18564  bytes = 0;
18565  }
18566 
18567  bytes_after_last_accept = bytes;
18568  }
18569 
18570  undumped_chars = 0;
18571 
18572  // continue processing the string
18573  state = UTF8_ACCEPT;
18574  break;
18575  }
18576 
18577  default: // LCOV_EXCL_LINE
18578  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
18579  }
18580  break;
18581  }
18582 
18583  default: // decode found yet incomplete multi-byte code point
18584  {
18585  if (!ensure_ascii)
18586  {
18587  // code point will not be escaped - copy byte to buffer
18588  string_buffer[bytes++] = s[i];
18589  }
18590  ++undumped_chars;
18591  break;
18592  }
18593  }
18594  }
18595 
18596  // we finished processing the string
18597  if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
18598  {
18599  // write buffer
18600  if (bytes > 0)
18601  {
18602  o->write_characters(string_buffer.data(), bytes);
18603  }
18604  }
18605  else
18606  {
18607  // we finish reading, but do not accept: string was incomplete
18608  switch (error_handler)
18609  {
18610  case error_handler_t::strict:
18611  {
18612  JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
18613  }
18614 
18615  case error_handler_t::ignore:
18616  {
18617  // write all accepted bytes
18618  o->write_characters(string_buffer.data(), bytes_after_last_accept);
18619  break;
18620  }
18621 
18622  case error_handler_t::replace:
18623  {
18624  // write all accepted bytes
18625  o->write_characters(string_buffer.data(), bytes_after_last_accept);
18626  // add a replacement character
18627  if (ensure_ascii)
18628  {
18629  o->write_characters("\\ufffd", 6);
18630  }
18631  else
18632  {
18633  o->write_characters("\xEF\xBF\xBD", 3);
18634  }
18635  break;
18636  }
18637 
18638  default: // LCOV_EXCL_LINE
18639  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
18640  }
18641  }
18642  }
18643 
18644  private:
18653  inline unsigned int count_digits(number_unsigned_t x) noexcept
18654  {
18655  unsigned int n_digits = 1;
18656  for (;;)
18657  {
18658  if (x < 10)
18659  {
18660  return n_digits;
18661  }
18662  if (x < 100)
18663  {
18664  return n_digits + 1;
18665  }
18666  if (x < 1000)
18667  {
18668  return n_digits + 2;
18669  }
18670  if (x < 10000)
18671  {
18672  return n_digits + 3;
18673  }
18674  x = x / 10000u;
18675  n_digits += 4;
18676  }
18677  }
18678 
18684  static std::string hex_bytes(std::uint8_t byte)
18685  {
18686  std::string result = "FF";
18687  constexpr const char* nibble_to_hex = "0123456789ABCDEF";
18688  result[0] = nibble_to_hex[byte / 16];
18689  result[1] = nibble_to_hex[byte % 16];
18690  return result;
18691  }
18692 
18693  // templates to avoid warnings about useless casts
18694  template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
18695  bool is_negative_number(NumberType x)
18696  {
18697  return x < 0;
18698  }
18699 
18700  template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
18701  bool is_negative_number(NumberType /*unused*/)
18702  {
18703  return false;
18704  }
18705 
18715  template < typename NumberType, detail::enable_if_t <
18716  std::is_integral<NumberType>::value ||
18717  std::is_same<NumberType, number_unsigned_t>::value ||
18718  std::is_same<NumberType, number_integer_t>::value ||
18719  std::is_same<NumberType, binary_char_t>::value,
18720  int > = 0 >
18721  void dump_integer(NumberType x)
18722  {
18723  static constexpr std::array<std::array<char, 2>, 100> digits_to_99
18724  {
18725  {
18726  {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
18727  {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
18728  {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
18729  {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
18730  {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
18731  {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
18732  {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
18733  {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
18734  {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
18735  {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
18736  }
18737  };
18738 
18739  // special case for "0"
18740  if (x == 0)
18741  {
18742  o->write_character('0');
18743  return;
18744  }
18745 
18746  // use a pointer to fill the buffer
18747  auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
18748 
18749  number_unsigned_t abs_value;
18750 
18751  unsigned int n_chars{};
18752 
18753  if (is_negative_number(x))
18754  {
18755  *buffer_ptr = '-';
18756  abs_value = remove_sign(static_cast<number_integer_t>(x));
18757 
18758  // account one more byte for the minus sign
18759  n_chars = 1 + count_digits(abs_value);
18760  }
18761  else
18762  {
18763  abs_value = static_cast<number_unsigned_t>(x);
18764  n_chars = count_digits(abs_value);
18765  }
18766 
18767  // spare 1 byte for '\0'
18768  JSON_ASSERT(n_chars < number_buffer.size() - 1);
18769 
18770  // jump to the end to generate the string from backward,
18771  // so we later avoid reversing the result
18772  buffer_ptr += n_chars;
18773 
18774  // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
18775  // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
18776  while (abs_value >= 100)
18777  {
18778  const auto digits_index = static_cast<unsigned>((abs_value % 100));
18779  abs_value /= 100;
18780  *(--buffer_ptr) = digits_to_99[digits_index][1];
18781  *(--buffer_ptr) = digits_to_99[digits_index][0];
18782  }
18783 
18784  if (abs_value >= 10)
18785  {
18786  const auto digits_index = static_cast<unsigned>(abs_value);
18787  *(--buffer_ptr) = digits_to_99[digits_index][1];
18788  *(--buffer_ptr) = digits_to_99[digits_index][0];
18789  }
18790  else
18791  {
18792  *(--buffer_ptr) = static_cast<char>('0' + abs_value);
18793  }
18794 
18795  o->write_characters(number_buffer.data(), n_chars);
18796  }
18797 
18806  void dump_float(number_float_t x)
18807  {
18808  // NaN / inf
18809  if (!std::isfinite(x))
18810  {
18811  o->write_characters("null", 4);
18812  return;
18813  }
18814 
18815  // If number_float_t is an IEEE-754 single or double precision number,
18816  // use the Grisu2 algorithm to produce short numbers which are
18817  // guaranteed to round-trip, using strtof and strtod, resp.
18818  //
18819  // NB: The test below works if <long double> == <double>.
18820  static constexpr bool is_ieee_single_or_double
18821  = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
18822  (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
18823 
18824  dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
18825  }
18826 
18827  void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
18828  {
18829  auto* begin = number_buffer.data();
18830  auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
18831 
18832  o->write_characters(begin, static_cast<size_t>(end - begin));
18833  }
18834 
18835  void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
18836  {
18837  // get number of digits for a float -> text -> float round-trip
18838  static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
18839 
18840  // the actual conversion
18841  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
18842  std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
18843 
18844  // negative value indicates an error
18845  JSON_ASSERT(len > 0);
18846  // check if buffer was large enough
18847  JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
18848 
18849  // erase thousands separator
18850  if (thousands_sep != '\0')
18851  {
18852  // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
18853  const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
18854  std::fill(end, number_buffer.end(), '\0');
18855  JSON_ASSERT((end - number_buffer.begin()) <= len);
18856  len = (end - number_buffer.begin());
18857  }
18858 
18859  // convert decimal point to '.'
18860  if (decimal_point != '\0' && decimal_point != '.')
18861  {
18862  // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
18863  const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
18864  if (dec_pos != number_buffer.end())
18865  {
18866  *dec_pos = '.';
18867  }
18868  }
18869 
18870  o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
18871 
18872  // determine if we need to append ".0"
18873  const bool value_is_int_like =
18874  std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
18875  [](char c)
18876  {
18877  return c == '.' || c == 'e';
18878  });
18879 
18880  if (value_is_int_like)
18881  {
18882  o->write_characters(".0", 2);
18883  }
18884  }
18885 
18907  static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
18908  {
18909  static const std::array<std::uint8_t, 400> utf8d =
18910  {
18911  {
18912  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
18913  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
18914  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
18915  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
18916  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
18917  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
18918  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
18919  0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
18920  0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
18921  0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
18922  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
18923  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
18924  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
18925  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
18926  }
18927  };
18928 
18929  JSON_ASSERT(byte < utf8d.size());
18930  const std::uint8_t type = utf8d[byte];
18931 
18932  codep = (state != UTF8_ACCEPT)
18933  ? (byte & 0x3fu) | (codep << 6u)
18934  : (0xFFu >> type) & (byte);
18935 
18936  const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
18937  JSON_ASSERT(index < utf8d.size());
18938  state = utf8d[index];
18939  return state;
18940  }
18941 
18942  /*
18943  * Overload to make the compiler happy while it is instantiating
18944  * dump_integer for number_unsigned_t.
18945  * Must never be called.
18946  */
18947  number_unsigned_t remove_sign(number_unsigned_t x)
18948  {
18949  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
18950  return x; // LCOV_EXCL_LINE
18951  }
18952 
18953  /*
18954  * Helper function for dump_integer
18955  *
18956  * This function takes a negative signed integer and returns its absolute
18957  * value as unsigned integer. The plus/minus shuffling is necessary as we can
18958  * not directly remove the sign of an arbitrary signed integer as the
18959  * absolute values of INT_MIN and INT_MAX are usually not the same. See
18960  * #1708 for details.
18961  */
18962  inline number_unsigned_t remove_sign(number_integer_t x) noexcept
18963  {
18964  JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
18965  return static_cast<number_unsigned_t>(-(x + 1)) + 1;
18966  }
18967 
18968  private:
18970  output_adapter_t<char> o = nullptr;
18971 
18973  std::array<char, 64> number_buffer{ {} };
18974 
18976  const std::lconv* loc = nullptr;
18978  const char thousands_sep = '\0';
18980  const char decimal_point = '\0';
18981 
18983  std::array<char, 512> string_buffer{ {} };
18984 
18986  const char indent_char;
18988  string_t indent_string;
18989 
18991  const error_handler_t error_handler;
18992  };
18993 
18994 } // namespace detail
18995 NLOHMANN_JSON_NAMESPACE_END
18996 
18997 // #include <nlohmann/detail/value_t.hpp>
18998 
18999 // #include <nlohmann/json_fwd.hpp>
19000 
19001 // #include <nlohmann/ordered_map.hpp>
19002 // __ _____ _____ _____
19003 // __| | __| | | | JSON for Modern C++
19004 // | | |__ | | | | | | version 3.11.3
19005 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
19006 //
19007 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
19008 // SPDX-License-Identifier: MIT
19009 
19010 
19011 
19012 #include <functional> // equal_to, less
19013 #include <initializer_list> // initializer_list
19014 #include <iterator> // input_iterator_tag, iterator_traits
19015 #include <memory> // allocator
19016 #include <stdexcept> // for out_of_range
19017 #include <type_traits> // enable_if, is_convertible
19018 #include <utility> // pair
19019 #include <vector> // vector
19020 
19021 // #include <nlohmann/detail/macro_scope.hpp>
19022 
19023 // #include <nlohmann/detail/meta/type_traits.hpp>
19024 
19025 
19026 NLOHMANN_JSON_NAMESPACE_BEGIN
19027 
19030 template <class Key, class T, class IgnoredLess = std::less<Key>,
19031  class Allocator = std::allocator<std::pair<const Key, T>>>
19032 struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
19033 {
19034  using key_type = Key;
19035  using mapped_type = T;
19036  using Container = std::vector<std::pair<const Key, T>, Allocator>;
19037  using iterator = typename Container::iterator;
19038  using const_iterator = typename Container::const_iterator;
19039  using size_type = typename Container::size_type;
19040  using value_type = typename Container::value_type;
19041 #ifdef JSON_HAS_CPP_14
19042  using key_compare = std::equal_to<>;
19043 #else
19044  using key_compare = std::equal_to<Key>;
19045 #endif
19046 
19047  // Explicit constructors instead of `using Container::Container`
19048  // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
19049  ordered_map() noexcept(noexcept(Container())) : Container{} {}
19050  explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{ alloc } {}
19051  template <class It>
19052  ordered_map(It first, It last, const Allocator& alloc = Allocator())
19053  : Container{ first, last, alloc } {}
19054  ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator())
19055  : Container{ init, alloc } {}
19056 
19057  std::pair<iterator, bool> emplace(const key_type& key, T&& t)
19058  {
19059  for (auto it = this->begin(); it != this->end(); ++it)
19060  {
19061  if (m_compare(it->first, key))
19062  {
19063  return { it, false };
19064  }
19065  }
19066  Container::emplace_back(key, std::forward<T>(t));
19067  return { std::prev(this->end()), true };
19068  }
19069 
19070  template<class KeyType, detail::enable_if_t<
19071  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19072  std::pair<iterator, bool> emplace(KeyType&& key, T&& t)
19073  {
19074  for (auto it = this->begin(); it != this->end(); ++it)
19075  {
19076  if (m_compare(it->first, key))
19077  {
19078  return { it, false };
19079  }
19080  }
19081  Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
19082  return { std::prev(this->end()), true };
19083  }
19084 
19085  T& operator[](const key_type& key)
19086  {
19087  return emplace(key, T{}).first->second;
19088  }
19089 
19090  template<class KeyType, detail::enable_if_t<
19091  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19092  T& operator[](KeyType&& key)
19093  {
19094  return emplace(std::forward<KeyType>(key), T{}).first->second;
19095  }
19096 
19097  const T& operator[](const key_type& key) const
19098  {
19099  return at(key);
19100  }
19101 
19102  template<class KeyType, detail::enable_if_t<
19103  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19104  const T& operator[](KeyType&& key) const
19105  {
19106  return at(std::forward<KeyType>(key));
19107  }
19108 
19109  T& at(const key_type& key)
19110  {
19111  for (auto it = this->begin(); it != this->end(); ++it)
19112  {
19113  if (m_compare(it->first, key))
19114  {
19115  return it->second;
19116  }
19117  }
19118 
19119  JSON_THROW(std::out_of_range("key not found"));
19120  }
19121 
19122  template<class KeyType, detail::enable_if_t<
19123  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19124  T& at(KeyType&& key) // NOLINT(cppcoreguidelines-missing-std-forward)
19125  {
19126  for (auto it = this->begin(); it != this->end(); ++it)
19127  {
19128  if (m_compare(it->first, key))
19129  {
19130  return it->second;
19131  }
19132  }
19133 
19134  JSON_THROW(std::out_of_range("key not found"));
19135  }
19136 
19137  const T& at(const key_type& key) const
19138  {
19139  for (auto it = this->begin(); it != this->end(); ++it)
19140  {
19141  if (m_compare(it->first, key))
19142  {
19143  return it->second;
19144  }
19145  }
19146 
19147  JSON_THROW(std::out_of_range("key not found"));
19148  }
19149 
19150  template<class KeyType, detail::enable_if_t<
19151  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19152  const T& at(KeyType&& key) const // NOLINT(cppcoreguidelines-missing-std-forward)
19153  {
19154  for (auto it = this->begin(); it != this->end(); ++it)
19155  {
19156  if (m_compare(it->first, key))
19157  {
19158  return it->second;
19159  }
19160  }
19161 
19162  JSON_THROW(std::out_of_range("key not found"));
19163  }
19164 
19165  size_type erase(const key_type& key)
19166  {
19167  for (auto it = this->begin(); it != this->end(); ++it)
19168  {
19169  if (m_compare(it->first, key))
19170  {
19171  // Since we cannot move const Keys, re-construct them in place
19172  for (auto next = it; ++next != this->end(); ++it)
19173  {
19174  it->~value_type(); // Destroy but keep allocation
19175  new (&*it) value_type{ std::move(*next) };
19176  }
19177  Container::pop_back();
19178  return 1;
19179  }
19180  }
19181  return 0;
19182  }
19183 
19184  template<class KeyType, detail::enable_if_t<
19185  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19186  size_type erase(KeyType&& key) // NOLINT(cppcoreguidelines-missing-std-forward)
19187  {
19188  for (auto it = this->begin(); it != this->end(); ++it)
19189  {
19190  if (m_compare(it->first, key))
19191  {
19192  // Since we cannot move const Keys, re-construct them in place
19193  for (auto next = it; ++next != this->end(); ++it)
19194  {
19195  it->~value_type(); // Destroy but keep allocation
19196  new (&*it) value_type{ std::move(*next) };
19197  }
19198  Container::pop_back();
19199  return 1;
19200  }
19201  }
19202  return 0;
19203  }
19204 
19205  iterator erase(iterator pos)
19206  {
19207  return erase(pos, std::next(pos));
19208  }
19209 
19210  iterator erase(iterator first, iterator last)
19211  {
19212  if (first == last)
19213  {
19214  return first;
19215  }
19216 
19217  const auto elements_affected = std::distance(first, last);
19218  const auto offset = std::distance(Container::begin(), first);
19219 
19220  // This is the start situation. We need to delete elements_affected
19221  // elements (3 in this example: e, f, g), and need to return an
19222  // iterator past the last deleted element (h in this example).
19223  // Note that offset is the distance from the start of the vector
19224  // to first. We will need this later.
19225 
19226  // [ a, b, c, d, e, f, g, h, i, j ]
19227  // ^ ^
19228  // first last
19229 
19230  // Since we cannot move const Keys, we re-construct them in place.
19231  // We start at first and re-construct (viz. copy) the elements from
19232  // the back of the vector. Example for first iteration:
19233 
19234  // ,--------.
19235  // v | destroy e and re-construct with h
19236  // [ a, b, c, d, e, f, g, h, i, j ]
19237  // ^ ^
19238  // it it + elements_affected
19239 
19240  for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
19241  {
19242  it->~value_type(); // destroy but keep allocation
19243  new (&*it) value_type{ std::move(*std::next(it, elements_affected)) }; // "move" next element to it
19244  }
19245 
19246  // [ a, b, c, d, h, i, j, h, i, j ]
19247  // ^ ^
19248  // first last
19249 
19250  // remove the unneeded elements at the end of the vector
19251  Container::resize(this->size() - static_cast<size_type>(elements_affected));
19252 
19253  // [ a, b, c, d, h, i, j ]
19254  // ^ ^
19255  // first last
19256 
19257  // first is now pointing past the last deleted element, but we cannot
19258  // use this iterator, because it may have been invalidated by the
19259  // resize call. Instead, we can return begin() + offset.
19260  return Container::begin() + offset;
19261  }
19262 
19263  size_type count(const key_type& key) const
19264  {
19265  for (auto it = this->begin(); it != this->end(); ++it)
19266  {
19267  if (m_compare(it->first, key))
19268  {
19269  return 1;
19270  }
19271  }
19272  return 0;
19273  }
19274 
19275  template<class KeyType, detail::enable_if_t<
19276  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19277  size_type count(KeyType&& key) const // NOLINT(cppcoreguidelines-missing-std-forward)
19278  {
19279  for (auto it = this->begin(); it != this->end(); ++it)
19280  {
19281  if (m_compare(it->first, key))
19282  {
19283  return 1;
19284  }
19285  }
19286  return 0;
19287  }
19288 
19289  iterator find(const key_type& key)
19290  {
19291  for (auto it = this->begin(); it != this->end(); ++it)
19292  {
19293  if (m_compare(it->first, key))
19294  {
19295  return it;
19296  }
19297  }
19298  return Container::end();
19299  }
19300 
19301  template<class KeyType, detail::enable_if_t<
19302  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19303  iterator find(KeyType&& key) // NOLINT(cppcoreguidelines-missing-std-forward)
19304  {
19305  for (auto it = this->begin(); it != this->end(); ++it)
19306  {
19307  if (m_compare(it->first, key))
19308  {
19309  return it;
19310  }
19311  }
19312  return Container::end();
19313  }
19314 
19315  const_iterator find(const key_type& key) const
19316  {
19317  for (auto it = this->begin(); it != this->end(); ++it)
19318  {
19319  if (m_compare(it->first, key))
19320  {
19321  return it;
19322  }
19323  }
19324  return Container::end();
19325  }
19326 
19327  std::pair<iterator, bool> insert(value_type&& value)
19328  {
19329  return emplace(value.first, std::move(value.second));
19330  }
19331 
19332  std::pair<iterator, bool> insert(const value_type& value)
19333  {
19334  for (auto it = this->begin(); it != this->end(); ++it)
19335  {
19336  if (m_compare(it->first, value.first))
19337  {
19338  return { it, false };
19339  }
19340  }
19341  Container::push_back(value);
19342  return { --this->end(), true };
19343  }
19344 
19345  template<typename InputIt>
19346  using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
19347  std::input_iterator_tag>::value>::type;
19348 
19349  template<typename InputIt, typename = require_input_iter<InputIt>>
19350  void insert(InputIt first, InputIt last)
19351  {
19352  for (auto it = first; it != last; ++it)
19353  {
19354  insert(*it);
19355  }
19356  }
19357 
19358 private:
19359  JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
19360 };
19361 
19362 NLOHMANN_JSON_NAMESPACE_END
19363 
19364 
19365 #if defined(JSON_HAS_CPP_17)
19366 #if JSON_HAS_STATIC_RTTI
19367 #include <any>
19368 #endif
19369 #include <string_view>
19370 #endif
19371 
19377 NLOHMANN_JSON_NAMESPACE_BEGIN
19378 
19397 NLOHMANN_BASIC_JSON_TPL_DECLARATION
19398 class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
19399  : public ::nlohmann::detail::json_base_class<CustomBaseClass>
19400 {
19401 private:
19402  template<detail::value_t> friend struct detail::external_constructor;
19403 
19404  template<typename>
19405  friend class ::nlohmann::json_pointer;
19406  // can be restored when json_pointer backwards compatibility is removed
19407  // friend ::nlohmann::json_pointer<StringType>;
19408 
19409  template<typename BasicJsonType, typename InputType>
19410  friend class ::nlohmann::detail::parser;
19411  friend ::nlohmann::detail::serializer<basic_json>;
19412  template<typename BasicJsonType>
19413  friend class ::nlohmann::detail::iter_impl;
19414  template<typename BasicJsonType, typename CharType>
19415  friend class ::nlohmann::detail::binary_writer;
19416  template<typename BasicJsonType, typename InputType, typename SAX>
19417  friend class ::nlohmann::detail::binary_reader;
19418  template<typename BasicJsonType>
19419  friend class ::nlohmann::detail::json_sax_dom_parser;
19420  template<typename BasicJsonType>
19421  friend class ::nlohmann::detail::json_sax_dom_callback_parser;
19422  friend class ::nlohmann::detail::exception;
19423 
19425  using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
19426  using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
19427 
19428 JSON_PRIVATE_UNLESS_TESTED:
19429  // convenience aliases for types residing in namespace detail;
19430  using lexer = ::nlohmann::detail::lexer_base<basic_json>;
19431 
19432  template<typename InputAdapterType>
19433  static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
19434  InputAdapterType adapter,
19435  detail::parser_callback_t<basic_json>cb = nullptr,
19436  const bool allow_exceptions = true,
19437  const bool ignore_comments = false
19438  )
19439  {
19440  return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
19441  std::move(cb), allow_exceptions, ignore_comments);
19442  }
19443 
19444 private:
19445  using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
19446  template<typename BasicJsonType>
19447  using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
19448  template<typename BasicJsonType>
19449  using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
19450  template<typename Iterator>
19451  using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
19452  template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
19453 
19454  template<typename CharType>
19455  using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
19456 
19457  template<typename InputType>
19458  using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
19459  template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
19460 
19461 JSON_PRIVATE_UNLESS_TESTED:
19462  using serializer = ::nlohmann::detail::serializer<basic_json>;
19463 
19464 public:
19465  using value_t = detail::value_t;
19467  using json_pointer = ::nlohmann::json_pointer<StringType>;
19468  template<typename T, typename SFINAE>
19469  using json_serializer = JSONSerializer<T, SFINAE>;
19471  using error_handler_t = detail::error_handler_t;
19473  using cbor_tag_handler_t = detail::cbor_tag_handler_t;
19475  using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
19476 
19477  using input_format_t = detail::input_format_t;
19479  using json_sax_t = json_sax<basic_json>;
19480 
19482  // exceptions //
19484 
19488 
19489  using exception = detail::exception;
19490  using parse_error = detail::parse_error;
19491  using invalid_iterator = detail::invalid_iterator;
19492  using type_error = detail::type_error;
19493  using out_of_range = detail::out_of_range;
19494  using other_error = detail::other_error;
19495 
19497 
19499  // container types //
19501 
19506 
19508  using value_type = basic_json;
19509 
19511  using reference = value_type&;
19513  using const_reference = const value_type&;
19514 
19516  using difference_type = std::ptrdiff_t;
19518  using size_type = std::size_t;
19519 
19521  using allocator_type = AllocatorType<basic_json>;
19522 
19524  using pointer = typename std::allocator_traits<allocator_type>::pointer;
19526  using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
19527 
19529  using iterator = iter_impl<basic_json>;
19531  using const_iterator = iter_impl<const basic_json>;
19533  using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
19535  using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
19536 
19538 
19541  static allocator_type get_allocator()
19542  {
19543  return allocator_type();
19544  }
19545 
19548  JSON_HEDLEY_WARN_UNUSED_RESULT
19549  static basic_json meta()
19550  {
19551  basic_json result;
19552 
19553  result["copyright"] = "(C) 2013-2023 Niels Lohmann";
19554  result["name"] = "JSON for Modern C++";
19555  result["url"] = "https://github.com/nlohmann/json";
19556  result["version"]["string"] =
19557  detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
19558  std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
19559  std::to_string(NLOHMANN_JSON_VERSION_PATCH));
19560  result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
19561  result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
19562  result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
19563 
19564 #ifdef _WIN32
19565  result["platform"] = "win32";
19566 #elif defined __linux__
19567  result["platform"] = "linux";
19568 #elif defined __APPLE__
19569  result["platform"] = "apple";
19570 #elif defined __unix__
19571  result["platform"] = "unix";
19572 #else
19573  result["platform"] = "unknown";
19574 #endif
19575 
19576 #if defined(__ICC) || defined(__INTEL_COMPILER)
19577  result["compiler"] = { {"family", "icc"}, {"version", __INTEL_COMPILER} };
19578 #elif defined(__clang__)
19579  result["compiler"] = { {"family", "clang"}, {"version", __clang_version__} };
19580 #elif defined(__GNUC__) || defined(__GNUG__)
19581  result["compiler"] = { {"family", "gcc"}, {"version", detail::concat(
19582  std::to_string(__GNUC__), '.',
19583  std::to_string(__GNUC_MINOR__), '.',
19584  std::to_string(__GNUC_PATCHLEVEL__))
19585  }
19586  };
19587 #elif defined(__HP_cc) || defined(__HP_aCC)
19588  result["compiler"] = "hp"
19589 #elif defined(__IBMCPP__)
19590  result["compiler"] = { {"family", "ilecpp"}, {"version", __IBMCPP__} };
19591 #elif defined(_MSC_VER)
19592  result["compiler"] = { {"family", "msvc"}, {"version", _MSC_VER} };
19593 #elif defined(__PGI)
19594  result["compiler"] = { {"family", "pgcpp"}, {"version", __PGI} };
19595 #elif defined(__SUNPRO_CC)
19596  result["compiler"] = { {"family", "sunpro"}, {"version", __SUNPRO_CC} };
19597 #else
19598  result["compiler"] = { {"family", "unknown"}, {"version", "unknown"} };
19599 #endif
19600 
19601 #if defined(_MSVC_LANG)
19602  result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
19603 #elif defined(__cplusplus)
19604  result["compiler"]["c++"] = std::to_string(__cplusplus);
19605 #else
19606  result["compiler"]["c++"] = "unknown";
19607 #endif
19608  return result;
19609  }
19610 
19612  // JSON value data types //
19614 
19619 
19624 #if defined(JSON_HAS_CPP_14)
19625  // use of transparent comparator avoids unnecessary repeated construction of temporaries
19626  // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
19627  using default_object_comparator_t = std::less<>;
19628 #else
19629  using default_object_comparator_t = std::less<StringType>;
19630 #endif
19631 
19634  using object_t = ObjectType<StringType,
19635  basic_json,
19636  default_object_comparator_t,
19637  AllocatorType<std::pair<const StringType,
19638  basic_json>>>;
19639 
19642  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
19643 
19646  using string_t = StringType;
19647 
19650  using boolean_t = BooleanType;
19651 
19654  using number_integer_t = NumberIntegerType;
19655 
19658  using number_unsigned_t = NumberUnsignedType;
19659 
19662  using number_float_t = NumberFloatType;
19663 
19666  using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
19667 
19670  using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
19671 
19673 
19674 private:
19675 
19677  template<typename T, typename... Args>
19678  JSON_HEDLEY_RETURNS_NON_NULL
19679  static T* create(Args&& ... args)
19680  {
19681  AllocatorType<T> alloc;
19682  using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
19683 
19684  auto deleter = [&](T* obj)
19685  {
19686  AllocatorTraits::deallocate(alloc, obj, 1);
19687  };
19688  std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
19689  AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
19690  JSON_ASSERT(obj != nullptr);
19691  return obj.release();
19692  }
19693 
19695  // JSON value storage //
19697 
19698 JSON_PRIVATE_UNLESS_TESTED:
19724  union json_value
19725  {
19727  object_t* object;
19729  array_t* array;
19731  string_t* string;
19733  binary_t* binary;
19735  boolean_t boolean;
19737  number_integer_t number_integer;
19739  number_unsigned_t number_unsigned;
19741  number_float_t number_float;
19742 
19744  json_value() = default;
19746  json_value(boolean_t v) noexcept : boolean(v) {}
19748  json_value(number_integer_t v) noexcept : number_integer(v) {}
19750  json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
19752  json_value(number_float_t v) noexcept : number_float(v) {}
19754  json_value(value_t t)
19755  {
19756  switch (t)
19757  {
19758  case value_t::object:
19759  {
19760  object = create<object_t>();
19761  break;
19762  }
19763 
19764  case value_t::array:
19765  {
19766  array = create<array_t>();
19767  break;
19768  }
19769 
19770  case value_t::string:
19771  {
19772  string = create<string_t>("");
19773  break;
19774  }
19775 
19776  case value_t::binary:
19777  {
19778  binary = create<binary_t>();
19779  break;
19780  }
19781 
19782  case value_t::boolean:
19783  {
19784  boolean = static_cast<boolean_t>(false);
19785  break;
19786  }
19787 
19788  case value_t::number_integer:
19789  {
19790  number_integer = static_cast<number_integer_t>(0);
19791  break;
19792  }
19793 
19794  case value_t::number_unsigned:
19795  {
19796  number_unsigned = static_cast<number_unsigned_t>(0);
19797  break;
19798  }
19799 
19800  case value_t::number_float:
19801  {
19802  number_float = static_cast<number_float_t>(0.0);
19803  break;
19804  }
19805 
19806  case value_t::null:
19807  {
19808  object = nullptr; // silence warning, see #821
19809  break;
19810  }
19811 
19812  case value_t::discarded:
19813  default:
19814  {
19815  object = nullptr; // silence warning, see #821
19816  if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
19817  {
19818  JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
19819  }
19820  break;
19821  }
19822  }
19823  }
19824 
19826  json_value(const string_t& value) : string(create<string_t>(value)) {}
19827 
19829  json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
19830 
19832  json_value(const object_t& value) : object(create<object_t>(value)) {}
19833 
19835  json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
19836 
19838  json_value(const array_t& value) : array(create<array_t>(value)) {}
19839 
19841  json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
19842 
19844  json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
19845 
19847  json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
19848 
19850  json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
19851 
19853  json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
19854 
19855  void destroy(value_t t)
19856  {
19857  if (
19858  (t == value_t::object && object == nullptr) ||
19859  (t == value_t::array && array == nullptr) ||
19860  (t == value_t::string && string == nullptr) ||
19861  (t == value_t::binary && binary == nullptr)
19862  )
19863  {
19864  //not initialized (e.g. due to exception in the ctor)
19865  return;
19866  }
19867  if (t == value_t::array || t == value_t::object)
19868  {
19869  // flatten the current json_value to a heap-allocated stack
19870  std::vector<basic_json> stack;
19871 
19872  // move the top-level items to stack
19873  if (t == value_t::array)
19874  {
19875  stack.reserve(array->size());
19876  std::move(array->begin(), array->end(), std::back_inserter(stack));
19877  }
19878  else
19879  {
19880  stack.reserve(object->size());
19881  for (auto&& it : *object)
19882  {
19883  stack.push_back(std::move(it.second));
19884  }
19885  }
19886 
19887  while (!stack.empty())
19888  {
19889  // move the last item to local variable to be processed
19890  basic_json current_item(std::move(stack.back()));
19891  stack.pop_back();
19892 
19893  // if current_item is array/object, move
19894  // its children to the stack to be processed later
19895  if (current_item.is_array())
19896  {
19897  std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
19898 
19899  current_item.m_data.m_value.array->clear();
19900  }
19901  else if (current_item.is_object())
19902  {
19903  for (auto&& it : *current_item.m_data.m_value.object)
19904  {
19905  stack.push_back(std::move(it.second));
19906  }
19907 
19908  current_item.m_data.m_value.object->clear();
19909  }
19910 
19911  // it's now safe that current_item get destructed
19912  // since it doesn't have any children
19913  }
19914  }
19915 
19916  switch (t)
19917  {
19918  case value_t::object:
19919  {
19920  AllocatorType<object_t> alloc;
19921  std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
19922  std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
19923  break;
19924  }
19925 
19926  case value_t::array:
19927  {
19928  AllocatorType<array_t> alloc;
19929  std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
19930  std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
19931  break;
19932  }
19933 
19934  case value_t::string:
19935  {
19936  AllocatorType<string_t> alloc;
19937  std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
19938  std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
19939  break;
19940  }
19941 
19942  case value_t::binary:
19943  {
19944  AllocatorType<binary_t> alloc;
19945  std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
19946  std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
19947  break;
19948  }
19949 
19950  case value_t::null:
19951  case value_t::boolean:
19952  case value_t::number_integer:
19953  case value_t::number_unsigned:
19954  case value_t::number_float:
19955  case value_t::discarded:
19956  default:
19957  {
19958  break;
19959  }
19960  }
19961  }
19962  };
19963 
19964 private:
19983  void assert_invariant(bool check_parents = true) const noexcept
19984  {
19985  JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
19986  JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
19987  JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
19988  JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
19989 
19990 #if JSON_DIAGNOSTICS
19991  JSON_TRY
19992  {
19993  // cppcheck-suppress assertWithSideEffect
19994  JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json& j)
19995  {
19996  return j.m_parent == this;
19997  }));
19998  }
19999  JSON_CATCH(...) {} // LCOV_EXCL_LINE
20000 #endif
20001  static_cast<void>(check_parents);
20002  }
20003 
20004  void set_parents()
20005  {
20006 #if JSON_DIAGNOSTICS
20007  switch (m_data.m_type)
20008  {
20009  case value_t::array:
20010  {
20011  for (auto& element : *m_data.m_value.array)
20012  {
20013  element.m_parent = this;
20014  }
20015  break;
20016  }
20017 
20018  case value_t::object:
20019  {
20020  for (auto& element : *m_data.m_value.object)
20021  {
20022  element.second.m_parent = this;
20023  }
20024  break;
20025  }
20026 
20027  case value_t::null:
20028  case value_t::string:
20029  case value_t::boolean:
20030  case value_t::number_integer:
20031  case value_t::number_unsigned:
20032  case value_t::number_float:
20033  case value_t::binary:
20034  case value_t::discarded:
20035  default:
20036  break;
20037  }
20038 #endif
20039  }
20040 
20041  iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
20042  {
20043 #if JSON_DIAGNOSTICS
20044  for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
20045  {
20046  (it + i)->m_parent = this;
20047  }
20048 #else
20049  static_cast<void>(count_set_parents);
20050 #endif
20051  return it;
20052  }
20053 
20054  reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
20055  {
20056 #if JSON_DIAGNOSTICS
20057  if (old_capacity != static_cast<std::size_t>(-1))
20058  {
20059  // see https://github.com/nlohmann/json/issues/2838
20060  JSON_ASSERT(type() == value_t::array);
20061  if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
20062  {
20063  // capacity has changed: update all parents
20064  set_parents();
20065  return j;
20066  }
20067  }
20068 
20069  // ordered_json uses a vector internally, so pointers could have
20070  // been invalidated; see https://github.com/nlohmann/json/issues/2962
20071 #ifdef JSON_HEDLEY_MSVC_VERSION
20072 #pragma warning(push )
20073 #pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
20074 #endif
20075  if (detail::is_ordered_map<object_t>::value)
20076  {
20077  set_parents();
20078  return j;
20079  }
20080 #ifdef JSON_HEDLEY_MSVC_VERSION
20081 #pragma warning( pop )
20082 #endif
20083 
20084  j.m_parent = this;
20085 #else
20086  static_cast<void>(j);
20087  static_cast<void>(old_capacity);
20088 #endif
20089  return j;
20090  }
20091 
20092 public:
20094  // JSON parser callback //
20096 
20099  using parse_event_t = detail::parse_event_t;
20100 
20103  using parser_callback_t = detail::parser_callback_t<basic_json>;
20104 
20106  // constructors //
20108 
20113 
20116  basic_json(const value_t v)
20117  : m_data(v)
20118  {
20119  assert_invariant();
20120  }
20121 
20124  basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
20125  : basic_json(value_t::null)
20126  {
20127  assert_invariant();
20128  }
20129 
20132  template < typename CompatibleType,
20133  typename U = detail::uncvref_t<CompatibleType>,
20134  detail::enable_if_t <
20135  !detail::is_basic_json<U>::value&& detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
20136  basic_json(CompatibleType&& val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
20137  JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
20138  std::forward<CompatibleType>(val))))
20139  {
20140  JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
20141  set_parents();
20142  assert_invariant();
20143  }
20144 
20147  template < typename BasicJsonType,
20148  detail::enable_if_t <
20149  detail::is_basic_json<BasicJsonType>::value && !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
20150  basic_json(const BasicJsonType& val)
20151  {
20152  using other_boolean_t = typename BasicJsonType::boolean_t;
20153  using other_number_float_t = typename BasicJsonType::number_float_t;
20154  using other_number_integer_t = typename BasicJsonType::number_integer_t;
20155  using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
20156  using other_string_t = typename BasicJsonType::string_t;
20157  using other_object_t = typename BasicJsonType::object_t;
20158  using other_array_t = typename BasicJsonType::array_t;
20159  using other_binary_t = typename BasicJsonType::binary_t;
20160 
20161  switch (val.type())
20162  {
20163  case value_t::boolean:
20164  JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
20165  break;
20166  case value_t::number_float:
20167  JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
20168  break;
20169  case value_t::number_integer:
20170  JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
20171  break;
20172  case value_t::number_unsigned:
20173  JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
20174  break;
20175  case value_t::string:
20176  JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
20177  break;
20178  case value_t::object:
20179  JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
20180  break;
20181  case value_t::array:
20182  JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
20183  break;
20184  case value_t::binary:
20185  JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
20186  break;
20187  case value_t::null:
20188  *this = nullptr;
20189  break;
20190  case value_t::discarded:
20191  m_data.m_type = value_t::discarded;
20192  break;
20193  default: // LCOV_EXCL_LINE
20194  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
20195  }
20196  JSON_ASSERT(m_data.m_type == val.type());
20197  set_parents();
20198  assert_invariant();
20199  }
20200 
20203  basic_json(initializer_list_t init,
20204  bool type_deduction = true,
20205  value_t manual_type = value_t::array)
20206  {
20207  // check if each element is an array with two elements whose first
20208  // element is a string
20209  bool is_an_object = std::all_of(init.begin(), init.end(),
20210  [](const detail::json_ref<basic_json>& element_ref)
20211  {
20212  // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
20213  // (many string types can be constructed from 0 via its null-pointer guise, so we get a
20214  // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
20215  return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
20216  });
20217 
20218  // adjust type if type deduction is not wanted
20219  if (!type_deduction)
20220  {
20221  // if array is wanted, do not create an object though possible
20222  if (manual_type == value_t::array)
20223  {
20224  is_an_object = false;
20225  }
20226 
20227  // if object is wanted but impossible, throw an exception
20228  if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
20229  {
20230  JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
20231  }
20232  }
20233 
20234  if (is_an_object)
20235  {
20236  // the initializer list is a list of pairs -> create object
20237  m_data.m_type = value_t::object;
20238  m_data.m_value = value_t::object;
20239 
20240  for (auto& element_ref : init)
20241  {
20242  auto element = element_ref.moved_or_copied();
20243  m_data.m_value.object->emplace(
20244  std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
20245  std::move((*element.m_data.m_value.array)[1]));
20246  }
20247  }
20248  else
20249  {
20250  // the initializer list describes an array -> create array
20251  m_data.m_type = value_t::array;
20252  m_data.m_value.array = create<array_t>(init.begin(), init.end());
20253  }
20254 
20255  set_parents();
20256  assert_invariant();
20257  }
20258 
20261  JSON_HEDLEY_WARN_UNUSED_RESULT
20262  static basic_json binary(const typename binary_t::container_type& init)
20263  {
20264  auto res = basic_json();
20265  res.m_data.m_type = value_t::binary;
20266  res.m_data.m_value = init;
20267  return res;
20268  }
20269 
20272  JSON_HEDLEY_WARN_UNUSED_RESULT
20273  static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
20274  {
20275  auto res = basic_json();
20276  res.m_data.m_type = value_t::binary;
20277  res.m_data.m_value = binary_t(init, subtype);
20278  return res;
20279  }
20280 
20283  JSON_HEDLEY_WARN_UNUSED_RESULT
20284  static basic_json binary(typename binary_t::container_type&& init)
20285  {
20286  auto res = basic_json();
20287  res.m_data.m_type = value_t::binary;
20288  res.m_data.m_value = std::move(init);
20289  return res;
20290  }
20291 
20294  JSON_HEDLEY_WARN_UNUSED_RESULT
20295  static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
20296  {
20297  auto res = basic_json();
20298  res.m_data.m_type = value_t::binary;
20299  res.m_data.m_value = binary_t(std::move(init), subtype);
20300  return res;
20301  }
20302 
20305  JSON_HEDLEY_WARN_UNUSED_RESULT
20306  static basic_json array(initializer_list_t init = {})
20307  {
20308  return basic_json(init, false, value_t::array);
20309  }
20310 
20313  JSON_HEDLEY_WARN_UNUSED_RESULT
20314  static basic_json object(initializer_list_t init = {})
20315  {
20316  return basic_json(init, false, value_t::object);
20317  }
20318 
20321  basic_json(size_type cnt, const basic_json& val) :
20322  m_data{ cnt, val }
20323  {
20324  set_parents();
20325  assert_invariant();
20326  }
20327 
20330  template < class InputIT, typename std::enable_if <
20331  std::is_same<InputIT, typename basic_json_t::iterator>::value ||
20332  std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
20333  basic_json(InputIT first, InputIT last)
20334  {
20335  JSON_ASSERT(first.m_object != nullptr);
20336  JSON_ASSERT(last.m_object != nullptr);
20337 
20338  // make sure iterator fits the current value
20339  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20340  {
20341  JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
20342  }
20343 
20344  // copy type from first iterator
20345  m_data.m_type = first.m_object->m_data.m_type;
20346 
20347  // check if iterator range is complete for primitive values
20348  switch (m_data.m_type)
20349  {
20350  case value_t::boolean:
20351  case value_t::number_float:
20352  case value_t::number_integer:
20353  case value_t::number_unsigned:
20354  case value_t::string:
20355  {
20356  if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
20357  || !last.m_it.primitive_iterator.is_end()))
20358  {
20359  JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
20360  }
20361  break;
20362  }
20363 
20364  case value_t::null:
20365  case value_t::object:
20366  case value_t::array:
20367  case value_t::binary:
20368  case value_t::discarded:
20369  default:
20370  break;
20371  }
20372 
20373  switch (m_data.m_type)
20374  {
20375  case value_t::number_integer:
20376  {
20377  m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
20378  break;
20379  }
20380 
20381  case value_t::number_unsigned:
20382  {
20383  m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
20384  break;
20385  }
20386 
20387  case value_t::number_float:
20388  {
20389  m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
20390  break;
20391  }
20392 
20393  case value_t::boolean:
20394  {
20395  m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
20396  break;
20397  }
20398 
20399  case value_t::string:
20400  {
20401  m_data.m_value = *first.m_object->m_data.m_value.string;
20402  break;
20403  }
20404 
20405  case value_t::object:
20406  {
20407  m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
20408  last.m_it.object_iterator);
20409  break;
20410  }
20411 
20412  case value_t::array:
20413  {
20414  m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
20415  last.m_it.array_iterator);
20416  break;
20417  }
20418 
20419  case value_t::binary:
20420  {
20421  m_data.m_value = *first.m_object->m_data.m_value.binary;
20422  break;
20423  }
20424 
20425  case value_t::null:
20426  case value_t::discarded:
20427  default:
20428  JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
20429  }
20430 
20431  set_parents();
20432  assert_invariant();
20433  }
20434 
20436  // other constructors and destructor //
20438 
20439  template<typename JsonRef,
20440  detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
20441  std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
20442  basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
20443 
20446  basic_json(const basic_json& other)
20447  : json_base_class_t(other)
20448  {
20449  m_data.m_type = other.m_data.m_type;
20450  // check of passed value is valid
20451  other.assert_invariant();
20452 
20453  switch (m_data.m_type)
20454  {
20455  case value_t::object:
20456  {
20457  m_data.m_value = *other.m_data.m_value.object;
20458  break;
20459  }
20460 
20461  case value_t::array:
20462  {
20463  m_data.m_value = *other.m_data.m_value.array;
20464  break;
20465  }
20466 
20467  case value_t::string:
20468  {
20469  m_data.m_value = *other.m_data.m_value.string;
20470  break;
20471  }
20472 
20473  case value_t::boolean:
20474  {
20475  m_data.m_value = other.m_data.m_value.boolean;
20476  break;
20477  }
20478 
20479  case value_t::number_integer:
20480  {
20481  m_data.m_value = other.m_data.m_value.number_integer;
20482  break;
20483  }
20484 
20485  case value_t::number_unsigned:
20486  {
20487  m_data.m_value = other.m_data.m_value.number_unsigned;
20488  break;
20489  }
20490 
20491  case value_t::number_float:
20492  {
20493  m_data.m_value = other.m_data.m_value.number_float;
20494  break;
20495  }
20496 
20497  case value_t::binary:
20498  {
20499  m_data.m_value = *other.m_data.m_value.binary;
20500  break;
20501  }
20502 
20503  case value_t::null:
20504  case value_t::discarded:
20505  default:
20506  break;
20507  }
20508 
20509  set_parents();
20510  assert_invariant();
20511  }
20512 
20515  basic_json(basic_json&& other) noexcept
20516  : json_base_class_t(std::forward<json_base_class_t>(other)),
20517  m_data(std::move(other.m_data))
20518  {
20519  // check that passed value is valid
20520  other.assert_invariant(false);
20521 
20522  // invalidate payload
20523  other.m_data.m_type = value_t::null;
20524  other.m_data.m_value = {};
20525 
20526  set_parents();
20527  assert_invariant();
20528  }
20529 
20532  basic_json& operator=(basic_json other) noexcept (
20533  std::is_nothrow_move_constructible<value_t>::value&&
20534  std::is_nothrow_move_assignable<value_t>::value&&
20535  std::is_nothrow_move_constructible<json_value>::value&&
20536  std::is_nothrow_move_assignable<json_value>::value&&
20537  std::is_nothrow_move_assignable<json_base_class_t>::value
20538  )
20539  {
20540  // check that passed value is valid
20541  other.assert_invariant();
20542 
20543  using std::swap;
20544  swap(m_data.m_type, other.m_data.m_type);
20545  swap(m_data.m_value, other.m_data.m_value);
20546  json_base_class_t::operator=(std::move(other));
20547 
20548  set_parents();
20549  assert_invariant();
20550  return *this;
20551  }
20552 
20555  ~basic_json() noexcept
20556  {
20557  assert_invariant(false);
20558  }
20559 
20561 
20562 public:
20564  // object inspection //
20566 
20570 
20573  string_t dump(const int indent = -1,
20574  const char indent_char = ' ',
20575  const bool ensure_ascii = false,
20576  const error_handler_t error_handler = error_handler_t::strict) const
20577  {
20578  string_t result;
20579  serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
20580 
20581  if (indent >= 0)
20582  {
20583  s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
20584  }
20585  else
20586  {
20587  s.dump(*this, false, ensure_ascii, 0);
20588  }
20589 
20590  return result;
20591  }
20592 
20595  constexpr value_t type() const noexcept
20596  {
20597  return m_data.m_type;
20598  }
20599 
20602  constexpr bool is_primitive() const noexcept
20603  {
20604  return is_null() || is_string() || is_boolean() || is_number() || is_binary();
20605  }
20606 
20609  constexpr bool is_structured() const noexcept
20610  {
20611  return is_array() || is_object();
20612  }
20613 
20616  constexpr bool is_null() const noexcept
20617  {
20618  return m_data.m_type == value_t::null;
20619  }
20620 
20623  constexpr bool is_boolean() const noexcept
20624  {
20625  return m_data.m_type == value_t::boolean;
20626  }
20627 
20630  constexpr bool is_number() const noexcept
20631  {
20632  return is_number_integer() || is_number_float();
20633  }
20634 
20637  constexpr bool is_number_integer() const noexcept
20638  {
20639  return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
20640  }
20641 
20644  constexpr bool is_number_unsigned() const noexcept
20645  {
20646  return m_data.m_type == value_t::number_unsigned;
20647  }
20648 
20651  constexpr bool is_number_float() const noexcept
20652  {
20653  return m_data.m_type == value_t::number_float;
20654  }
20655 
20658  constexpr bool is_object() const noexcept
20659  {
20660  return m_data.m_type == value_t::object;
20661  }
20662 
20665  constexpr bool is_array() const noexcept
20666  {
20667  return m_data.m_type == value_t::array;
20668  }
20669 
20672  constexpr bool is_string() const noexcept
20673  {
20674  return m_data.m_type == value_t::string;
20675  }
20676 
20679  constexpr bool is_binary() const noexcept
20680  {
20681  return m_data.m_type == value_t::binary;
20682  }
20683 
20686  constexpr bool is_discarded() const noexcept
20687  {
20688  return m_data.m_type == value_t::discarded;
20689  }
20690 
20693  constexpr operator value_t() const noexcept
20694  {
20695  return m_data.m_type;
20696  }
20697 
20699 
20700 private:
20702  // value access //
20704 
20706  boolean_t get_impl(boolean_t* /*unused*/) const
20707  {
20708  if (JSON_HEDLEY_LIKELY(is_boolean()))
20709  {
20710  return m_data.m_value.boolean;
20711  }
20712 
20713  JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
20714  }
20715 
20717  object_t* get_impl_ptr(object_t* /*unused*/) noexcept
20718  {
20719  return is_object() ? m_data.m_value.object : nullptr;
20720  }
20721 
20723  constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
20724  {
20725  return is_object() ? m_data.m_value.object : nullptr;
20726  }
20727 
20729  array_t* get_impl_ptr(array_t* /*unused*/) noexcept
20730  {
20731  return is_array() ? m_data.m_value.array : nullptr;
20732  }
20733 
20735  constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
20736  {
20737  return is_array() ? m_data.m_value.array : nullptr;
20738  }
20739 
20741  string_t* get_impl_ptr(string_t* /*unused*/) noexcept
20742  {
20743  return is_string() ? m_data.m_value.string : nullptr;
20744  }
20745 
20747  constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
20748  {
20749  return is_string() ? m_data.m_value.string : nullptr;
20750  }
20751 
20753  boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
20754  {
20755  return is_boolean() ? &m_data.m_value.boolean : nullptr;
20756  }
20757 
20759  constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
20760  {
20761  return is_boolean() ? &m_data.m_value.boolean : nullptr;
20762  }
20763 
20765  number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
20766  {
20767  return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
20768  }
20769 
20771  constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
20772  {
20773  return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
20774  }
20775 
20777  number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
20778  {
20779  return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
20780  }
20781 
20783  constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
20784  {
20785  return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
20786  }
20787 
20789  number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
20790  {
20791  return is_number_float() ? &m_data.m_value.number_float : nullptr;
20792  }
20793 
20795  constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
20796  {
20797  return is_number_float() ? &m_data.m_value.number_float : nullptr;
20798  }
20799 
20801  binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
20802  {
20803  return is_binary() ? m_data.m_value.binary : nullptr;
20804  }
20805 
20807  constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
20808  {
20809  return is_binary() ? m_data.m_value.binary : nullptr;
20810  }
20811 
20823  template<typename ReferenceType, typename ThisType>
20824  static ReferenceType get_ref_impl(ThisType& obj)
20825  {
20826  // delegate the call to get_ptr<>()
20827  auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
20828 
20829  if (JSON_HEDLEY_LIKELY(ptr != nullptr))
20830  {
20831  return *ptr;
20832  }
20833 
20834  JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
20835  }
20836 
20837 public:
20841 
20844  template<typename PointerType, typename std::enable_if<
20845  std::is_pointer<PointerType>::value, int>::type = 0>
20846  auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20847  {
20848  // delegate the call to get_impl_ptr<>()
20849  return get_impl_ptr(static_cast<PointerType>(nullptr));
20850  }
20851 
20854  template < typename PointerType, typename std::enable_if <
20855  std::is_pointer<PointerType>::value&&
20856  std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
20857  constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20858  {
20859  // delegate the call to get_impl_ptr<>() const
20860  return get_impl_ptr(static_cast<PointerType>(nullptr));
20861  }
20862 
20863 private:
20902  template < typename ValueType,
20903  detail::enable_if_t <
20904  detail::is_default_constructible<ValueType>::value&&
20905  detail::has_from_json<basic_json_t, ValueType>::value,
20906  int > = 0 >
20907  ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
20908  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20909  {
20910  auto ret = ValueType();
20911  JSONSerializer<ValueType>::from_json(*this, ret);
20912  return ret;
20913  }
20914 
20945  template < typename ValueType,
20946  detail::enable_if_t <
20947  detail::has_non_default_from_json<basic_json_t, ValueType>::value,
20948  int > = 0 >
20949  ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
20950  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20951  {
20952  return JSONSerializer<ValueType>::from_json(*this);
20953  }
20954 
20970  template < typename BasicJsonType,
20971  detail::enable_if_t <
20972  detail::is_basic_json<BasicJsonType>::value,
20973  int > = 0 >
20974  BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
20975  {
20976  return *this;
20977  }
20978 
20993  template<typename BasicJsonType,
20994  detail::enable_if_t<
20995  std::is_same<BasicJsonType, basic_json_t>::value,
20996  int> = 0>
20997  basic_json get_impl(detail::priority_tag<3> /*unused*/) const
20998  {
20999  return *this;
21000  }
21001 
21006  template<typename PointerType,
21007  detail::enable_if_t<
21008  std::is_pointer<PointerType>::value,
21009  int> = 0>
21010  constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
21011  -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
21012  {
21013  // delegate the call to get_ptr
21014  return get_ptr<PointerType>();
21015  }
21016 
21017 public:
21041  template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
21042 #if defined(JSON_HAS_CPP_14)
21043  constexpr
21044 #endif
21045  auto get() const noexcept(
21046  noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
21047  -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
21048  {
21049  // we cannot static_assert on ValueTypeCV being non-const, because
21050  // there is support for get<const basic_json_t>(), which is why we
21051  // still need the uncvref
21052  static_assert(!std::is_reference<ValueTypeCV>::value,
21053  "get() cannot be used with reference types, you might want to use get_ref()");
21054  return get_impl<ValueType>(detail::priority_tag<4> {});
21055  }
21056 
21084  template<typename PointerType, typename std::enable_if<
21085  std::is_pointer<PointerType>::value, int>::type = 0>
21086  auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
21087  {
21088  // delegate the call to get_ptr
21089  return get_ptr<PointerType>();
21090  }
21091 
21094  template < typename ValueType,
21095  detail::enable_if_t <
21096  !detail::is_basic_json<ValueType>::value&&
21097  detail::has_from_json<basic_json_t, ValueType>::value,
21098  int > = 0 >
21099  ValueType& get_to(ValueType& v) const noexcept(noexcept(
21100  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
21101  {
21102  JSONSerializer<ValueType>::from_json(*this, v);
21103  return v;
21104  }
21105 
21106  // specialization to allow calling get_to with a basic_json value
21107  // see https://github.com/nlohmann/json/issues/2175
21108  template<typename ValueType,
21109  detail::enable_if_t <
21110  detail::is_basic_json<ValueType>::value,
21111  int> = 0>
21112  ValueType& get_to(ValueType& v) const
21113  {
21114  v = *this;
21115  return v;
21116  }
21117 
21118  template <
21119  typename T, std::size_t N,
21120  typename Array = T(&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
21121  detail::enable_if_t <
21122  detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
21123  Array get_to(T(&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
21124  noexcept(noexcept(JSONSerializer<Array>::from_json(
21125  std::declval<const basic_json_t&>(), v)))
21126  {
21127  JSONSerializer<Array>::from_json(*this, v);
21128  return v;
21129  }
21130 
21133  template<typename ReferenceType, typename std::enable_if<
21134  std::is_reference<ReferenceType>::value, int>::type = 0>
21135  ReferenceType get_ref()
21136  {
21137  // delegate call to get_ref_impl
21138  return get_ref_impl<ReferenceType>(*this);
21139  }
21140 
21143  template < typename ReferenceType, typename std::enable_if <
21144  std::is_reference<ReferenceType>::value&&
21145  std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
21146  ReferenceType get_ref() const
21147  {
21148  // delegate call to get_ref_impl
21149  return get_ref_impl<ReferenceType>(*this);
21150  }
21151 
21181  template < typename ValueType, typename std::enable_if <
21182  detail::conjunction <
21183  detail::negation<std::is_pointer<ValueType>>,
21184  detail::negation<std::is_same<ValueType, std::nullptr_t>>,
21185  detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
21186  detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
21187  detail::negation<detail::is_basic_json<ValueType>>,
21188  detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
21189 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
21190  detail::negation<std::is_same<ValueType, std::string_view>>,
21191 #endif
21192 #if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
21193  detail::negation<std::is_same<ValueType, std::any>>,
21194 #endif
21195  detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
21196  >::value, int >::type = 0 >
21197  JSON_EXPLICIT operator ValueType() const
21198  {
21199  // delegate the call to get<>() const
21200  return get<ValueType>();
21201  }
21202 
21205  binary_t& get_binary()
21206  {
21207  if (!is_binary())
21208  {
21209  JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
21210  }
21211 
21212  return *get_ptr<binary_t*>();
21213  }
21214 
21217  const binary_t& get_binary() const
21218  {
21219  if (!is_binary())
21220  {
21221  JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
21222  }
21223 
21224  return *get_ptr<const binary_t*>();
21225  }
21226 
21228 
21230  // element access //
21232 
21236 
21239  reference at(size_type idx)
21240  {
21241  // at only works for arrays
21242  if (JSON_HEDLEY_LIKELY(is_array()))
21243  {
21244  JSON_TRY
21245  {
21246  return set_parent(m_data.m_value.array->at(idx));
21247  }
21248  JSON_CATCH(std::out_of_range&)
21249  {
21250  // create better exception explanation
21251  JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21252  }
21253  }
21254  else
21255  {
21256  JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21257  }
21258  }
21259 
21262  const_reference at(size_type idx) const
21263  {
21264  // at only works for arrays
21265  if (JSON_HEDLEY_LIKELY(is_array()))
21266  {
21267  JSON_TRY
21268  {
21269  return m_data.m_value.array->at(idx);
21270  }
21271  JSON_CATCH(std::out_of_range&)
21272  {
21273  // create better exception explanation
21274  JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21275  }
21276  }
21277  else
21278  {
21279  JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21280  }
21281  }
21282 
21285  reference at(const typename object_t::key_type& key)
21286  {
21287  // at only works for objects
21288  if (JSON_HEDLEY_UNLIKELY(!is_object()))
21289  {
21290  JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21291  }
21292 
21293  auto it = m_data.m_value.object->find(key);
21294  if (it == m_data.m_value.object->end())
21295  {
21296  JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
21297  }
21298  return set_parent(it->second);
21299  }
21300 
21303  template<class KeyType, detail::enable_if_t<
21304  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
21305  reference at(KeyType&& key)
21306  {
21307  // at only works for objects
21308  if (JSON_HEDLEY_UNLIKELY(!is_object()))
21309  {
21310  JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21311  }
21312 
21313  auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
21314  if (it == m_data.m_value.object->end())
21315  {
21316  JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
21317  }
21318  return set_parent(it->second);
21319  }
21320 
21323  const_reference at(const typename object_t::key_type& key) const
21324  {
21325  // at only works for objects
21326  if (JSON_HEDLEY_UNLIKELY(!is_object()))
21327  {
21328  JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21329  }
21330 
21331  auto it = m_data.m_value.object->find(key);
21332  if (it == m_data.m_value.object->end())
21333  {
21334  JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
21335  }
21336  return it->second;
21337  }
21338 
21341  template<class KeyType, detail::enable_if_t<
21342  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
21343  const_reference at(KeyType&& key) const
21344  {
21345  // at only works for objects
21346  if (JSON_HEDLEY_UNLIKELY(!is_object()))
21347  {
21348  JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21349  }
21350 
21351  auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
21352  if (it == m_data.m_value.object->end())
21353  {
21354  JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
21355  }
21356  return it->second;
21357  }
21358 
21361  reference operator[](size_type idx)
21362  {
21363  // implicitly convert null value to an empty array
21364  if (is_null())
21365  {
21366  m_data.m_type = value_t::array;
21367  m_data.m_value.array = create<array_t>();
21368  assert_invariant();
21369  }
21370 
21371  // operator[] only works for arrays
21372  if (JSON_HEDLEY_LIKELY(is_array()))
21373  {
21374  // fill up array with null values if given idx is outside range
21375  if (idx >= m_data.m_value.array->size())
21376  {
21377 #if JSON_DIAGNOSTICS
21378  // remember array size & capacity before resizing
21379  const auto old_size = m_data.m_value.array->size();
21380  const auto old_capacity = m_data.m_value.array->capacity();
21381 #endif
21382  m_data.m_value.array->resize(idx + 1);
21383 
21384 #if JSON_DIAGNOSTICS
21385  if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
21386  {
21387  // capacity has changed: update all parents
21388  set_parents();
21389  }
21390  else
21391  {
21392  // set parent for values added above
21393  set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
21394  }
21395 #endif
21396  assert_invariant();
21397  }
21398 
21399  return m_data.m_value.array->operator[](idx);
21400  }
21401 
21402  JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
21403  }
21404 
21407  const_reference operator[](size_type idx) const
21408  {
21409  // const operator[] only works for arrays
21410  if (JSON_HEDLEY_LIKELY(is_array()))
21411  {
21412  return m_data.m_value.array->operator[](idx);
21413  }
21414 
21415  JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
21416  }
21417 
21420  reference operator[](typename object_t::key_type key)
21421  {
21422  // implicitly convert null value to an empty object
21423  if (is_null())
21424  {
21425  m_data.m_type = value_t::object;
21426  m_data.m_value.object = create<object_t>();
21427  assert_invariant();
21428  }
21429 
21430  // operator[] only works for objects
21431  if (JSON_HEDLEY_LIKELY(is_object()))
21432  {
21433  auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
21434  return set_parent(result.first->second);
21435  }
21436 
21437  JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
21438  }
21439 
21442  const_reference operator[](const typename object_t::key_type& key) const
21443  {
21444  // const operator[] only works for objects
21445  if (JSON_HEDLEY_LIKELY(is_object()))
21446  {
21447  auto it = m_data.m_value.object->find(key);
21448  JSON_ASSERT(it != m_data.m_value.object->end());
21449  return it->second;
21450  }
21451 
21452  JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
21453  }
21454 
21455  // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
21456  // (they seemingly cannot be constrained to resolve the ambiguity)
21457  template<typename T>
21458  reference operator[](T* key)
21459  {
21460  return operator[](typename object_t::key_type(key));
21461  }
21462 
21463  template<typename T>
21464  const_reference operator[](T* key) const
21465  {
21466  return operator[](typename object_t::key_type(key));
21467  }
21468 
21471  template<class KeyType, detail::enable_if_t<
21472  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
21473  reference operator[](KeyType&& key)
21474  {
21475  // implicitly convert null value to an empty object
21476  if (is_null())
21477  {
21478  m_data.m_type = value_t::object;
21479  m_data.m_value.object = create<object_t>();
21480  assert_invariant();
21481  }
21482 
21483  // operator[] only works for objects
21484  if (JSON_HEDLEY_LIKELY(is_object()))
21485  {
21486  auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
21487  return set_parent(result.first->second);
21488  }
21489 
21490  JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
21491  }
21492 
21495  template<class KeyType, detail::enable_if_t<
21496  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
21497  const_reference operator[](KeyType&& key) const
21498  {
21499  // const operator[] only works for objects
21500  if (JSON_HEDLEY_LIKELY(is_object()))
21501  {
21502  auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
21503  JSON_ASSERT(it != m_data.m_value.object->end());
21504  return it->second;
21505  }
21506 
21507  JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
21508  }
21509 
21510 private:
21511  template<typename KeyType>
21512  using is_comparable_with_object_key = detail::is_comparable <
21513  object_comparator_t, const typename object_t::key_type&, KeyType >;
21514 
21515  template<typename ValueType>
21516  using value_return_type = std::conditional <
21517  detail::is_c_string_uncvref<ValueType>::value,
21518  string_t, typename std::decay<ValueType>::type >;
21519 
21520 public:
21523  template < class ValueType, detail::enable_if_t <
21524  !detail::is_transparent<object_comparator_t>::value
21525  && detail::is_getable<basic_json_t, ValueType>::value
21526  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21527  ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
21528  {
21529  // value only works for objects
21530  if (JSON_HEDLEY_LIKELY(is_object()))
21531  {
21532  // if key is found, return value and given default value otherwise
21533  const auto it = find(key);
21534  if (it != end())
21535  {
21536  return it->template get<ValueType>();
21537  }
21538 
21539  return default_value;
21540  }
21541 
21542  JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
21543  }
21544 
21547  template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
21548  detail::enable_if_t <
21549  !detail::is_transparent<object_comparator_t>::value
21550  && detail::is_getable<basic_json_t, ReturnType>::value
21551  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21552  ReturnType value(const typename object_t::key_type& key, ValueType&& default_value) const
21553  {
21554  // value only works for objects
21555  if (JSON_HEDLEY_LIKELY(is_object()))
21556  {
21557  // if key is found, return value and given default value otherwise
21558  const auto it = find(key);
21559  if (it != end())
21560  {
21561  return it->template get<ReturnType>();
21562  }
21563 
21564  return std::forward<ValueType>(default_value);
21565  }
21566 
21567  JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
21568  }
21569 
21572  template < class ValueType, class KeyType, detail::enable_if_t <
21573  detail::is_transparent<object_comparator_t>::value
21574  && !detail::is_json_pointer<KeyType>::value
21575  && is_comparable_with_object_key<KeyType>::value
21576  && detail::is_getable<basic_json_t, ValueType>::value
21577  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21578  ValueType value(KeyType&& key, const ValueType& default_value) const
21579  {
21580  // value only works for objects
21581  if (JSON_HEDLEY_LIKELY(is_object()))
21582  {
21583  // if key is found, return value and given default value otherwise
21584  const auto it = find(std::forward<KeyType>(key));
21585  if (it != end())
21586  {
21587  return it->template get<ValueType>();
21588  }
21589 
21590  return default_value;
21591  }
21592 
21593  JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
21594  }
21595 
21598  template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
21599  detail::enable_if_t <
21600  detail::is_transparent<object_comparator_t>::value
21601  && !detail::is_json_pointer<KeyType>::value
21602  && is_comparable_with_object_key<KeyType>::value
21603  && detail::is_getable<basic_json_t, ReturnType>::value
21604  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21605  ReturnType value(KeyType&& key, ValueType&& default_value) const
21606  {
21607  // value only works for objects
21608  if (JSON_HEDLEY_LIKELY(is_object()))
21609  {
21610  // if key is found, return value and given default value otherwise
21611  const auto it = find(std::forward<KeyType>(key));
21612  if (it != end())
21613  {
21614  return it->template get<ReturnType>();
21615  }
21616 
21617  return std::forward<ValueType>(default_value);
21618  }
21619 
21620  JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
21621  }
21622 
21625  template < class ValueType, detail::enable_if_t <
21626  detail::is_getable<basic_json_t, ValueType>::value
21627  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21628  ValueType value(const json_pointer& ptr, const ValueType& default_value) const
21629  {
21630  // value only works for objects
21631  if (JSON_HEDLEY_LIKELY(is_object()))
21632  {
21633  // if pointer resolves a value, return it or use default value
21634  JSON_TRY
21635  {
21636  return ptr.get_checked(this).template get<ValueType>();
21637  }
21638  JSON_INTERNAL_CATCH(out_of_range&)
21639  {
21640  return default_value;
21641  }
21642  }
21643 
21644  JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
21645  }
21646 
21649  template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
21650  detail::enable_if_t <
21651  detail::is_getable<basic_json_t, ReturnType>::value
21652  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21653  ReturnType value(const json_pointer& ptr, ValueType&& default_value) const
21654  {
21655  // value only works for objects
21656  if (JSON_HEDLEY_LIKELY(is_object()))
21657  {
21658  // if pointer resolves a value, return it or use default value
21659  JSON_TRY
21660  {
21661  return ptr.get_checked(this).template get<ReturnType>();
21662  }
21663  JSON_INTERNAL_CATCH(out_of_range&)
21664  {
21665  return std::forward<ValueType>(default_value);
21666  }
21667  }
21668 
21669  JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
21670  }
21671 
21672  template < class ValueType, class BasicJsonType, detail::enable_if_t <
21673  detail::is_basic_json<BasicJsonType>::value
21674  && detail::is_getable<basic_json_t, ValueType>::value
21675  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21676  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
21677  ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
21678  {
21679  return value(ptr.convert(), default_value);
21680  }
21681 
21682  template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
21683  detail::enable_if_t <
21684  detail::is_basic_json<BasicJsonType>::value
21685  && detail::is_getable<basic_json_t, ReturnType>::value
21686  && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21687  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
21688  ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType&& default_value) const
21689  {
21690  return value(ptr.convert(), std::forward<ValueType>(default_value));
21691  }
21692 
21695  reference front()
21696  {
21697  return *begin();
21698  }
21699 
21702  const_reference front() const
21703  {
21704  return *cbegin();
21705  }
21706 
21709  reference back()
21710  {
21711  auto tmp = end();
21712  --tmp;
21713  return *tmp;
21714  }
21715 
21718  const_reference back() const
21719  {
21720  auto tmp = cend();
21721  --tmp;
21722  return *tmp;
21723  }
21724 
21727  template < class IteratorType, detail::enable_if_t <
21728  std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21729  std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
21730  IteratorType erase(IteratorType pos)
21731  {
21732  // make sure iterator fits the current value
21733  if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
21734  {
21735  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
21736  }
21737 
21738  IteratorType result = end();
21739 
21740  switch (m_data.m_type)
21741  {
21742  case value_t::boolean:
21743  case value_t::number_float:
21744  case value_t::number_integer:
21745  case value_t::number_unsigned:
21746  case value_t::string:
21747  case value_t::binary:
21748  {
21749  if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
21750  {
21751  JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
21752  }
21753 
21754  if (is_string())
21755  {
21756  AllocatorType<string_t> alloc;
21757  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
21758  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
21759  m_data.m_value.string = nullptr;
21760  }
21761  else if (is_binary())
21762  {
21763  AllocatorType<binary_t> alloc;
21764  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
21765  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
21766  m_data.m_value.binary = nullptr;
21767  }
21768 
21769  m_data.m_type = value_t::null;
21770  assert_invariant();
21771  break;
21772  }
21773 
21774  case value_t::object:
21775  {
21776  result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
21777  break;
21778  }
21779 
21780  case value_t::array:
21781  {
21782  result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
21783  break;
21784  }
21785 
21786  case value_t::null:
21787  case value_t::discarded:
21788  default:
21789  JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
21790  }
21791 
21792  return result;
21793  }
21794 
21797  template < class IteratorType, detail::enable_if_t <
21798  std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21799  std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
21800  IteratorType erase(IteratorType first, IteratorType last)
21801  {
21802  // make sure iterator fits the current value
21803  if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
21804  {
21805  JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
21806  }
21807 
21808  IteratorType result = end();
21809 
21810  switch (m_data.m_type)
21811  {
21812  case value_t::boolean:
21813  case value_t::number_float:
21814  case value_t::number_integer:
21815  case value_t::number_unsigned:
21816  case value_t::string:
21817  case value_t::binary:
21818  {
21819  if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
21820  || !last.m_it.primitive_iterator.is_end()))
21821  {
21822  JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
21823  }
21824 
21825  if (is_string())
21826  {
21827  AllocatorType<string_t> alloc;
21828  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
21829  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
21830  m_data.m_value.string = nullptr;
21831  }
21832  else if (is_binary())
21833  {
21834  AllocatorType<binary_t> alloc;
21835  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
21836  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
21837  m_data.m_value.binary = nullptr;
21838  }
21839 
21840  m_data.m_type = value_t::null;
21841  assert_invariant();
21842  break;
21843  }
21844 
21845  case value_t::object:
21846  {
21847  result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
21848  last.m_it.object_iterator);
21849  break;
21850  }
21851 
21852  case value_t::array:
21853  {
21854  result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
21855  last.m_it.array_iterator);
21856  break;
21857  }
21858 
21859  case value_t::null:
21860  case value_t::discarded:
21861  default:
21862  JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
21863  }
21864 
21865  return result;
21866  }
21867 
21868 private:
21869  template < typename KeyType, detail::enable_if_t <
21870  detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
21871  size_type erase_internal(KeyType&& key)
21872  {
21873  // this erase only works for objects
21874  if (JSON_HEDLEY_UNLIKELY(!is_object()))
21875  {
21876  JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
21877  }
21878 
21879  return m_data.m_value.object->erase(std::forward<KeyType>(key));
21880  }
21881 
21882  template < typename KeyType, detail::enable_if_t <
21883  !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
21884  size_type erase_internal(KeyType&& key)
21885  {
21886  // this erase only works for objects
21887  if (JSON_HEDLEY_UNLIKELY(!is_object()))
21888  {
21889  JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
21890  }
21891 
21892  const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
21893  if (it != m_data.m_value.object->end())
21894  {
21895  m_data.m_value.object->erase(it);
21896  return 1;
21897  }
21898  return 0;
21899  }
21900 
21901 public:
21902 
21905  size_type erase(const typename object_t::key_type& key)
21906  {
21907  // the indirection via erase_internal() is added to avoid making this
21908  // function a template and thus de-rank it during overload resolution
21909  return erase_internal(key);
21910  }
21911 
21914  template<class KeyType, detail::enable_if_t<
21915  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
21916  size_type erase(KeyType&& key)
21917  {
21918  return erase_internal(std::forward<KeyType>(key));
21919  }
21920 
21923  void erase(const size_type idx)
21924  {
21925  // this erase only works for arrays
21926  if (JSON_HEDLEY_LIKELY(is_array()))
21927  {
21928  if (JSON_HEDLEY_UNLIKELY(idx >= size()))
21929  {
21930  JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21931  }
21932 
21933  m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
21934  }
21935  else
21936  {
21937  JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
21938  }
21939  }
21940 
21942 
21944  // lookup //
21946 
21949 
21952  iterator find(const typename object_t::key_type& key)
21953  {
21954  auto result = end();
21955 
21956  if (is_object())
21957  {
21958  result.m_it.object_iterator = m_data.m_value.object->find(key);
21959  }
21960 
21961  return result;
21962  }
21963 
21966  const_iterator find(const typename object_t::key_type& key) const
21967  {
21968  auto result = cend();
21969 
21970  if (is_object())
21971  {
21972  result.m_it.object_iterator = m_data.m_value.object->find(key);
21973  }
21974 
21975  return result;
21976  }
21977 
21980  template<class KeyType, detail::enable_if_t<
21981  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
21982  iterator find(KeyType&& key)
21983  {
21984  auto result = end();
21985 
21986  if (is_object())
21987  {
21988  result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
21989  }
21990 
21991  return result;
21992  }
21993 
21996  template<class KeyType, detail::enable_if_t<
21997  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
21998  const_iterator find(KeyType&& key) const
21999  {
22000  auto result = cend();
22001 
22002  if (is_object())
22003  {
22004  result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
22005  }
22006 
22007  return result;
22008  }
22009 
22012  size_type count(const typename object_t::key_type& key) const
22013  {
22014  // return 0 for all nonobject types
22015  return is_object() ? m_data.m_value.object->count(key) : 0;
22016  }
22017 
22020  template<class KeyType, detail::enable_if_t<
22021  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22022  size_type count(KeyType&& key) const
22023  {
22024  // return 0 for all nonobject types
22025  return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
22026  }
22027 
22030  bool contains(const typename object_t::key_type& key) const
22031  {
22032  return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
22033  }
22034 
22037  template<class KeyType, detail::enable_if_t<
22038  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22039  bool contains(KeyType&& key) const
22040  {
22041  return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
22042  }
22043 
22046  bool contains(const json_pointer& ptr) const
22047  {
22048  return ptr.contains(this);
22049  }
22050 
22051  template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
22052  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
22053  bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
22054  {
22055  return ptr.contains(this);
22056  }
22057 
22059 
22061  // iterators //
22063 
22066 
22069  iterator begin() noexcept
22070  {
22071  iterator result(this);
22072  result.set_begin();
22073  return result;
22074  }
22075 
22078  const_iterator begin() const noexcept
22079  {
22080  return cbegin();
22081  }
22082 
22085  const_iterator cbegin() const noexcept
22086  {
22087  const_iterator result(this);
22088  result.set_begin();
22089  return result;
22090  }
22091 
22094  iterator end() noexcept
22095  {
22096  iterator result(this);
22097  result.set_end();
22098  return result;
22099  }
22100 
22103  const_iterator end() const noexcept
22104  {
22105  return cend();
22106  }
22107 
22110  const_iterator cend() const noexcept
22111  {
22112  const_iterator result(this);
22113  result.set_end();
22114  return result;
22115  }
22116 
22119  reverse_iterator rbegin() noexcept
22120  {
22121  return reverse_iterator(end());
22122  }
22123 
22126  const_reverse_iterator rbegin() const noexcept
22127  {
22128  return crbegin();
22129  }
22130 
22133  reverse_iterator rend() noexcept
22134  {
22135  return reverse_iterator(begin());
22136  }
22137 
22140  const_reverse_iterator rend() const noexcept
22141  {
22142  return crend();
22143  }
22144 
22147  const_reverse_iterator crbegin() const noexcept
22148  {
22149  return const_reverse_iterator(cend());
22150  }
22151 
22154  const_reverse_iterator crend() const noexcept
22155  {
22156  return const_reverse_iterator(cbegin());
22157  }
22158 
22159 public:
22165  JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
22166  static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
22167  {
22168  return ref.items();
22169  }
22170 
22176  JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
22177  static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
22178  {
22179  return ref.items();
22180  }
22181 
22184  iteration_proxy<iterator> items() noexcept
22185  {
22186  return iteration_proxy<iterator>(*this);
22187  }
22188 
22191  iteration_proxy<const_iterator> items() const noexcept
22192  {
22193  return iteration_proxy<const_iterator>(*this);
22194  }
22195 
22197 
22199  // capacity //
22201 
22204 
22207  bool empty() const noexcept
22208  {
22209  switch (m_data.m_type)
22210  {
22211  case value_t::null:
22212  {
22213  // null values are empty
22214  return true;
22215  }
22216 
22217  case value_t::array:
22218  {
22219  // delegate call to array_t::empty()
22220  return m_data.m_value.array->empty();
22221  }
22222 
22223  case value_t::object:
22224  {
22225  // delegate call to object_t::empty()
22226  return m_data.m_value.object->empty();
22227  }
22228 
22229  case value_t::string:
22230  case value_t::boolean:
22231  case value_t::number_integer:
22232  case value_t::number_unsigned:
22233  case value_t::number_float:
22234  case value_t::binary:
22235  case value_t::discarded:
22236  default:
22237  {
22238  // all other types are nonempty
22239  return false;
22240  }
22241  }
22242  }
22243 
22246  size_type size() const noexcept
22247  {
22248  switch (m_data.m_type)
22249  {
22250  case value_t::null:
22251  {
22252  // null values are empty
22253  return 0;
22254  }
22255 
22256  case value_t::array:
22257  {
22258  // delegate call to array_t::size()
22259  return m_data.m_value.array->size();
22260  }
22261 
22262  case value_t::object:
22263  {
22264  // delegate call to object_t::size()
22265  return m_data.m_value.object->size();
22266  }
22267 
22268  case value_t::string:
22269  case value_t::boolean:
22270  case value_t::number_integer:
22271  case value_t::number_unsigned:
22272  case value_t::number_float:
22273  case value_t::binary:
22274  case value_t::discarded:
22275  default:
22276  {
22277  // all other types have size 1
22278  return 1;
22279  }
22280  }
22281  }
22282 
22285  size_type max_size() const noexcept
22286  {
22287  switch (m_data.m_type)
22288  {
22289  case value_t::array:
22290  {
22291  // delegate call to array_t::max_size()
22292  return m_data.m_value.array->max_size();
22293  }
22294 
22295  case value_t::object:
22296  {
22297  // delegate call to object_t::max_size()
22298  return m_data.m_value.object->max_size();
22299  }
22300 
22301  case value_t::null:
22302  case value_t::string:
22303  case value_t::boolean:
22304  case value_t::number_integer:
22305  case value_t::number_unsigned:
22306  case value_t::number_float:
22307  case value_t::binary:
22308  case value_t::discarded:
22309  default:
22310  {
22311  // all other types have max_size() == size()
22312  return size();
22313  }
22314  }
22315  }
22316 
22318 
22320  // modifiers //
22322 
22325 
22328  void clear() noexcept
22329  {
22330  switch (m_data.m_type)
22331  {
22332  case value_t::number_integer:
22333  {
22334  m_data.m_value.number_integer = 0;
22335  break;
22336  }
22337 
22338  case value_t::number_unsigned:
22339  {
22340  m_data.m_value.number_unsigned = 0;
22341  break;
22342  }
22343 
22344  case value_t::number_float:
22345  {
22346  m_data.m_value.number_float = 0.0;
22347  break;
22348  }
22349 
22350  case value_t::boolean:
22351  {
22352  m_data.m_value.boolean = false;
22353  break;
22354  }
22355 
22356  case value_t::string:
22357  {
22358  m_data.m_value.string->clear();
22359  break;
22360  }
22361 
22362  case value_t::binary:
22363  {
22364  m_data.m_value.binary->clear();
22365  break;
22366  }
22367 
22368  case value_t::array:
22369  {
22370  m_data.m_value.array->clear();
22371  break;
22372  }
22373 
22374  case value_t::object:
22375  {
22376  m_data.m_value.object->clear();
22377  break;
22378  }
22379 
22380  case value_t::null:
22381  case value_t::discarded:
22382  default:
22383  break;
22384  }
22385  }
22386 
22389  void push_back(basic_json&& val)
22390  {
22391  // push_back only works for null objects or arrays
22392  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
22393  {
22394  JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
22395  }
22396 
22397  // transform null object into an array
22398  if (is_null())
22399  {
22400  m_data.m_type = value_t::array;
22401  m_data.m_value = value_t::array;
22402  assert_invariant();
22403  }
22404 
22405  // add element to array (move semantics)
22406  const auto old_capacity = m_data.m_value.array->capacity();
22407  m_data.m_value.array->push_back(std::move(val));
22408  set_parent(m_data.m_value.array->back(), old_capacity);
22409  // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
22410  }
22411 
22414  reference operator+=(basic_json&& val)
22415  {
22416  push_back(std::move(val));
22417  return *this;
22418  }
22419 
22422  void push_back(const basic_json& val)
22423  {
22424  // push_back only works for null objects or arrays
22425  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
22426  {
22427  JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
22428  }
22429 
22430  // transform null object into an array
22431  if (is_null())
22432  {
22433  m_data.m_type = value_t::array;
22434  m_data.m_value = value_t::array;
22435  assert_invariant();
22436  }
22437 
22438  // add element to array
22439  const auto old_capacity = m_data.m_value.array->capacity();
22440  m_data.m_value.array->push_back(val);
22441  set_parent(m_data.m_value.array->back(), old_capacity);
22442  }
22443 
22446  reference operator+=(const basic_json& val)
22447  {
22448  push_back(val);
22449  return *this;
22450  }
22451 
22454  void push_back(const typename object_t::value_type& val)
22455  {
22456  // push_back only works for null objects or objects
22457  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
22458  {
22459  JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
22460  }
22461 
22462  // transform null object into an object
22463  if (is_null())
22464  {
22465  m_data.m_type = value_t::object;
22466  m_data.m_value = value_t::object;
22467  assert_invariant();
22468  }
22469 
22470  // add element to object
22471  auto res = m_data.m_value.object->insert(val);
22472  set_parent(res.first->second);
22473  }
22474 
22477  reference operator+=(const typename object_t::value_type& val)
22478  {
22479  push_back(val);
22480  return *this;
22481  }
22482 
22485  void push_back(initializer_list_t init)
22486  {
22487  if (is_object() && init.size() == 2 && (*init.begin())->is_string())
22488  {
22489  basic_json&& key = init.begin()->moved_or_copied();
22490  push_back(typename object_t::value_type(
22491  std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
22492  }
22493  else
22494  {
22495  push_back(basic_json(init));
22496  }
22497  }
22498 
22501  reference operator+=(initializer_list_t init)
22502  {
22503  push_back(init);
22504  return *this;
22505  }
22506 
22509  template<class... Args>
22510  reference emplace_back(Args&& ... args)
22511  {
22512  // emplace_back only works for null objects or arrays
22513  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
22514  {
22515  JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
22516  }
22517 
22518  // transform null object into an array
22519  if (is_null())
22520  {
22521  m_data.m_type = value_t::array;
22522  m_data.m_value = value_t::array;
22523  assert_invariant();
22524  }
22525 
22526  // add element to array (perfect forwarding)
22527  const auto old_capacity = m_data.m_value.array->capacity();
22528  m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
22529  return set_parent(m_data.m_value.array->back(), old_capacity);
22530  }
22531 
22534  template<class... Args>
22535  std::pair<iterator, bool> emplace(Args&& ... args)
22536  {
22537  // emplace only works for null objects or arrays
22538  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
22539  {
22540  JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
22541  }
22542 
22543  // transform null object into an object
22544  if (is_null())
22545  {
22546  m_data.m_type = value_t::object;
22547  m_data.m_value = value_t::object;
22548  assert_invariant();
22549  }
22550 
22551  // add element to array (perfect forwarding)
22552  auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
22553  set_parent(res.first->second);
22554 
22555  // create result iterator and set iterator to the result of emplace
22556  auto it = begin();
22557  it.m_it.object_iterator = res.first;
22558 
22559  // return pair of iterator and boolean
22560  return { it, res.second };
22561  }
22562 
22566  template<typename... Args>
22567  iterator insert_iterator(const_iterator pos, Args&& ... args)
22568  {
22569  iterator result(this);
22570  JSON_ASSERT(m_data.m_value.array != nullptr);
22571 
22572  auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
22573  m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
22574  result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
22575 
22576  // This could have been written as:
22577  // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
22578  // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
22579 
22580  set_parents();
22581  return result;
22582  }
22583 
22586  iterator insert(const_iterator pos, const basic_json& val)
22587  {
22588  // insert only works for arrays
22589  if (JSON_HEDLEY_LIKELY(is_array()))
22590  {
22591  // check if iterator pos fits to this JSON value
22592  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22593  {
22594  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
22595  }
22596 
22597  // insert to array and return iterator
22598  return insert_iterator(pos, val);
22599  }
22600 
22601  JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
22602  }
22603 
22606  iterator insert(const_iterator pos, basic_json&& val)
22607  {
22608  return insert(pos, val);
22609  }
22610 
22613  iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
22614  {
22615  // insert only works for arrays
22616  if (JSON_HEDLEY_LIKELY(is_array()))
22617  {
22618  // check if iterator pos fits to this JSON value
22619  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22620  {
22621  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
22622  }
22623 
22624  // insert to array and return iterator
22625  return insert_iterator(pos, cnt, val);
22626  }
22627 
22628  JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
22629  }
22630 
22633  iterator insert(const_iterator pos, const_iterator first, const_iterator last)
22634  {
22635  // insert only works for arrays
22636  if (JSON_HEDLEY_UNLIKELY(!is_array()))
22637  {
22638  JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
22639  }
22640 
22641  // check if iterator pos fits to this JSON value
22642  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22643  {
22644  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
22645  }
22646 
22647  // check if range iterators belong to the same JSON object
22648  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22649  {
22650  JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
22651  }
22652 
22653  if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
22654  {
22655  JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
22656  }
22657 
22658  // insert to array and return iterator
22659  return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
22660  }
22661 
22664  iterator insert(const_iterator pos, initializer_list_t ilist)
22665  {
22666  // insert only works for arrays
22667  if (JSON_HEDLEY_UNLIKELY(!is_array()))
22668  {
22669  JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
22670  }
22671 
22672  // check if iterator pos fits to this JSON value
22673  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22674  {
22675  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
22676  }
22677 
22678  // insert to array and return iterator
22679  return insert_iterator(pos, ilist.begin(), ilist.end());
22680  }
22681 
22684  void insert(const_iterator first, const_iterator last)
22685  {
22686  // insert only works for objects
22687  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22688  {
22689  JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
22690  }
22691 
22692  // check if range iterators belong to the same JSON object
22693  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22694  {
22695  JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
22696  }
22697 
22698  // passed iterators must belong to objects
22699  if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
22700  {
22701  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
22702  }
22703 
22704  m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
22705  }
22706 
22709  void update(const_reference j, bool merge_objects = false)
22710  {
22711  update(j.begin(), j.end(), merge_objects);
22712  }
22713 
22716  void update(const_iterator first, const_iterator last, bool merge_objects = false)
22717  {
22718  // implicitly convert null value to an empty object
22719  if (is_null())
22720  {
22721  m_data.m_type = value_t::object;
22722  m_data.m_value.object = create<object_t>();
22723  assert_invariant();
22724  }
22725 
22726  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22727  {
22728  JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
22729  }
22730 
22731  // check if range iterators belong to the same JSON object
22732  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22733  {
22734  JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
22735  }
22736 
22737  // passed iterators must belong to objects
22738  if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
22739  {
22740  JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
22741  }
22742 
22743  for (auto it = first; it != last; ++it)
22744  {
22745  if (merge_objects && it.value().is_object())
22746  {
22747  auto it2 = m_data.m_value.object->find(it.key());
22748  if (it2 != m_data.m_value.object->end())
22749  {
22750  it2->second.update(it.value(), true);
22751  continue;
22752  }
22753  }
22754  m_data.m_value.object->operator[](it.key()) = it.value();
22755 #if JSON_DIAGNOSTICS
22756  m_data.m_value.object->operator[](it.key()).m_parent = this;
22757 #endif
22758  }
22759  }
22760 
22763  void swap(reference other) noexcept (
22764  std::is_nothrow_move_constructible<value_t>::value&&
22765  std::is_nothrow_move_assignable<value_t>::value&&
22766  std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
22767  std::is_nothrow_move_assignable<json_value>::value
22768  )
22769  {
22770  std::swap(m_data.m_type, other.m_data.m_type);
22771  std::swap(m_data.m_value, other.m_data.m_value);
22772 
22773  set_parents();
22774  other.set_parents();
22775  assert_invariant();
22776  }
22777 
22780  friend void swap(reference left, reference right) noexcept (
22781  std::is_nothrow_move_constructible<value_t>::value&&
22782  std::is_nothrow_move_assignable<value_t>::value&&
22783  std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
22784  std::is_nothrow_move_assignable<json_value>::value
22785  )
22786  {
22787  left.swap(right);
22788  }
22789 
22792  void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
22793  {
22794  // swap only works for arrays
22795  if (JSON_HEDLEY_LIKELY(is_array()))
22796  {
22797  using std::swap;
22798  swap(*(m_data.m_value.array), other);
22799  }
22800  else
22801  {
22802  JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
22803  }
22804  }
22805 
22808  void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
22809  {
22810  // swap only works for objects
22811  if (JSON_HEDLEY_LIKELY(is_object()))
22812  {
22813  using std::swap;
22814  swap(*(m_data.m_value.object), other);
22815  }
22816  else
22817  {
22818  JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
22819  }
22820  }
22821 
22824  void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
22825  {
22826  // swap only works for strings
22827  if (JSON_HEDLEY_LIKELY(is_string()))
22828  {
22829  using std::swap;
22830  swap(*(m_data.m_value.string), other);
22831  }
22832  else
22833  {
22834  JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
22835  }
22836  }
22837 
22840  void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
22841  {
22842  // swap only works for strings
22843  if (JSON_HEDLEY_LIKELY(is_binary()))
22844  {
22845  using std::swap;
22846  swap(*(m_data.m_value.binary), other);
22847  }
22848  else
22849  {
22850  JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
22851  }
22852  }
22853 
22856  void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
22857  {
22858  // swap only works for strings
22859  if (JSON_HEDLEY_LIKELY(is_binary()))
22860  {
22861  using std::swap;
22862  swap(*(m_data.m_value.binary), other);
22863  }
22864  else
22865  {
22866  JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
22867  }
22868  }
22869 
22871 
22873  // lexicographical comparison operators //
22875 
22878 
22879  // note parentheses around operands are necessary; see
22880  // https://github.com/nlohmann/json/issues/1530
22881 #define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result) \
22882  const auto lhs_type = lhs.type(); \
22883  const auto rhs_type = rhs.type(); \
22884  \
22885  if (lhs_type == rhs_type) /* NOLINT(readability/braces) */ \
22886  { \
22887  switch (lhs_type) \
22888  { \
22889  case value_t::array: \
22890  return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array); \
22891  \
22892  case value_t::object: \
22893  return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object); \
22894  \
22895  case value_t::null: \
22896  return (null_result); \
22897  \
22898  case value_t::string: \
22899  return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string); \
22900  \
22901  case value_t::boolean: \
22902  return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean); \
22903  \
22904  case value_t::number_integer: \
22905  return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer); \
22906  \
22907  case value_t::number_unsigned: \
22908  return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned); \
22909  \
22910  case value_t::number_float: \
22911  return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float); \
22912  \
22913  case value_t::binary: \
22914  return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary); \
22915  \
22916  case value_t::discarded: \
22917  default: \
22918  return (unordered_result); \
22919  } \
22920  } \
22921  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float) \
22922  { \
22923  return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float; \
22924  } \
22925  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer) \
22926  { \
22927  return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer); \
22928  } \
22929  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float) \
22930  { \
22931  return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float; \
22932  } \
22933  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned) \
22934  { \
22935  return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned); \
22936  } \
22937  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer) \
22938  { \
22939  return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
22940  } \
22941  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned) \
22942  { \
22943  return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
22944  } \
22945  else if(compares_unordered(lhs, rhs))\
22946  {\
22947  return (unordered_result);\
22948  }\
22949  \
22950  return (default_result);
22951 
22952 JSON_PRIVATE_UNLESS_TESTED:
22953  // returns true if:
22954  // - any operand is NaN and the other operand is of number type
22955  // - any operand is discarded
22956  // in legacy mode, discarded values are considered ordered if
22957  // an operation is computed as an odd number of inverses of others
22958  static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
22959  {
22960  if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
22961  || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
22962  {
22963  return true;
22964  }
22965 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
22966  return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
22967 #else
22968  static_cast<void>(inverse);
22969  return lhs.is_discarded() || rhs.is_discarded();
22970 #endif
22971  }
22972 
22973 private:
22974  bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
22975  {
22976  return compares_unordered(*this, rhs, inverse);
22977  }
22978 
22979 public:
22980 #if JSON_HAS_THREE_WAY_COMPARISON
22983  bool operator==(const_reference rhs) const noexcept
22984  {
22985 #ifdef __GNUC__
22986 #pragma GCC diagnostic push
22987 #pragma GCC diagnostic ignored "-Wfloat-equal"
22988 #endif
22989  const_reference lhs = *this;
22990  JSON_IMPLEMENT_OPERATOR(== , true, false, false)
22991 #ifdef __GNUC__
22992 #pragma GCC diagnostic pop
22993 #endif
22994  }
22995 
22998  template<typename ScalarType>
22999  requires std::is_scalar_v<ScalarType>
23000  bool operator==(ScalarType rhs) const noexcept
23001  {
23002  return *this == basic_json(rhs);
23003  }
23004 
23007  bool operator!=(const_reference rhs) const noexcept
23008  {
23009  if (compares_unordered(rhs, true))
23010  {
23011  return false;
23012  }
23013  return !operator==(rhs);
23014  }
23015 
23018  std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
23019  {
23020  const_reference lhs = *this;
23021  // default_result is used if we cannot compare values. In that case,
23022  // we compare types.
23023  JSON_IMPLEMENT_OPERATOR(<=> , // *NOPAD*
23024  std::partial_ordering::equivalent,
23025  std::partial_ordering::unordered,
23026  lhs_type <=> rhs_type) // *NOPAD*
23027  }
23028 
23031  template<typename ScalarType>
23032  requires std::is_scalar_v<ScalarType>
23033  std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
23034  {
23035  return *this <=> basic_json(rhs); // *NOPAD*
23036  }
23037 
23038 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
23039  // all operators that are computed as an odd number of inverses of others
23040  // need to be overloaded to emulate the legacy comparison behavior
23041 
23044  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
23045  bool operator<=(const_reference rhs) const noexcept
23046  {
23047  if (compares_unordered(rhs, true))
23048  {
23049  return false;
23050  }
23051  return !(rhs < *this);
23052  }
23053 
23056  template<typename ScalarType>
23057  requires std::is_scalar_v<ScalarType>
23058  bool operator<=(ScalarType rhs) const noexcept
23059  {
23060  return *this <= basic_json(rhs);
23061  }
23062 
23065  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
23066  bool operator>=(const_reference rhs) const noexcept
23067  {
23068  if (compares_unordered(rhs, true))
23069  {
23070  return false;
23071  }
23072  return !(*this < rhs);
23073  }
23074 
23077  template<typename ScalarType>
23078  requires std::is_scalar_v<ScalarType>
23079  bool operator>=(ScalarType rhs) const noexcept
23080  {
23081  return *this >= basic_json(rhs);
23082  }
23083 #endif
23084 #else
23087  friend bool operator==(const_reference lhs, const_reference rhs) noexcept
23088  {
23089 #ifdef __GNUC__
23090 #pragma GCC diagnostic push
23091 #pragma GCC diagnostic ignored "-Wfloat-equal"
23092 #endif
23093  JSON_IMPLEMENT_OPERATOR(== , true, false, false)
23094 #ifdef __GNUC__
23095 #pragma GCC diagnostic pop
23096 #endif
23097  }
23098 
23101  template<typename ScalarType, typename std::enable_if<
23102  std::is_scalar<ScalarType>::value, int>::type = 0>
23103  friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
23104  {
23105  return lhs == basic_json(rhs);
23106  }
23107 
23110  template<typename ScalarType, typename std::enable_if<
23111  std::is_scalar<ScalarType>::value, int>::type = 0>
23112  friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
23113  {
23114  return basic_json(lhs) == rhs;
23115  }
23116 
23119  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
23120  {
23121  if (compares_unordered(lhs, rhs, true))
23122  {
23123  return false;
23124  }
23125  return !(lhs == rhs);
23126  }
23127 
23130  template<typename ScalarType, typename std::enable_if<
23131  std::is_scalar<ScalarType>::value, int>::type = 0>
23132  friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
23133  {
23134  return lhs != basic_json(rhs);
23135  }
23136 
23139  template<typename ScalarType, typename std::enable_if<
23140  std::is_scalar<ScalarType>::value, int>::type = 0>
23141  friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
23142  {
23143  return basic_json(lhs) != rhs;
23144  }
23145 
23148  friend bool operator<(const_reference lhs, const_reference rhs) noexcept
23149  {
23150  // default_result is used if we cannot compare values. In that case,
23151  // we compare types. Note we have to call the operator explicitly,
23152  // because MSVC has problems otherwise.
23153  JSON_IMPLEMENT_OPERATOR(< , false, false, operator<(lhs_type, rhs_type))
23154  }
23155 
23158  template<typename ScalarType, typename std::enable_if<
23159  std::is_scalar<ScalarType>::value, int>::type = 0>
23160  friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
23161  {
23162  return lhs < basic_json(rhs);
23163  }
23164 
23167  template<typename ScalarType, typename std::enable_if<
23168  std::is_scalar<ScalarType>::value, int>::type = 0>
23169  friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
23170  {
23171  return basic_json(lhs) < rhs;
23172  }
23173 
23176  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
23177  {
23178  if (compares_unordered(lhs, rhs, true))
23179  {
23180  return false;
23181  }
23182  return !(rhs < lhs);
23183  }
23184 
23187  template<typename ScalarType, typename std::enable_if<
23188  std::is_scalar<ScalarType>::value, int>::type = 0>
23189  friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
23190  {
23191  return lhs <= basic_json(rhs);
23192  }
23193 
23196  template<typename ScalarType, typename std::enable_if<
23197  std::is_scalar<ScalarType>::value, int>::type = 0>
23198  friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
23199  {
23200  return basic_json(lhs) <= rhs;
23201  }
23202 
23205  friend bool operator>(const_reference lhs, const_reference rhs) noexcept
23206  {
23207  // double inverse
23208  if (compares_unordered(lhs, rhs))
23209  {
23210  return false;
23211  }
23212  return !(lhs <= rhs);
23213  }
23214 
23217  template<typename ScalarType, typename std::enable_if<
23218  std::is_scalar<ScalarType>::value, int>::type = 0>
23219  friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
23220  {
23221  return lhs > basic_json(rhs);
23222  }
23223 
23226  template<typename ScalarType, typename std::enable_if<
23227  std::is_scalar<ScalarType>::value, int>::type = 0>
23228  friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
23229  {
23230  return basic_json(lhs) > rhs;
23231  }
23232 
23235  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
23236  {
23237  if (compares_unordered(lhs, rhs, true))
23238  {
23239  return false;
23240  }
23241  return !(lhs < rhs);
23242  }
23243 
23246  template<typename ScalarType, typename std::enable_if<
23247  std::is_scalar<ScalarType>::value, int>::type = 0>
23248  friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
23249  {
23250  return lhs >= basic_json(rhs);
23251  }
23252 
23255  template<typename ScalarType, typename std::enable_if<
23256  std::is_scalar<ScalarType>::value, int>::type = 0>
23257  friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
23258  {
23259  return basic_json(lhs) >= rhs;
23260  }
23261 #endif
23262 
23263 #undef JSON_IMPLEMENT_OPERATOR
23264 
23266 
23268  // serialization //
23270 
23273 #ifndef JSON_NO_IO
23276  friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
23277  {
23278  // read width member and use it as indentation parameter if nonzero
23279  const bool pretty_print = o.width() > 0;
23280  const auto indentation = pretty_print ? o.width() : 0;
23281 
23282  // reset width to 0 for subsequent calls to this stream
23283  o.width(0);
23284 
23285  // do the actual serialization
23286  serializer s(detail::output_adapter<char>(o), o.fill());
23287  s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
23288  return o;
23289  }
23290 
23297  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
23298  friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
23299  {
23300  return o << j;
23301  }
23302 #endif // JSON_NO_IO
23304 
23306  // deserialization //
23308 
23311 
23314  template<typename InputType>
23315  JSON_HEDLEY_WARN_UNUSED_RESULT
23316  static basic_json parse(InputType&& i,
23317  const parser_callback_t cb = nullptr,
23318  const bool allow_exceptions = true,
23319  const bool ignore_comments = false)
23320  {
23321  basic_json result;
23322  parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
23323  return result;
23324  }
23325 
23328  template<typename IteratorType>
23329  JSON_HEDLEY_WARN_UNUSED_RESULT
23330  static basic_json parse(IteratorType first,
23331  IteratorType last,
23332  const parser_callback_t cb = nullptr,
23333  const bool allow_exceptions = true,
23334  const bool ignore_comments = false)
23335  {
23336  basic_json result;
23337  parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
23338  return result;
23339  }
23340 
23341  JSON_HEDLEY_WARN_UNUSED_RESULT
23342  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
23343  static basic_json parse(detail::span_input_adapter&& i,
23344  const parser_callback_t cb = nullptr,
23345  const bool allow_exceptions = true,
23346  const bool ignore_comments = false)
23347  {
23348  basic_json result;
23349  parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
23350  return result;
23351  }
23352 
23355  template<typename InputType>
23356  static bool accept(InputType&& i,
23357  const bool ignore_comments = false)
23358  {
23359  return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
23360  }
23361 
23364  template<typename IteratorType>
23365  static bool accept(IteratorType first, IteratorType last,
23366  const bool ignore_comments = false)
23367  {
23368  return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
23369  }
23370 
23371  JSON_HEDLEY_WARN_UNUSED_RESULT
23372  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
23373  static bool accept(detail::span_input_adapter&& i,
23374  const bool ignore_comments = false)
23375  {
23376  return parser(i.get(), nullptr, false, ignore_comments).accept(true);
23377  }
23378 
23381  template <typename InputType, typename SAX>
23382  JSON_HEDLEY_NON_NULL(2)
23383  static bool sax_parse(InputType&& i, SAX* sax,
23384  input_format_t format = input_format_t::json,
23385  const bool strict = true,
23386  const bool ignore_comments = false)
23387  {
23388  auto ia = detail::input_adapter(std::forward<InputType>(i));
23389  return format == input_format_t::json
23390  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23391  : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
23392  }
23393 
23396  template<class IteratorType, class SAX>
23397  JSON_HEDLEY_NON_NULL(3)
23398  static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
23399  input_format_t format = input_format_t::json,
23400  const bool strict = true,
23401  const bool ignore_comments = false)
23402  {
23403  auto ia = detail::input_adapter(std::move(first), std::move(last));
23404  return format == input_format_t::json
23405  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23406  : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
23407  }
23408 
23414  template <typename SAX>
23415  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
23416  JSON_HEDLEY_NON_NULL(2)
23417  static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
23418  input_format_t format = input_format_t::json,
23419  const bool strict = true,
23420  const bool ignore_comments = false)
23421  {
23422  auto ia = i.get();
23423  return format == input_format_t::json
23424  // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23425  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23426  // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23427  : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
23428  }
23429 #ifndef JSON_NO_IO
23436  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
23437  friend std::istream& operator<<(basic_json& j, std::istream& i)
23438  {
23439  return operator>>(i, j);
23440  }
23441 
23444  friend std::istream& operator>>(std::istream& i, basic_json& j)
23445  {
23446  parser(detail::input_adapter(i)).parse(false, j);
23447  return i;
23448  }
23449 #endif // JSON_NO_IO
23451 
23453  // convenience functions //
23455 
23458  JSON_HEDLEY_RETURNS_NON_NULL
23459  const char* type_name() const noexcept
23460  {
23461  switch (m_data.m_type)
23462  {
23463  case value_t::null:
23464  return "null";
23465  case value_t::object:
23466  return "object";
23467  case value_t::array:
23468  return "array";
23469  case value_t::string:
23470  return "string";
23471  case value_t::boolean:
23472  return "boolean";
23473  case value_t::binary:
23474  return "binary";
23475  case value_t::discarded:
23476  return "discarded";
23477  case value_t::number_integer:
23478  case value_t::number_unsigned:
23479  case value_t::number_float:
23480  default:
23481  return "number";
23482  }
23483  }
23484 
23485 JSON_PRIVATE_UNLESS_TESTED:
23487  // member variables //
23489 
23490  struct data
23491  {
23493  value_t m_type = value_t::null;
23494 
23496  json_value m_value = {};
23497 
23498  data(const value_t v)
23499  : m_type(v), m_value(v)
23500  {
23501  }
23502 
23503  data(size_type cnt, const basic_json& val)
23504  : m_type(value_t::array)
23505  {
23506  m_value.array = create<array_t>(cnt, val);
23507  }
23508 
23509  data() noexcept = default;
23510  data(data&&) noexcept = default;
23511  data(const data&) noexcept = delete;
23512  data& operator=(data&&) noexcept = delete;
23513  data& operator=(const data&) noexcept = delete;
23514 
23515  ~data() noexcept
23516  {
23517  m_value.destroy(m_type);
23518  }
23519  };
23520 
23521  data m_data = {};
23522 
23523 #if JSON_DIAGNOSTICS
23525  basic_json* m_parent = nullptr;
23526 #endif
23527 
23529  // binary serialization/deserialization //
23531 
23534 
23535 public:
23538  static std::vector<std::uint8_t> to_cbor(const basic_json& j)
23539  {
23540  std::vector<std::uint8_t> result;
23541  to_cbor(j, result);
23542  return result;
23543  }
23544 
23547  static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23548  {
23549  binary_writer<std::uint8_t>(o).write_cbor(j);
23550  }
23551 
23554  static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
23555  {
23556  binary_writer<char>(o).write_cbor(j);
23557  }
23558 
23561  static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
23562  {
23563  std::vector<std::uint8_t> result;
23564  to_msgpack(j, result);
23565  return result;
23566  }
23567 
23570  static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23571  {
23572  binary_writer<std::uint8_t>(o).write_msgpack(j);
23573  }
23574 
23577  static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
23578  {
23579  binary_writer<char>(o).write_msgpack(j);
23580  }
23581 
23584  static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
23585  const bool use_size = false,
23586  const bool use_type = false)
23587  {
23588  std::vector<std::uint8_t> result;
23589  to_ubjson(j, result, use_size, use_type);
23590  return result;
23591  }
23592 
23595  static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
23596  const bool use_size = false, const bool use_type = false)
23597  {
23598  binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
23599  }
23600 
23603  static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
23604  const bool use_size = false, const bool use_type = false)
23605  {
23606  binary_writer<char>(o).write_ubjson(j, use_size, use_type);
23607  }
23608 
23611  static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
23612  const bool use_size = false,
23613  const bool use_type = false)
23614  {
23615  std::vector<std::uint8_t> result;
23616  to_bjdata(j, result, use_size, use_type);
23617  return result;
23618  }
23619 
23622  static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
23623  const bool use_size = false, const bool use_type = false)
23624  {
23625  binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
23626  }
23627 
23630  static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
23631  const bool use_size = false, const bool use_type = false)
23632  {
23633  binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
23634  }
23635 
23638  static std::vector<std::uint8_t> to_bson(const basic_json& j)
23639  {
23640  std::vector<std::uint8_t> result;
23641  to_bson(j, result);
23642  return result;
23643  }
23644 
23647  static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23648  {
23649  binary_writer<std::uint8_t>(o).write_bson(j);
23650  }
23651 
23654  static void to_bson(const basic_json& j, detail::output_adapter<char> o)
23655  {
23656  binary_writer<char>(o).write_bson(j);
23657  }
23658 
23661  template<typename InputType>
23662  JSON_HEDLEY_WARN_UNUSED_RESULT
23663  static basic_json from_cbor(InputType&& i,
23664  const bool strict = true,
23665  const bool allow_exceptions = true,
23666  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23667  {
23668  basic_json result;
23669  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23670  auto ia = detail::input_adapter(std::forward<InputType>(i));
23671  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23672  return res ? result : basic_json(value_t::discarded);
23673  }
23674 
23677  template<typename IteratorType>
23678  JSON_HEDLEY_WARN_UNUSED_RESULT
23679  static basic_json from_cbor(IteratorType first, IteratorType last,
23680  const bool strict = true,
23681  const bool allow_exceptions = true,
23682  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23683  {
23684  basic_json result;
23685  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23686  auto ia = detail::input_adapter(std::move(first), std::move(last));
23687  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23688  return res ? result : basic_json(value_t::discarded);
23689  }
23690 
23691  template<typename T>
23692  JSON_HEDLEY_WARN_UNUSED_RESULT
23693  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
23694  static basic_json from_cbor(const T* ptr, std::size_t len,
23695  const bool strict = true,
23696  const bool allow_exceptions = true,
23697  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23698  {
23699  return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
23700  }
23701 
23702  JSON_HEDLEY_WARN_UNUSED_RESULT
23703  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
23704  static basic_json from_cbor(detail::span_input_adapter&& i,
23705  const bool strict = true,
23706  const bool allow_exceptions = true,
23707  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23708  {
23709  basic_json result;
23710  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23711  auto ia = i.get();
23712  // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23713  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23714  return res ? result : basic_json(value_t::discarded);
23715  }
23716 
23719  template<typename InputType>
23720  JSON_HEDLEY_WARN_UNUSED_RESULT
23721  static basic_json from_msgpack(InputType&& i,
23722  const bool strict = true,
23723  const bool allow_exceptions = true)
23724  {
23725  basic_json result;
23726  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23727  auto ia = detail::input_adapter(std::forward<InputType>(i));
23728  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23729  return res ? result : basic_json(value_t::discarded);
23730  }
23731 
23734  template<typename IteratorType>
23735  JSON_HEDLEY_WARN_UNUSED_RESULT
23736  static basic_json from_msgpack(IteratorType first, IteratorType last,
23737  const bool strict = true,
23738  const bool allow_exceptions = true)
23739  {
23740  basic_json result;
23741  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23742  auto ia = detail::input_adapter(std::move(first), std::move(last));
23743  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23744  return res ? result : basic_json(value_t::discarded);
23745  }
23746 
23747  template<typename T>
23748  JSON_HEDLEY_WARN_UNUSED_RESULT
23749  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
23750  static basic_json from_msgpack(const T* ptr, std::size_t len,
23751  const bool strict = true,
23752  const bool allow_exceptions = true)
23753  {
23754  return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
23755  }
23756 
23757  JSON_HEDLEY_WARN_UNUSED_RESULT
23758  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
23759  static basic_json from_msgpack(detail::span_input_adapter&& i,
23760  const bool strict = true,
23761  const bool allow_exceptions = true)
23762  {
23763  basic_json result;
23764  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23765  auto ia = i.get();
23766  // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23767  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23768  return res ? result : basic_json(value_t::discarded);
23769  }
23770 
23773  template<typename InputType>
23774  JSON_HEDLEY_WARN_UNUSED_RESULT
23775  static basic_json from_ubjson(InputType&& i,
23776  const bool strict = true,
23777  const bool allow_exceptions = true)
23778  {
23779  basic_json result;
23780  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23781  auto ia = detail::input_adapter(std::forward<InputType>(i));
23782  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23783  return res ? result : basic_json(value_t::discarded);
23784  }
23785 
23788  template<typename IteratorType>
23789  JSON_HEDLEY_WARN_UNUSED_RESULT
23790  static basic_json from_ubjson(IteratorType first, IteratorType last,
23791  const bool strict = true,
23792  const bool allow_exceptions = true)
23793  {
23794  basic_json result;
23795  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23796  auto ia = detail::input_adapter(std::move(first), std::move(last));
23797  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23798  return res ? result : basic_json(value_t::discarded);
23799  }
23800 
23801  template<typename T>
23802  JSON_HEDLEY_WARN_UNUSED_RESULT
23803  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
23804  static basic_json from_ubjson(const T* ptr, std::size_t len,
23805  const bool strict = true,
23806  const bool allow_exceptions = true)
23807  {
23808  return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
23809  }
23810 
23811  JSON_HEDLEY_WARN_UNUSED_RESULT
23812  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
23813  static basic_json from_ubjson(detail::span_input_adapter&& i,
23814  const bool strict = true,
23815  const bool allow_exceptions = true)
23816  {
23817  basic_json result;
23818  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23819  auto ia = i.get();
23820  // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23821  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23822  return res ? result : basic_json(value_t::discarded);
23823  }
23824 
23827  template<typename InputType>
23828  JSON_HEDLEY_WARN_UNUSED_RESULT
23829  static basic_json from_bjdata(InputType&& i,
23830  const bool strict = true,
23831  const bool allow_exceptions = true)
23832  {
23833  basic_json result;
23834  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23835  auto ia = detail::input_adapter(std::forward<InputType>(i));
23836  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
23837  return res ? result : basic_json(value_t::discarded);
23838  }
23839 
23842  template<typename IteratorType>
23843  JSON_HEDLEY_WARN_UNUSED_RESULT
23844  static basic_json from_bjdata(IteratorType first, IteratorType last,
23845  const bool strict = true,
23846  const bool allow_exceptions = true)
23847  {
23848  basic_json result;
23849  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23850  auto ia = detail::input_adapter(std::move(first), std::move(last));
23851  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
23852  return res ? result : basic_json(value_t::discarded);
23853  }
23854 
23857  template<typename InputType>
23858  JSON_HEDLEY_WARN_UNUSED_RESULT
23859  static basic_json from_bson(InputType&& i,
23860  const bool strict = true,
23861  const bool allow_exceptions = true)
23862  {
23863  basic_json result;
23864  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23865  auto ia = detail::input_adapter(std::forward<InputType>(i));
23866  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23867  return res ? result : basic_json(value_t::discarded);
23868  }
23869 
23872  template<typename IteratorType>
23873  JSON_HEDLEY_WARN_UNUSED_RESULT
23874  static basic_json from_bson(IteratorType first, IteratorType last,
23875  const bool strict = true,
23876  const bool allow_exceptions = true)
23877  {
23878  basic_json result;
23879  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23880  auto ia = detail::input_adapter(std::move(first), std::move(last));
23881  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23882  return res ? result : basic_json(value_t::discarded);
23883  }
23884 
23885  template<typename T>
23886  JSON_HEDLEY_WARN_UNUSED_RESULT
23887  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
23888  static basic_json from_bson(const T* ptr, std::size_t len,
23889  const bool strict = true,
23890  const bool allow_exceptions = true)
23891  {
23892  return from_bson(ptr, ptr + len, strict, allow_exceptions);
23893  }
23894 
23895  JSON_HEDLEY_WARN_UNUSED_RESULT
23896  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
23897  static basic_json from_bson(detail::span_input_adapter&& i,
23898  const bool strict = true,
23899  const bool allow_exceptions = true)
23900  {
23901  basic_json result;
23902  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23903  auto ia = i.get();
23904  // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23905  const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23906  return res ? result : basic_json(value_t::discarded);
23907  }
23909 
23911  // JSON Pointer support //
23913 
23916 
23919  reference operator[](const json_pointer& ptr)
23920  {
23921  return ptr.get_unchecked(this);
23922  }
23923 
23924  template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
23925  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
23926  reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
23927  {
23928  return ptr.get_unchecked(this);
23929  }
23930 
23933  const_reference operator[](const json_pointer& ptr) const
23934  {
23935  return ptr.get_unchecked(this);
23936  }
23937 
23938  template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
23939  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
23940  const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
23941  {
23942  return ptr.get_unchecked(this);
23943  }
23944 
23947  reference at(const json_pointer& ptr)
23948  {
23949  return ptr.get_checked(this);
23950  }
23951 
23952  template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
23953  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
23954  reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
23955  {
23956  return ptr.get_checked(this);
23957  }
23958 
23961  const_reference at(const json_pointer& ptr) const
23962  {
23963  return ptr.get_checked(this);
23964  }
23965 
23966  template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
23967  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
23968  const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
23969  {
23970  return ptr.get_checked(this);
23971  }
23972 
23975  basic_json flatten() const
23976  {
23977  basic_json result(value_t::object);
23978  json_pointer::flatten("", *this, result);
23979  return result;
23980  }
23981 
23984  basic_json unflatten() const
23985  {
23986  return json_pointer::unflatten(*this);
23987  }
23988 
23990 
23992  // JSON Patch functions //
23994 
23997 
24000  void patch_inplace(const basic_json& json_patch)
24001  {
24002  basic_json& result = *this;
24003  // the valid JSON Patch operations
24004  enum class patch_operations { add, remove, replace, move, copy, test, invalid };
24005 
24006  const auto get_op = [](const std::string& op)
24007  {
24008  if (op == "add")
24009  {
24010  return patch_operations::add;
24011  }
24012  if (op == "remove")
24013  {
24014  return patch_operations::remove;
24015  }
24016  if (op == "replace")
24017  {
24018  return patch_operations::replace;
24019  }
24020  if (op == "move")
24021  {
24022  return patch_operations::move;
24023  }
24024  if (op == "copy")
24025  {
24026  return patch_operations::copy;
24027  }
24028  if (op == "test")
24029  {
24030  return patch_operations::test;
24031  }
24032 
24033  return patch_operations::invalid;
24034  };
24035 
24036  // wrapper for "add" operation; add value at ptr
24037  const auto operation_add = [&result](json_pointer& ptr, basic_json val)
24038  {
24039  // adding to the root of the target document means replacing it
24040  if (ptr.empty())
24041  {
24042  result = val;
24043  return;
24044  }
24045 
24046  // make sure the top element of the pointer exists
24047  json_pointer const top_pointer = ptr.top();
24048  if (top_pointer != ptr)
24049  {
24050  result.at(top_pointer);
24051  }
24052 
24053  // get reference to parent of JSON pointer ptr
24054  const auto last_path = ptr.back();
24055  ptr.pop_back();
24056  // parent must exist when performing patch add per RFC6902 specs
24057  basic_json& parent = result.at(ptr);
24058 
24059  switch (parent.m_data.m_type)
24060  {
24061  case value_t::null:
24062  case value_t::object:
24063  {
24064  // use operator[] to add value
24065  parent[last_path] = val;
24066  break;
24067  }
24068 
24069  case value_t::array:
24070  {
24071  if (last_path == "-")
24072  {
24073  // special case: append to back
24074  parent.push_back(val);
24075  }
24076  else
24077  {
24078  const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
24079  if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
24080  {
24081  // avoid undefined behavior
24082  JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
24083  }
24084 
24085  // default case: insert add offset
24086  parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
24087  }
24088  break;
24089  }
24090 
24091  // if there exists a parent it cannot be primitive
24092  case value_t::string: // LCOV_EXCL_LINE
24093  case value_t::boolean: // LCOV_EXCL_LINE
24094  case value_t::number_integer: // LCOV_EXCL_LINE
24095  case value_t::number_unsigned: // LCOV_EXCL_LINE
24096  case value_t::number_float: // LCOV_EXCL_LINE
24097  case value_t::binary: // LCOV_EXCL_LINE
24098  case value_t::discarded: // LCOV_EXCL_LINE
24099  default: // LCOV_EXCL_LINE
24100  JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
24101  }
24102  };
24103 
24104  // wrapper for "remove" operation; remove value at ptr
24105  const auto operation_remove = [this, &result](json_pointer& ptr)
24106  {
24107  // get reference to parent of JSON pointer ptr
24108  const auto last_path = ptr.back();
24109  ptr.pop_back();
24110  basic_json& parent = result.at(ptr);
24111 
24112  // remove child
24113  if (parent.is_object())
24114  {
24115  // perform range check
24116  auto it = parent.find(last_path);
24117  if (JSON_HEDLEY_LIKELY(it != parent.end()))
24118  {
24119  parent.erase(it);
24120  }
24121  else
24122  {
24123  JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
24124  }
24125  }
24126  else if (parent.is_array())
24127  {
24128  // note erase performs range check
24129  parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
24130  }
24131  };
24132 
24133  // type check: top level value must be an array
24134  if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
24135  {
24136  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
24137  }
24138 
24139  // iterate and apply the operations
24140  for (const auto& val : json_patch)
24141  {
24142  // wrapper to get a value for an operation
24143  const auto get_value = [&val](const std::string& op,
24144  const std::string& member,
24145  bool string_type) -> basic_json&
24146  {
24147  // find value
24148  auto it = val.m_data.m_value.object->find(member);
24149 
24150  // context-sensitive error message
24151  const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');
24152 
24153  // check if desired value is present
24154  if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
24155  {
24156  // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
24157  JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
24158  }
24159 
24160  // check if result is of type string
24161  if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
24162  {
24163  // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
24164  JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
24165  }
24166 
24167  // no error: return value
24168  return it->second;
24169  };
24170 
24171  // type check: every element of the array must be an object
24172  if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
24173  {
24174  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
24175  }
24176 
24177  // collect mandatory members
24178  const auto op = get_value("op", "op", true).template get<std::string>();
24179  const auto path = get_value(op, "path", true).template get<std::string>();
24180  json_pointer ptr(path);
24181 
24182  switch (get_op(op))
24183  {
24184  case patch_operations::add:
24185  {
24186  operation_add(ptr, get_value("add", "value", false));
24187  break;
24188  }
24189 
24190  case patch_operations::remove:
24191  {
24192  operation_remove(ptr);
24193  break;
24194  }
24195 
24196  case patch_operations::replace:
24197  {
24198  // the "path" location must exist - use at()
24199  result.at(ptr) = get_value("replace", "value", false);
24200  break;
24201  }
24202 
24203  case patch_operations::move:
24204  {
24205  const auto from_path = get_value("move", "from", true).template get<std::string>();
24206  json_pointer from_ptr(from_path);
24207 
24208  // the "from" location must exist - use at()
24209  basic_json const v = result.at(from_ptr);
24210 
24211  // The move operation is functionally identical to a
24212  // "remove" operation on the "from" location, followed
24213  // immediately by an "add" operation at the target
24214  // location with the value that was just removed.
24215  operation_remove(from_ptr);
24216  operation_add(ptr, v);
24217  break;
24218  }
24219 
24220  case patch_operations::copy:
24221  {
24222  const auto from_path = get_value("copy", "from", true).template get<std::string>();
24223  const json_pointer from_ptr(from_path);
24224 
24225  // the "from" location must exist - use at()
24226  basic_json const v = result.at(from_ptr);
24227 
24228  // The copy is functionally identical to an "add"
24229  // operation at the target location using the value
24230  // specified in the "from" member.
24231  operation_add(ptr, v);
24232  break;
24233  }
24234 
24235  case patch_operations::test:
24236  {
24237  bool success = false;
24238  JSON_TRY
24239  {
24240  // check if "value" matches the one at "path"
24241  // the "path" location must exist - use at()
24242  success = (result.at(ptr) == get_value("test", "value", false));
24243  }
24244  JSON_INTERNAL_CATCH(out_of_range&)
24245  {
24246  // ignore out of range errors: success remains false
24247  }
24248 
24249  // throw an exception if test fails
24250  if (JSON_HEDLEY_UNLIKELY(!success))
24251  {
24252  JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
24253  }
24254 
24255  break;
24256  }
24257 
24258  case patch_operations::invalid:
24259  default:
24260  {
24261  // op must be "add", "remove", "replace", "move", "copy", or
24262  // "test"
24263  JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
24264  }
24265  }
24266  }
24267  }
24268 
24271  basic_json patch(const basic_json& json_patch) const
24272  {
24273  basic_json result = *this;
24274  result.patch_inplace(json_patch);
24275  return result;
24276  }
24277 
24280  JSON_HEDLEY_WARN_UNUSED_RESULT
24281  static basic_json diff(const basic_json& source, const basic_json& target,
24282  const std::string& path = "")
24283  {
24284  // the patch
24285  basic_json result(value_t::array);
24286 
24287  // if the values are the same, return empty patch
24288  if (source == target)
24289  {
24290  return result;
24291  }
24292 
24293  if (source.type() != target.type())
24294  {
24295  // different types: replace value
24296  result.push_back(
24297  {
24298  {"op", "replace"}, {"path", path}, {"value", target}
24299  });
24300  return result;
24301  }
24302 
24303  switch (source.type())
24304  {
24305  case value_t::array:
24306  {
24307  // first pass: traverse common elements
24308  std::size_t i = 0;
24309  while (i < source.size() && i < target.size())
24310  {
24311  // recursive call to compare array values at index i
24312  auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));
24313  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24314  ++i;
24315  }
24316 
24317  // We now reached the end of at least one array
24318  // in a second pass, traverse the remaining elements
24319 
24320  // remove my remaining elements
24321  const auto end_index = static_cast<difference_type>(result.size());
24322  while (i < source.size())
24323  {
24324  // add operations in reverse order to avoid invalid
24325  // indices
24326  result.insert(result.begin() + end_index, object(
24327  {
24328  {"op", "remove"},
24329  {"path", detail::concat(path, '/', std::to_string(i))}
24330  }));
24331  ++i;
24332  }
24333 
24334  // add other remaining elements
24335  while (i < target.size())
24336  {
24337  result.push_back(
24338  {
24339  {"op", "add"},
24340  {"path", detail::concat(path, "/-")},
24341  {"value", target[i]}
24342  });
24343  ++i;
24344  }
24345 
24346  break;
24347  }
24348 
24349  case value_t::object:
24350  {
24351  // first pass: traverse this object's elements
24352  for (auto it = source.cbegin(); it != source.cend(); ++it)
24353  {
24354  // escape the key name to be used in a JSON patch
24355  const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
24356 
24357  if (target.find(it.key()) != target.end())
24358  {
24359  // recursive call to compare object values at key it
24360  auto temp_diff = diff(it.value(), target[it.key()], path_key);
24361  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24362  }
24363  else
24364  {
24365  // found a key that is not in o -> remove it
24366  result.push_back(object(
24367  {
24368  {"op", "remove"}, {"path", path_key}
24369  }));
24370  }
24371  }
24372 
24373  // second pass: traverse other object's elements
24374  for (auto it = target.cbegin(); it != target.cend(); ++it)
24375  {
24376  if (source.find(it.key()) == source.end())
24377  {
24378  // found a key that is not in this -> add it
24379  const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
24380  result.push_back(
24381  {
24382  {"op", "add"}, {"path", path_key},
24383  {"value", it.value()}
24384  });
24385  }
24386  }
24387 
24388  break;
24389  }
24390 
24391  case value_t::null:
24392  case value_t::string:
24393  case value_t::boolean:
24394  case value_t::number_integer:
24395  case value_t::number_unsigned:
24396  case value_t::number_float:
24397  case value_t::binary:
24398  case value_t::discarded:
24399  default:
24400  {
24401  // both primitive type: replace value
24402  result.push_back(
24403  {
24404  {"op", "replace"}, {"path", path}, {"value", target}
24405  });
24406  break;
24407  }
24408  }
24409 
24410  return result;
24411  }
24413 
24415  // JSON Merge Patch functions //
24417 
24420 
24423  void merge_patch(const basic_json& apply_patch)
24424  {
24425  if (apply_patch.is_object())
24426  {
24427  if (!is_object())
24428  {
24429  *this = object();
24430  }
24431  for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
24432  {
24433  if (it.value().is_null())
24434  {
24435  erase(it.key());
24436  }
24437  else
24438  {
24439  operator[](it.key()).merge_patch(it.value());
24440  }
24441  }
24442  }
24443  else
24444  {
24445  *this = apply_patch;
24446  }
24447  }
24448 
24450 };
24451 
24454 NLOHMANN_BASIC_JSON_TPL_DECLARATION
24455 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
24456 {
24457  return j.dump();
24458 }
24459 
24460 inline namespace literals
24461 {
24462  inline namespace json_literals
24463  {
24464 
24467  JSON_HEDLEY_NON_NULL(1)
24468 #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
24469  inline nlohmann::json operator ""_json(const char* s, std::size_t n)
24470 #else
24471  inline nlohmann::json operator "" _json(const char* s, std::size_t n)
24472 #endif
24473  {
24474  return nlohmann::json::parse(s, s + n);
24475  }
24476 
24479  JSON_HEDLEY_NON_NULL(1)
24480 #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
24481  inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
24482 #else
24483  inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
24484 #endif
24485  {
24486  return nlohmann::json::json_pointer(std::string(s, n));
24487  }
24488 
24489  } // namespace json_literals
24490 } // namespace literals
24491 NLOHMANN_JSON_NAMESPACE_END
24492 
24494 // nonmember support //
24496 
24497 namespace std // NOLINT(cert-dcl58-cpp)
24498 {
24499 
24502  NLOHMANN_BASIC_JSON_TPL_DECLARATION
24503  struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
24504  {
24505  std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
24506  {
24507  return nlohmann::detail::hash(j);
24508  }
24509  };
24510 
24511  // specialization for std::less<value_t>
24512  template<>
24513  struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
24514  {
24519  bool operator()(::nlohmann::detail::value_t lhs,
24520  ::nlohmann::detail::value_t rhs) const noexcept
24521  {
24522 #if JSON_HAS_THREE_WAY_COMPARISON
24523  return std::is_lt(lhs <=> rhs); // *NOPAD*
24524 #else
24525  return ::nlohmann::detail::operator<(lhs, rhs);
24526 #endif
24527  }
24528  };
24529 
24530  // C++20 prohibit function specialization in the std namespace.
24531 #ifndef JSON_HAS_CPP_20
24532 
24535  NLOHMANN_BASIC_JSON_TPL_DECLARATION
24536  inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept( // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
24537  is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&& // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
24538  is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
24539  {
24540  j1.swap(j2);
24541  }
24542 
24543 #endif
24544 
24545 } // namespace std
24546 
24547 #if JSON_USE_GLOBAL_UDLS
24548 #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
24549 using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
24550 using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
24551 #else
24552 using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
24553 using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
24554 #endif
24555 #endif
24556 
24557 // #include <nlohmann/detail/macro_unscope.hpp>
24558 // __ _____ _____ _____
24559 // __| | __| | | | JSON for Modern C++
24560 // | | |__ | | | | | | version 3.11.3
24561 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
24562 //
24563 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
24564 // SPDX-License-Identifier: MIT
24565 
24566 
24567 
24568 // restore clang diagnostic settings
24569 #if defined(__clang__)
24570 #pragma clang diagnostic pop
24571 #endif
24572 
24573 // clean up
24574 #undef JSON_ASSERT
24575 #undef JSON_INTERNAL_CATCH
24576 #undef JSON_THROW
24577 #undef JSON_PRIVATE_UNLESS_TESTED
24578 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
24579 #undef NLOHMANN_BASIC_JSON_TPL
24580 #undef JSON_EXPLICIT
24581 #undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
24582 #undef JSON_INLINE_VARIABLE
24583 #undef JSON_NO_UNIQUE_ADDRESS
24584 #undef JSON_DISABLE_ENUM_SERIALIZATION
24585 #undef JSON_USE_GLOBAL_UDLS
24586 
24587 #ifndef JSON_TEST_KEEP_MACROS
24588 #undef JSON_CATCH
24589 #undef JSON_TRY
24590 #undef JSON_HAS_CPP_11
24591 #undef JSON_HAS_CPP_14
24592 #undef JSON_HAS_CPP_17
24593 #undef JSON_HAS_CPP_20
24594 #undef JSON_HAS_FILESYSTEM
24595 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
24596 #undef JSON_HAS_THREE_WAY_COMPARISON
24597 #undef JSON_HAS_RANGES
24598 #undef JSON_HAS_STATIC_RTTI
24599 #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
24600 #endif
24601 
24602 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
24603 // __ _____ _____ _____
24604 // __| | __| | | | JSON for Modern C++
24605 // | | |__ | | | | | | version 3.11.3
24606 // |_____|_____|_____|_|___| https://github.com/nlohmann/json
24607 //
24608 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
24609 // SPDX-License-Identifier: MIT
24610 
24611 
24612 
24613 #undef JSON_HEDLEY_ALWAYS_INLINE
24614 #undef JSON_HEDLEY_ARM_VERSION
24615 #undef JSON_HEDLEY_ARM_VERSION_CHECK
24616 #undef JSON_HEDLEY_ARRAY_PARAM
24617 #undef JSON_HEDLEY_ASSUME
24618 #undef JSON_HEDLEY_BEGIN_C_DECLS
24619 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
24620 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
24621 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
24622 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
24623 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
24624 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
24625 #undef JSON_HEDLEY_CLANG_HAS_WARNING
24626 #undef JSON_HEDLEY_COMPCERT_VERSION
24627 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
24628 #undef JSON_HEDLEY_CONCAT
24629 #undef JSON_HEDLEY_CONCAT3
24630 #undef JSON_HEDLEY_CONCAT3_EX
24631 #undef JSON_HEDLEY_CONCAT_EX
24632 #undef JSON_HEDLEY_CONST
24633 #undef JSON_HEDLEY_CONSTEXPR
24634 #undef JSON_HEDLEY_CONST_CAST
24635 #undef JSON_HEDLEY_CPP_CAST
24636 #undef JSON_HEDLEY_CRAY_VERSION
24637 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
24638 #undef JSON_HEDLEY_C_DECL
24639 #undef JSON_HEDLEY_DEPRECATED
24640 #undef JSON_HEDLEY_DEPRECATED_FOR
24641 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
24642 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
24643 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
24644 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
24645 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
24646 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
24647 #undef JSON_HEDLEY_DIAGNOSTIC_POP
24648 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
24649 #undef JSON_HEDLEY_DMC_VERSION
24650 #undef JSON_HEDLEY_DMC_VERSION_CHECK
24651 #undef JSON_HEDLEY_EMPTY_BASES
24652 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
24653 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
24654 #undef JSON_HEDLEY_END_C_DECLS
24655 #undef JSON_HEDLEY_FLAGS
24656 #undef JSON_HEDLEY_FLAGS_CAST
24657 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
24658 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
24659 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
24660 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
24661 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
24662 #undef JSON_HEDLEY_GCC_HAS_FEATURE
24663 #undef JSON_HEDLEY_GCC_HAS_WARNING
24664 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
24665 #undef JSON_HEDLEY_GCC_VERSION
24666 #undef JSON_HEDLEY_GCC_VERSION_CHECK
24667 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
24668 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
24669 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
24670 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
24671 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
24672 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
24673 #undef JSON_HEDLEY_GNUC_HAS_WARNING
24674 #undef JSON_HEDLEY_GNUC_VERSION
24675 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
24676 #undef JSON_HEDLEY_HAS_ATTRIBUTE
24677 #undef JSON_HEDLEY_HAS_BUILTIN
24678 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
24679 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
24680 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
24681 #undef JSON_HEDLEY_HAS_EXTENSION
24682 #undef JSON_HEDLEY_HAS_FEATURE
24683 #undef JSON_HEDLEY_HAS_WARNING
24684 #undef JSON_HEDLEY_IAR_VERSION
24685 #undef JSON_HEDLEY_IAR_VERSION_CHECK
24686 #undef JSON_HEDLEY_IBM_VERSION
24687 #undef JSON_HEDLEY_IBM_VERSION_CHECK
24688 #undef JSON_HEDLEY_IMPORT
24689 #undef JSON_HEDLEY_INLINE
24690 #undef JSON_HEDLEY_INTEL_CL_VERSION
24691 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
24692 #undef JSON_HEDLEY_INTEL_VERSION
24693 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
24694 #undef JSON_HEDLEY_IS_CONSTANT
24695 #undef JSON_HEDLEY_IS_CONSTEXPR_
24696 #undef JSON_HEDLEY_LIKELY
24697 #undef JSON_HEDLEY_MALLOC
24698 #undef JSON_HEDLEY_MCST_LCC_VERSION
24699 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
24700 #undef JSON_HEDLEY_MESSAGE
24701 #undef JSON_HEDLEY_MSVC_VERSION
24702 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
24703 #undef JSON_HEDLEY_NEVER_INLINE
24704 #undef JSON_HEDLEY_NON_NULL
24705 #undef JSON_HEDLEY_NO_ESCAPE
24706 #undef JSON_HEDLEY_NO_RETURN
24707 #undef JSON_HEDLEY_NO_THROW
24708 #undef JSON_HEDLEY_NULL
24709 #undef JSON_HEDLEY_PELLES_VERSION
24710 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
24711 #undef JSON_HEDLEY_PGI_VERSION
24712 #undef JSON_HEDLEY_PGI_VERSION_CHECK
24713 #undef JSON_HEDLEY_PREDICT
24714 #undef JSON_HEDLEY_PRINTF_FORMAT
24715 #undef JSON_HEDLEY_PRIVATE
24716 #undef JSON_HEDLEY_PUBLIC
24717 #undef JSON_HEDLEY_PURE
24718 #undef JSON_HEDLEY_REINTERPRET_CAST
24719 #undef JSON_HEDLEY_REQUIRE
24720 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
24721 #undef JSON_HEDLEY_REQUIRE_MSG
24722 #undef JSON_HEDLEY_RESTRICT
24723 #undef JSON_HEDLEY_RETURNS_NON_NULL
24724 #undef JSON_HEDLEY_SENTINEL
24725 #undef JSON_HEDLEY_STATIC_ASSERT
24726 #undef JSON_HEDLEY_STATIC_CAST
24727 #undef JSON_HEDLEY_STRINGIFY
24728 #undef JSON_HEDLEY_STRINGIFY_EX
24729 #undef JSON_HEDLEY_SUNPRO_VERSION
24730 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
24731 #undef JSON_HEDLEY_TINYC_VERSION
24732 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
24733 #undef JSON_HEDLEY_TI_ARMCL_VERSION
24734 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
24735 #undef JSON_HEDLEY_TI_CL2000_VERSION
24736 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
24737 #undef JSON_HEDLEY_TI_CL430_VERSION
24738 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
24739 #undef JSON_HEDLEY_TI_CL6X_VERSION
24740 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
24741 #undef JSON_HEDLEY_TI_CL7X_VERSION
24742 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
24743 #undef JSON_HEDLEY_TI_CLPRU_VERSION
24744 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
24745 #undef JSON_HEDLEY_TI_VERSION
24746 #undef JSON_HEDLEY_TI_VERSION_CHECK
24747 #undef JSON_HEDLEY_UNAVAILABLE
24748 #undef JSON_HEDLEY_UNLIKELY
24749 #undef JSON_HEDLEY_UNPREDICTABLE
24750 #undef JSON_HEDLEY_UNREACHABLE
24751 #undef JSON_HEDLEY_UNREACHABLE_RETURN
24752 #undef JSON_HEDLEY_VERSION
24753 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
24754 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
24755 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
24756 #undef JSON_HEDLEY_VERSION_ENCODE
24757 #undef JSON_HEDLEY_WARNING
24758 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
24759 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
24760 #undef JSON_HEDLEY_FALL_THROUGH
24761 
24762 
24763 
24764 #endif // INCLUDE_NLOHMANN_JSON_HPP_
basic_json
namespace for Niels Lohmann
Definition: json.hpp:19400
basic_json::is_string
constexpr bool is_string() const noexcept
return whether value is a string
Definition: json.hpp:20672
basic_json::get_to
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
Definition: json.hpp:21099
basic_json::erase
size_type erase(const typename object_t::key_type &key)
remove element from a JSON object given a key
Definition: json.hpp:21905
basic_json::operator[]
reference operator[](KeyType &&key)
access specified object element
Definition: json.hpp:21473
basic_json::from_cbor
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
create a JSON value from an input in CBOR format
Definition: json.hpp:23679
basic_json::get
auto get() const noexcept(noexcept(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))) -> decltype(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))
get a (pointer) value (explicit)
Definition: json.hpp:21045
basic_json::back
reference back()
access the last element
Definition: json.hpp:21709
basic_json::basic_json
basic_json(CompatibleType &&val) noexcept(noexcept(//NOLINT(bugprone-forwarding-reference-overload, bugprone-exception-escape) JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
create a JSON value from compatible types
Definition: json.hpp:20136
basic_json::patch
basic_json patch(const basic_json &json_patch) const
applies a JSON patch to a copy of the current object
Definition: json.hpp:24271
basic_json::front
const_reference front() const
access the first element
Definition: json.hpp:21702
basic_json::JSON_HEDLEY_DEPRECATED_FOR
JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) const _reference operator[](const
access specified element via JSON Pointer
Definition: json.hpp:23939
basic_json::is_array
constexpr bool is_array() const noexcept
return whether value is an array
Definition: json.hpp:20665
basic_json::swap
void swap(reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&//NOLINT(cppcoreguidelines-noexcept-swap, performance-noexcept-swap) std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
Definition: json.hpp:22763
basic_json::value
ReturnType value(const json_pointer &ptr, ValueType &&default_value) const
access specified object element via JSON Pointer with default value
Definition: json.hpp:21653
basic_json::count
size_type count(KeyType &&key) const
returns the number of occurrences of a key in a JSON object
Definition: json.hpp:22022
basic_json::const_iterator
iter_impl< const basic_json > const_iterator
a const iterator for a basic_json container
Definition: json.hpp:19531
basic_json::to_bjdata
static void to_bjdata(const basic_json &j, detail::output_adapter< char > o, const bool use_size=false, const bool use_type=false)
create a BJData serialization of a given JSON value
Definition: json.hpp:23630
basic_json::initializer_list_t
std::initializer_list< detail::json_ref< basic_json > > initializer_list_t
helper type for initializer lists of basic_json values
Definition: json.hpp:19475
basic_json::is_number_integer
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
Definition: json.hpp:20637
basic_json::const_reverse_iterator
json_reverse_iterator< typename basic_json::const_iterator > const_reverse_iterator
a const reverse iterator for a basic_json container
Definition: json.hpp:19535
basic_json::data
data(size_type cnt, const basic_json &val)
Definition: json.hpp:23503
basic_json::from_bson
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in BSON format
Definition: json.hpp:23874
basic_json::to_bjdata
static void to_bjdata(const basic_json &j, detail::output_adapter< std::uint8_t > o, const bool use_size=false, const bool use_type=false)
create a BJData serialization of a given JSON value
Definition: json.hpp:23622
basic_json::operator[]
reference operator[](const json_pointer &ptr)
access specified element via JSON Pointer
Definition: json.hpp:23919
basic_json::const_pointer
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
Definition: json.hpp:19526
basic_json::JSON_HEDLEY_DEPRECATED_FOR
JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) reference at(const
Definition: json.hpp:23953
basic_json::size_type
std::size_t size_type
a type to represent container sizes
Definition: json.hpp:19518
basic_json::is_structured
constexpr bool is_structured() const noexcept
return whether type is structured
Definition: json.hpp:20609
basic_json::operator[]
const_reference operator[](KeyType &&key) const
access specified object element
Definition: json.hpp:21497
basic_json::const_reference
const value_type & const_reference
the type of an element const reference
Definition: json.hpp:19513
basic_json::swap
void swap(binary_t &other)
exchanges the values
Definition: json.hpp:22840
basic_json::get_ref
ReferenceType get_ref()
get a reference value (implicit)
Definition: json.hpp:21135
basic_json::update
void update(const_reference j, bool merge_objects=false)
updates a JSON object from another object, overwriting existing keys
Definition: json.hpp:22709
basic_json::get_ref
ReferenceType get_ref() const
get a reference value (implicit)
Definition: json.hpp:21146
basic_json::is_discarded
constexpr bool is_discarded() const noexcept
return whether value is discarded
Definition: json.hpp:20686
basic_json::rhs
JSON_PRIVATE_UNLESS_TESTED const_reference rhs
Definition: json.hpp:22958
basic_json::operator+=
reference operator+=(initializer_list_t init)
add an object to an object
Definition: json.hpp:22501
basic_json::JSON_HEDLEY_DEPRECATED_FOR
JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) ValueType value(const
access the first element
Definition: json.hpp:21676
basic_json::operator[]
const_reference operator[](const typename object_t::key_type &key) const
access specified object element
Definition: json.hpp:21442
basic_json::back
const_reference back() const
access the last element
Definition: json.hpp:21718
basic_json::erase
IteratorType erase(IteratorType first, IteratorType last)
remove elements given an iterator range
Definition: json.hpp:21800
basic_json::operator+=
reference operator+=(const basic_json &val)
add an object to an array
Definition: json.hpp:22446
basic_json::swap
friend void swap(reference left, reference right) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&//NOLINT(cppcoreguidelines-noexcept-swap, performance-noexcept-swap) std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
Definition: json.hpp:22780
basic_json::from_ubjson
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in UBJSON format
Definition: json.hpp:23775
basic_json::binary
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init, typename binary_t::subtype_type subtype)
explicitly create a binary array (with subtype)
Definition: json.hpp:20273
basic_json::insert
iterator insert(const_iterator pos, size_type cnt, const basic_json &val)
inserts copies of element into array
Definition: json.hpp:22613
basic_json::get_binary
const binary_t & get_binary() const
get a binary value
Definition: json.hpp:21217
basic_json::from_bson
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in BSON format
Definition: json.hpp:23859
basic_json::get_allocator
static allocator_type get_allocator()
returns the allocator associated with the container
Definition: json.hpp:19541
basic_json::binary_t
nlohmann::byte_container_with_subtype< BinaryType > binary_t
a type for a packed binary type
Definition: json.hpp:19666
basic_json::at
reference at(KeyType &&key)
access specified object element with bounds checking
Definition: json.hpp:21305
basic_json::is_number_unsigned
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
Definition: json.hpp:20644
basic_json::update
void update(const_iterator first, const_iterator last, bool merge_objects=false)
updates a JSON object from another object, overwriting existing keys
Definition: json.hpp:22716
basic_json::m_data
data m_data
Definition: json.hpp:23521
basic_json::push_back
void push_back(initializer_list_t init)
add an object to an object
Definition: json.hpp:22485
basic_json::parser_callback_t
detail::parser_callback_t< basic_json > parser_callback_t
per-element parser callback type
Definition: json.hpp:20103
basic_json::object
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json object(initializer_list_t init={})
explicitly create an object from an initializer list
Definition: json.hpp:20314
basic_json::to_msgpack
static void to_msgpack(const basic_json &j, detail::output_adapter< char > o)
create a MessagePack serialization of a given JSON value
Definition: json.hpp:23577
basic_json::inverse
JSON_PRIVATE_UNLESS_TESTED const_reference bool inverse
Definition: json.hpp:22958
basic_json::value
ReturnType value(const typename object_t::key_type &key, ValueType &&default_value) const
access specified object element with default value
Definition: json.hpp:21552
basic_json::from_bjdata
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bjdata(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in BJData format
Definition: json.hpp:23829
basic_json::at
const_reference at(const json_pointer &ptr) const
access specified element via JSON Pointer
Definition: json.hpp:23961
basic_json::binary
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init)
explicitly create a binary array
Definition: json.hpp:20284
basic_json::basic_json
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
Definition: json.hpp:20124
basic_json::from_cbor
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(InputType &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
create a JSON value from an input in CBOR format
Definition: json.hpp:23663
basic_json::from_ubjson
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in UBJSON format
Definition: json.hpp:23790
basic_json::erase
size_type erase(KeyType &&key)
remove element from a JSON object given a key
Definition: json.hpp:21916
basic_json::operator<<
friend std::istream & operator<<(basic_json &j, std::istream &i)
deserialize from stream
Definition: json.hpp:23437
basic_json::insert
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
inserts range of elements into array
Definition: json.hpp:22633
basic_json::value
ReturnType value(KeyType &&key, ValueType &&default_value) const
access specified object element via JSON Pointer with default value
Definition: json.hpp:21605
basic_json::diff
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json diff(const basic_json &source, const basic_json &target, const std::string &path="")
creates a diff as a JSON patch
Definition: json.hpp:24281
basic_json::operator[]
const_reference operator[](const json_pointer &ptr) const
access specified element via JSON Pointer
Definition: json.hpp:23933
basic_json::array_t
ArrayType< basic_json, AllocatorType< basic_json > > array_t
a type for an array
Definition: json.hpp:19642
basic_json::reference
value_type & reference
the type of an element reference
Definition: json.hpp:19511
basic_json::contains
bool contains(KeyType &&key) const
check the existence of an element in a JSON object
Definition: json.hpp:22039
basic_json::to_cbor
static void to_cbor(const basic_json &j, detail::output_adapter< std::uint8_t > o)
create a CBOR serialization of a given JSON value
Definition: json.hpp:23547
basic_json::to_bson
static void to_bson(const basic_json &j, detail::output_adapter< char > o)
create a BSON serialization of a given JSON value
Definition: json.hpp:23654
basic_json::find
iterator find(const typename object_t::key_type &key)
find an element in a JSON object
Definition: json.hpp:21952
basic_json::binary
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init)
explicitly create a binary array (without subtype)
Definition: json.hpp:20262
basic_json::at
const_reference at(KeyType &&key) const
access specified object element with bounds checking
Definition: json.hpp:21343
basic_json::meta
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json meta()
returns version information on the library
Definition: json.hpp:19549
basic_json::basic_json
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
Definition: json.hpp:20321
basic_json::find
const_iterator find(const typename object_t::key_type &key) const
find an element in a JSON object
Definition: json.hpp:21966
basic_json::erase
IteratorType erase(IteratorType pos)
remove element given an iterator
Definition: json.hpp:21730
basic_json::insert
iterator insert(const_iterator pos, const basic_json &val)
inserts element into array
Definition: json.hpp:22586
basic_json::number_float_t
NumberFloatType number_float_t
a type for a number (floating-point)
Definition: json.hpp:19662
basic_json::value
ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const
access specified object element with default value
Definition: json.hpp:21527
basic_json::get_to
ValueType & get_to(ValueType &v) const
Definition: json.hpp:21112
basic_json::allocator_type
AllocatorType< basic_json > allocator_type
the allocator type
Definition: json.hpp:19521
basic_json::pointer
typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
Definition: json.hpp:19524
basic_json::dump
string_t dump(const int indent=-1, const char indent_char=' ', const bool ensure_ascii=false, const error_handler_t error_handler=error_handler_t::strict) const
serialization
Definition: json.hpp:20573
basic_json::merge_patch
void merge_patch(const basic_json &apply_patch)
applies a JSON Merge Patch
Definition: json.hpp:24423
basic_json::operator[]
reference operator[](T *key)
Definition: json.hpp:21458
basic_json::at
reference at(size_type idx)
access specified array element with bounds checking
Definition: json.hpp:21239
basic_json::find
iterator find(KeyType &&key)
find an element in a JSON object
Definition: json.hpp:21982
basic_json::is_number_float
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
Definition: json.hpp:20651
basic_json::boolean_t
BooleanType boolean_t
a type for a boolean
Definition: json.hpp:19650
basic_json::value_t
detail::value_t value_t
Definition: json.hpp:19465
basic_json::default_object_comparator_t
std::less< StringType > default_object_comparator_t
default object key comparator type The actual object key comparator type (object_comparator_t) may be...
Definition: json.hpp:19629
basic_json::operator+=
reference operator+=(const typename object_t::value_type &val)
add an object to an object
Definition: json.hpp:22477
basic_json::to_cbor
static std::vector< std::uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
Definition: json.hpp:23538
basic_json::operator[]
reference operator[](typename object_t::key_type key)
access specified object element
Definition: json.hpp:21420
basic_json::get_ptr
constexpr auto get_ptr() const noexcept -> decltype(std::declval< const basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
Definition: json.hpp:20857
basic_json::~basic_json
~basic_json() noexcept
destructor
Definition: json.hpp:20555
basic_json::out_of_range
detail::out_of_range out_of_range
Definition: json.hpp:19493
basic_json::basic_json
basic_json(initializer_list_t init, bool type_deduction=true, value_t manual_type=value_t::array)
create a container (array or object) from an initializer list
Definition: json.hpp:20203
basic_json::swap
void swap(typename binary_t::container_type &other)
exchanges the values
Definition: json.hpp:22856
basic_json::is_number
constexpr bool is_number() const noexcept
return whether value is a number
Definition: json.hpp:20630
basic_json::operator>>
friend std::istream & operator>>(std::istream &i, basic_json &j)
deserialize from stream
Definition: json.hpp:23444
basic_json::insert
void insert(const_iterator first, const_iterator last)
inserts range of elements into object
Definition: json.hpp:22684
basic_json::operator=
basic_json & operator=(basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value &&std::is_nothrow_move_assignable< json_base_class_t >::value)
copy assignment
Definition: json.hpp:20532
basic_json::from_msgpack
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in MessagePack format
Definition: json.hpp:23721
basic_json::get
auto get() noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
Definition: json.hpp:21086
basic_json::operator[]
const_reference operator[](T *key) const
Definition: json.hpp:21464
basic_json::data
data(const value_t v)
Definition: json.hpp:23498
basic_json::operator[]
reference operator[](size_type idx)
access specified array element
Definition: json.hpp:21361
basic_json::basic_json
basic_json(const JsonRef &ref)
Definition: json.hpp:20442
basic_json::json_serializer
JSONSerializer< T, SFINAE > json_serializer
Definition: json.hpp:19469
basic_json::to_ubjson
static void to_ubjson(const basic_json &j, detail::output_adapter< char > o, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
Definition: json.hpp:23603
basic_json::get_to
Array get_to(T(&v)[N]) const noexcept(noexcept(JSONSerializer< Array >::from_json(std::declval< const basic_json_t & >(), v)))
Definition: json.hpp:21123
basic_json::number_integer_t
NumberIntegerType number_integer_t
a type for a number (integer)
Definition: json.hpp:19654
basic_json::get_ptr
auto get_ptr() noexcept -> decltype(std::declval< basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
Definition: json.hpp:20846
basic_json::at
const_reference at(const typename object_t::key_type &key) const
access specified object element with bounds checking
Definition: json.hpp:21323
basic_json::is_binary
constexpr bool is_binary() const noexcept
return whether value is a binary array
Definition: json.hpp:20679
basic_json::swap
void swap(object_t &other)
exchanges the values
Definition: json.hpp:22808
basic_json::insert
iterator insert(const_iterator pos, initializer_list_t ilist)
inserts elements from initializer list into array
Definition: json.hpp:22664
basic_json::binary
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init, typename binary_t::subtype_type subtype)
explicitly create a binary array (with subtype)
Definition: json.hpp:20295
basic_json::swap
void swap(array_t &other)
exchanges the values
Definition: json.hpp:22792
basic_json::erase
void erase(const size_type idx)
remove element from a JSON array given an index
Definition: json.hpp:21923
basic_json::emplace
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
Definition: json.hpp:22535
basic_json::operator+=
reference operator+=(basic_json &&val)
add an object to an array
Definition: json.hpp:22414
basic_json::contains
bool contains(const json_pointer &ptr) const
check the existence of an element in a JSON object given a JSON pointer
Definition: json.hpp:22046
basic_json::get_binary
binary_t & get_binary()
get a binary value
Definition: json.hpp:21205
basic_json::type
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
Definition: json.hpp:20595
basic_json::emplace_back
reference emplace_back(Args &&... args)
add an object to an array
Definition: json.hpp:22510
basic_json::value
ValueType value(const json_pointer &ptr, const ValueType &default_value) const
access specified object element via JSON Pointer with default value
Definition: json.hpp:21628
basic_json::array
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json array(initializer_list_t init={})
explicitly create an array from an initializer list
Definition: json.hpp:20306
basic_json::data
data() noexcept=default
basic_json::string_t
StringType string_t
a type for a string
Definition: json.hpp:19646
basic_json::object_t
ObjectType< StringType, basic_json, default_object_comparator_t, AllocatorType< std::pair< const StringType, basic_json > >> object_t
a type for an object
Definition: json.hpp:19638
basic_json::push_back
void push_back(const basic_json &val)
add an object to an array
Definition: json.hpp:22422
basic_json::value
ValueType value(KeyType &&key, const ValueType &default_value) const
access specified object element with default value
Definition: json.hpp:21578
basic_json::at
reference at(const typename object_t::key_type &key)
access specified object element with bounds checking
Definition: json.hpp:21285
basic_json::from_bjdata
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bjdata(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in BJData format
Definition: json.hpp:23844
basic_json::m_value
json_value m_value
the value of the current element
Definition: json.hpp:23496
basic_json::is_boolean
constexpr bool is_boolean() const noexcept
return whether value is a boolean
Definition: json.hpp:20623
basic_json::count
size_type count(const typename object_t::key_type &key) const
returns the number of occurrences of a key in a JSON object
Definition: json.hpp:22012
basic_json::to_msgpack
static std::vector< std::uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
Definition: json.hpp:23561
basic_json::is_primitive
constexpr bool is_primitive() const noexcept
return whether type is primitive
Definition: json.hpp:20602
basic_json::is_null
constexpr bool is_null() const noexcept
return whether value is null
Definition: json.hpp:20616
basic_json::to_ubjson
static void to_ubjson(const basic_json &j, detail::output_adapter< std::uint8_t > o, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
Definition: json.hpp:23595
basic_json::sax_parse
JSON_PRIVATE_UNLESS_TESTED const_reference bool static SAX bool sax_parse(InputType &&i, SAX *sax, input_format_t format=input_format_t::json, const bool strict=true, const bool ignore_comments=false)
Definition: json.hpp:23383
basic_json::to_bson
static std::vector< std::uint8_t > to_bson(const basic_json &j)
create a BSON serialization of a given JSON value
Definition: json.hpp:23638
basic_json::basic_json
basic_json(basic_json &&other) noexcept
move constructor
Definition: json.hpp:20515
basic_json::iterator
iter_impl< basic_json > iterator
an iterator for a basic_json container
Definition: json.hpp:19529
basic_json::basic_json
basic_json(const value_t v)
create an empty value with a given type
Definition: json.hpp:20116
basic_json::operator[]
const_reference operator[](size_type idx) const
access specified array element
Definition: json.hpp:21407
basic_json::difference_type
std::ptrdiff_t difference_type
a type to represent differences between iterators
Definition: json.hpp:19516
basic_json::insert
iterator insert(const_iterator pos, basic_json &&val)
inserts element into array
Definition: json.hpp:22606
basic_json::number_unsigned_t
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
Definition: json.hpp:19658
basic_json::swap
void swap(string_t &other)
exchanges the values
Definition: json.hpp:22824
basic_json::basic_json
basic_json(const BasicJsonType &val)
create a JSON value from an existing one
Definition: json.hpp:20150
basic_json::reverse_iterator
json_reverse_iterator< typename basic_json::iterator > reverse_iterator
a reverse iterator for a basic_json container
Definition: json.hpp:19533
basic_json::at
const_reference at(size_type idx) const
access specified array element with bounds checking
Definition: json.hpp:21262
basic_json::object_comparator_t
detail::actual_object_comparator_t< basic_json > object_comparator_t
object key comparator type
Definition: json.hpp:19670
basic_json::basic_json
basic_json(const basic_json &other)
copy constructor
Definition: json.hpp:20446
basic_json::push_back
void push_back(const typename object_t::value_type &val)
add an object to an object
Definition: json.hpp:22454
basic_json::to_cbor
static void to_cbor(const basic_json &j, detail::output_adapter< char > o)
create a CBOR serialization of a given JSON value
Definition: json.hpp:23554
basic_json::is_object
constexpr bool is_object() const noexcept
return whether value is an object
Definition: json.hpp:20658
basic_json::to_bjdata
static std::vector< std::uint8_t > to_bjdata(const basic_json &j, const bool use_size=false, const bool use_type=false)
create a BJData serialization of a given JSON value
Definition: json.hpp:23611
basic_json::to_msgpack
static void to_msgpack(const basic_json &j, detail::output_adapter< std::uint8_t > o)
create a MessagePack serialization of a given JSON value
Definition: json.hpp:23570
basic_json::from_msgpack
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in MessagePack format
Definition: json.hpp:23736
basic_json::insert_iterator
iterator insert_iterator(const_iterator pos, Args &&... args)
Definition: json.hpp:22567
basic_json::basic_json
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
Definition: json.hpp:20333
basic_json::JSON_HEDLEY_DEPRECATED_FOR
JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) reference operator[](const
Definition: json.hpp:23925
basic_json::to_ubjson
static std::vector< std::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:23584
basic_json::type_name
JSON_HEDLEY_RETURNS_NON_NULL const char * type_name() const noexcept
return the type as string
Definition: json.hpp:23459
basic_json::contains
bool contains(const typename object_t::key_type &key) const
check the existence of an element in a JSON object
Definition: json.hpp:22030
basic_json::to_bson
static void to_bson(const basic_json &j, detail::output_adapter< std::uint8_t > o)
create a BSON serialization of a given JSON value
Definition: json.hpp:23647
basic_json::find
const_iterator find(KeyType &&key) const
find an element in a JSON object
Definition: json.hpp:21998
basic_json::json_pointer
::nlohmann::json_pointer< StringType > json_pointer
JSON Pointer, see nlohmann::json_pointer.
Definition: json.hpp:19467
byte_container_with_subtype
an internal type for a backed binary type
Definition: json.hpp:5892
byte_container_with_subtype::operator!=
bool operator!=(const byte_container_with_subtype &rhs) const
Definition: json.hpp:5932
byte_container_with_subtype::byte_container_with_subtype
byte_container_with_subtype() noexcept(noexcept(container_type()))
Definition: json.hpp:5898
byte_container_with_subtype::subtype_type
std::uint64_t subtype_type
Definition: json.hpp:5895
byte_container_with_subtype::operator==
bool operator==(const byte_container_with_subtype &rhs) const
Definition: json.hpp:5926
byte_container_with_subtype::container_type
BinaryType container_type
Definition: json.hpp:5894
byte_container_with_subtype::byte_container_with_subtype
byte_container_with_subtype(container_type &&b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
Definition: json.hpp:5920
byte_container_with_subtype::byte_container_with_subtype
byte_container_with_subtype(container_type &&b) noexcept(noexcept(container_type(std::move(b))))
Definition: json.hpp:5908
byte_container_with_subtype::subtype
constexpr subtype_type subtype() const noexcept
return the binary subtype
Definition: json.hpp:5947
byte_container_with_subtype::byte_container_with_subtype
byte_container_with_subtype(const container_type &b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
Definition: json.hpp:5913
byte_container_with_subtype::has_subtype
constexpr bool has_subtype() const noexcept
return whether the value has a subtype
Definition: json.hpp:5954
byte_container_with_subtype::byte_container_with_subtype
byte_container_with_subtype(const container_type &b) noexcept(noexcept(container_type(b)))
Definition: json.hpp:5903
byte_container_with_subtype::set_subtype
void set_subtype(subtype_type subtype_) noexcept
sets the binary subtype
Definition: json.hpp:5939
byte_container_with_subtype::clear_subtype
void clear_subtype() noexcept
clears the binary subtype
Definition: json.hpp:5961
detail::binary_reader
deserialization of CBOR, MessagePack, and UBJSON values
Definition: json.hpp:9212
detail::binary_reader::binary_reader
binary_reader(const binary_reader &)=delete
detail::binary_reader::binary_reader
binary_reader(binary_reader &&)=default
detail::binary_reader::binary_reader
binary_reader(InputAdapterType &&adapter, const input_format_t format=input_format_t::json) noexcept
create a binary reader
Definition: json.hpp:9228
detail::binary_reader::sax_parse
bool sax_parse(const input_format_t format, json_sax_t *sax_, const bool strict=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
Definition: json.hpp:9249
detail::binary_reader::~binary_reader
~binary_reader()=default
detail::binary_reader::operator=
binary_reader & operator=(binary_reader &&)=default
detail::binary_reader::operator=
binary_reader & operator=(const binary_reader &)=delete
detail::binary_writer
serialization to CBOR and MessagePack values
Definition: json.hpp:15078
detail::binary_writer::write_bson
void write_bson(const BasicJsonType &j)
Definition: json.hpp:15098
detail::binary_writer::to_char_type
static constexpr CharType to_char_type(std::uint8_t x) noexcept
Definition: json.hpp:16833
detail::binary_writer::to_char_type
static CharType to_char_type(std::uint8_t x) noexcept
Definition: json.hpp:16840
detail::binary_writer::binary_writer
binary_writer(output_adapter_t< CharType > adapter)
create a binary writer
Definition: json.hpp:15089
detail::binary_writer::to_char_type
static constexpr CharType to_char_type(InputCharType x) noexcept
Definition: json.hpp:16862
detail::binary_writer::write_ubjson
void write_ubjson(const BasicJsonType &j, const bool use_count, const bool use_type, const bool add_prefix=true, const bool use_bjdata=false)
Definition: json.hpp:15777
detail::binary_writer::write_msgpack
void write_msgpack(const BasicJsonType &j)
Definition: json.hpp:15451
detail::binary_writer::write_cbor
void write_cbor(const BasicJsonType &j)
Definition: json.hpp:15127
detail::exception
general exception of the basic_json class
Definition: json.hpp:4373
detail::exception::id
const int id
the id of the exception
Definition: json.hpp:4382
detail::exception::diagnostics
static std::string diagnostics(std::nullptr_t)
Definition: json.hpp:4393
detail::exception::what
const char * what() const noexcept override
returns the explanatory string
Definition: json.hpp:4376
detail::exception::name
static std::string name(const std::string &ename, int id_)
Definition: json.hpp:4388
detail::exception::diagnostics
static std::string diagnostics(const BasicJsonType *leaf_element)
Definition: json.hpp:4399
detail::file_input_adapter
Definition: json.hpp:6189
detail::file_input_adapter::char_type
char char_type
Definition: json.hpp:6191
detail::file_input_adapter::file_input_adapter
file_input_adapter(const file_input_adapter &)=delete
detail::file_input_adapter::file_input_adapter
file_input_adapter(file_input_adapter &&) noexcept=default
detail::file_input_adapter::get_character
std::char_traits< char >::int_type get_character() noexcept
Definition: json.hpp:6207
detail::input_stream_adapter
Definition: json.hpp:6227
detail::input_stream_adapter::input_stream_adapter
input_stream_adapter(input_stream_adapter &&rhs) noexcept
Definition: json.hpp:6250
detail::input_stream_adapter::~input_stream_adapter
~input_stream_adapter()
Definition: json.hpp:6231
detail::input_stream_adapter::char_type
char char_type
Definition: json.hpp:6229
detail::input_stream_adapter::input_stream_adapter
input_stream_adapter(const input_stream_adapter &)=delete
detail::input_stream_adapter::operator=
input_stream_adapter & operator=(input_stream_adapter &)=delete
detail::input_stream_adapter::operator=
input_stream_adapter & operator=(input_stream_adapter &&)=delete
detail::input_stream_adapter::get_character
std::char_traits< char >::int_type get_character()
Definition: json.hpp:6260
detail::input_stream_adapter::input_stream_adapter
input_stream_adapter(std::istream &i)
Definition: json.hpp:6241
detail::invalid_iterator
exception indicating errors with iterators
Definition: json.hpp:4524
detail::invalid_iterator::create
static invalid_iterator create(int id_, const std::string &what_arg, BasicJsonContext context)
Definition: json.hpp:4527
detail::iter_impl
a template for a bidirectional iterator for the basic_json class This class implements a both iterato...
Definition: json.hpp:12915
detail::iter_impl::operator=
iter_impl & operator=(const iter_impl< const BasicJsonType > &other) noexcept
converting assignment
Definition: json.hpp:13027
detail::iter_impl::~iter_impl
~iter_impl()=default
detail::iter_impl::operator+
iter_impl operator+(difference_type i) const
add to iterator
Definition: json.hpp:13489
detail::iter_impl::operator-=
iter_impl & operator-=(difference_type i)
subtract from iterator
Definition: json.hpp:13480
detail::iter_impl::operator+=
iter_impl & operator+=(difference_type i)
add to iterator
Definition: json.hpp:13443
detail::iter_impl::operator>=
bool operator>=(const iter_impl &other) const
comparison: greater than or equal
Definition: json.hpp:13434
detail::iter_impl::iter_impl
iter_impl(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting constructor
Definition: json.hpp:13042
detail::iter_impl::operator<
bool operator<(const iter_impl &other) const
comparison: smaller
Definition: json.hpp:13381
detail::iter_impl::operator<=
bool operator<=(const iter_impl &other) const
comparison: less than or equal
Definition: json.hpp:13416
detail::iter_impl::operator++
iter_impl & operator++()
pre-increment (++it)
Definition: json.hpp:13244
detail::iter_impl::operator==
bool operator==(const IterImpl &other) const
comparison: equal
Definition: json.hpp:13336
detail::iter_impl::operator++
iter_impl operator++(int) &
post-increment (it++)
Definition: json.hpp:13233
detail::iter_impl::operator--
iter_impl & operator--()
pre-decrement (–it)
Definition: json.hpp:13295
detail::iter_impl::operator[]
reference operator[](difference_type n) const
access to successor
Definition: json.hpp:13551
detail::iter_impl::key
const object_t::key_type & key() const
return the key of an object iterator
Definition: json.hpp:13589
detail::iter_impl::difference_type
typename BasicJsonType::difference_type difference_type
a type to represent differences between iterators
Definition: json.hpp:12945
detail::iter_impl::operator->
pointer operator->() const
dereference the iterator
Definition: json.hpp:13191
detail::iter_impl::operator=
iter_impl & operator=(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting assignment
Definition: json.hpp:13052
detail::iter_impl::m_it
internal_iterator< typename std::remove_const< BasicJsonType >::type > m_it
the actual iterator of the associated instance
Definition: json.hpp:13614
detail::iter_impl::operator-
difference_type operator-(const iter_impl &other) const
return difference
Definition: json.hpp:13522
detail::iter_impl::iter_impl
iter_impl(iter_impl &&) noexcept=default
detail::iter_impl::iterator_category
std::bidirectional_iterator_tag iterator_category
Definition: json.hpp:12940
detail::iter_impl::operator+
friend iter_impl operator+(difference_type i, const iter_impl &it)
addition of distance and iterator
Definition: json.hpp:13500
detail::iter_impl::value
reference value() const
return the value of an iterator
Definition: json.hpp:13605
detail::iter_impl::operator>
bool operator>(const iter_impl &other) const
comparison: greater than
Definition: json.hpp:13425
detail::iter_impl::pointer
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_pointer, typename BasicJsonType::pointer >::type pointer
defines a pointer to the type iterated over (value_type)
Definition: json.hpp:12949
detail::iter_impl::value_type
typename BasicJsonType::value_type value_type
the type of the values when the iterator is dereferenced
Definition: json.hpp:12943
detail::iter_impl::operator*
reference operator*() const
return a reference to the value pointed to by the iterator
Definition: json.hpp:13147
detail::iter_impl::operator-
iter_impl operator-(difference_type i) const
subtract from iterator
Definition: json.hpp:13511
detail::iter_impl::iter_impl
iter_impl()=default
detail::iter_impl::operator!=
bool operator!=(const IterImpl &other) const
comparison: not equal
Definition: json.hpp:13372
detail::iter_impl::operator--
iter_impl operator--(int) &
post-decrement (it–)
Definition: json.hpp:13284
detail::iter_impl::reference
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_reference, typename BasicJsonType::reference >::type reference
defines a reference to the type iterated over (value_type)
Definition: json.hpp:12954
detail::iter_impl::iter_impl
iter_impl(const iter_impl< const BasicJsonType > &other) noexcept
const copy constructor
Definition: json.hpp:13017
detail::iter_impl::set_end
void set_end() noexcept
set the iterator past the last value
Definition: json.hpp:13108
detail::iteration_proxy_value
Definition: json.hpp:5187
detail::iteration_proxy_value::operator++
iteration_proxy_value operator++(int) &
Definition: json.hpp:5243
detail::iteration_proxy_value::iteration_proxy_value
iteration_proxy_value(iteration_proxy_value const &)=default
detail::iteration_proxy_value::operator==
bool operator==(const iteration_proxy_value &o) const
equality operator (needed for InputIterator)
Definition: json.hpp:5252
detail::iteration_proxy_value::operator!=
bool operator!=(const iteration_proxy_value &o) const
inequality operator (needed for range-based for)
Definition: json.hpp:5258
detail::iteration_proxy_value::difference_type
std::ptrdiff_t difference_type
Definition: json.hpp:5189
detail::iteration_proxy_value::iteration_proxy_value
iteration_proxy_value(IteratorType it, std::size_t array_index_=0) noexcept(std::is_nothrow_move_constructible< IteratorType >::value &&std::is_nothrow_default_constructible< string_type >::value)
Definition: json.hpp:5210
detail::iteration_proxy_value::iteration_proxy_value
iteration_proxy_value()=default
detail::iteration_proxy_value::key
const string_type & key() const
return key of the iterator
Definition: json.hpp:5264
detail::iteration_proxy_value::iteration_proxy_value
iteration_proxy_value(iteration_proxy_value &&) noexcept(std::is_nothrow_move_constructible< IteratorType >::value &&std::is_nothrow_move_constructible< string_type >::value)=default
detail::iteration_proxy_value::string_type
typename std::remove_cv< typename std::remove_reference< decltype(std::declval< IteratorType >().key()) >::type >::type string_type
Definition: json.hpp:5194
detail::iteration_proxy_value::value
IteratorType::reference value() const
return value of the iterator
Definition: json.hpp:5300
detail::iteration_proxy_value::operator++
iteration_proxy_value & operator++()
increment operator (needed for range-based for)
Definition: json.hpp:5235
detail::iteration_proxy_value::operator=
iteration_proxy_value & operator=(iteration_proxy_value const &)=default
detail::iteration_proxy_value::iterator_category
std::input_iterator_tag iterator_category
Definition: json.hpp:5193
detail::iteration_proxy
proxy class for the items() function
Definition: json.hpp:5308
detail::iteration_proxy::end
iteration_proxy_value< IteratorType > end() const noexcept
return iterator end (needed for range-based for)
Definition: json.hpp:5333
detail::iteration_proxy::iteration_proxy
iteration_proxy(iteration_proxy const &)=default
detail::iteration_proxy::iteration_proxy
iteration_proxy()=default
detail::iteration_proxy::iteration_proxy
iteration_proxy(iteration_proxy &&) noexcept=default
detail::iteration_proxy::begin
iteration_proxy_value< IteratorType > begin() const noexcept
return iterator begin (needed for range-based for)
Definition: json.hpp:5327
detail::iteration_proxy::iteration_proxy
iteration_proxy(typename IteratorType::reference cont) noexcept
construct iteration proxy from a container
Definition: json.hpp:5317
detail::iteration_proxy::operator=
iteration_proxy & operator=(iteration_proxy const &)=default
detail::iterator_input_adapter
Definition: json.hpp:6282
detail::iterator_input_adapter::iterator_input_adapter
iterator_input_adapter(IteratorType first, IteratorType last)
Definition: json.hpp:6286
detail::iterator_input_adapter::char_type
typename std::iterator_traits< IteratorType >::value_type char_type
Definition: json.hpp:6284
detail::iterator_input_adapter::get_character
char_traits< char_type >::int_type get_character()
Definition: json.hpp:6290
detail::json_ref
Definition: json.hpp:14819
detail::json_ref::json_ref
json_ref(json_ref &&) noexcept=default
detail::json_ref::json_ref
json_ref(const value_type &value)
Definition: json.hpp:14827
detail::json_ref::json_ref
json_ref(value_type &&value)
Definition: json.hpp:14823
detail::json_ref::operator*
value_type const & operator*() const
Definition: json.hpp:14858
detail::json_ref::json_ref
json_ref(std::initializer_list< json_ref > init)
Definition: json.hpp:14831
detail::json_ref::json_ref
json_ref(Args &&... args)
Definition: json.hpp:14838
detail::json_ref::moved_or_copied
value_type moved_or_copied() const
Definition: json.hpp:14849
detail::json_ref::value_type
BasicJsonType value_type
Definition: json.hpp:14821
detail::json_ref::operator->
value_type const * operator->() const
Definition: json.hpp:14863
detail::json_reverse_iterator
a template for a reverse iterator class
Definition: json.hpp:13668
detail::json_reverse_iterator::operator++
json_reverse_iterator operator++(int) &
post-increment (it++)
Definition: json.hpp:13684
detail::json_reverse_iterator::operator++
json_reverse_iterator & operator++()
pre-increment (++it)
Definition: json.hpp:13690
detail::json_reverse_iterator::operator--
json_reverse_iterator operator--(int) &
post-decrement (it–)
Definition: json.hpp:13696
detail::json_reverse_iterator::operator--
json_reverse_iterator & operator--()
pre-decrement (–it)
Definition: json.hpp:13702
detail::json_reverse_iterator::difference_type
std::ptrdiff_t difference_type
Definition: json.hpp:13670
detail::json_reverse_iterator::operator[]
reference operator[](difference_type n) const
access to successor
Definition: json.hpp:13732
detail::json_reverse_iterator::key
auto key() const -> decltype(std::declval< Base >().key())
return the key of an object iterator
Definition: json.hpp:13738
detail::json_reverse_iterator::operator-
difference_type operator-(const json_reverse_iterator &other) const
return difference
Definition: json.hpp:13726
detail::json_reverse_iterator::operator+=
json_reverse_iterator & operator+=(difference_type i)
add to iterator
Definition: json.hpp:13708
detail::json_reverse_iterator::reference
typename Base::reference reference
the reference type for the pointed-to element
Definition: json.hpp:13674
detail::json_reverse_iterator::value
reference value() const
return the value of an iterator
Definition: json.hpp:13745
detail::json_reverse_iterator::json_reverse_iterator
json_reverse_iterator(const base_iterator &it) noexcept
create reverse iterator from base class
Definition: json.hpp:13681
detail::json_reverse_iterator::base_iterator
std::reverse_iterator< Base > base_iterator
shortcut to the reverse iterator adapter
Definition: json.hpp:13672
detail::json_reverse_iterator::operator-
json_reverse_iterator operator-(difference_type i) const
subtract from iterator
Definition: json.hpp:13720
detail::json_reverse_iterator::json_reverse_iterator
json_reverse_iterator(const typename base_iterator::iterator_type &it) noexcept
create reverse iterator from iterator
Definition: json.hpp:13677
detail::json_reverse_iterator::operator+
json_reverse_iterator operator+(difference_type i) const
add to iterator
Definition: json.hpp:13714
detail::json_sax_acceptor
Definition: json.hpp:7291
detail::json_sax_acceptor::number_unsigned_t
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.hpp:7294
detail::json_sax_acceptor::end_object
bool end_object()
Definition: json.hpp:7344
detail::json_sax_acceptor::start_object
bool start_object(std::size_t=static_cast< std::size_t >(-1))
Definition: json.hpp:7334
detail::json_sax_acceptor::binary
bool binary(binary_t &)
Definition: json.hpp:7329
detail::json_sax_acceptor::number_integer
bool number_integer(number_integer_t)
Definition: json.hpp:7309
detail::json_sax_acceptor::start_array
bool start_array(std::size_t=static_cast< std::size_t >(-1))
Definition: json.hpp:7349
detail::json_sax_acceptor::boolean
bool boolean(bool)
Definition: json.hpp:7304
detail::json_sax_acceptor::end_array
bool end_array()
Definition: json.hpp:7354
detail::json_sax_acceptor::number_unsigned
bool number_unsigned(number_unsigned_t)
Definition: json.hpp:7314
detail::json_sax_acceptor::string
bool string(string_t &)
Definition: json.hpp:7324
detail::json_sax_acceptor::binary_t
typename BasicJsonType::binary_t binary_t
Definition: json.hpp:7297
detail::json_sax_acceptor::number_float
bool number_float(number_float_t, const string_t &)
Definition: json.hpp:7319
detail::json_sax_acceptor::parse_error
bool parse_error(std::size_t, const std::string &, const detail::exception &)
Definition: json.hpp:7359
detail::json_sax_acceptor::key
bool key(string_t &)
Definition: json.hpp:7339
detail::json_sax_acceptor::number_integer_t
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.hpp:7293
detail::json_sax_acceptor::number_float_t
typename BasicJsonType::number_float_t number_float_t
Definition: json.hpp:7295
detail::json_sax_acceptor::string_t
typename BasicJsonType::string_t string_t
Definition: json.hpp:7296
detail::json_sax_dom_callback_parser
Definition: json.hpp:6984
detail::json_sax_dom_callback_parser::boolean
bool boolean(bool val)
Definition: json.hpp:7015
detail::json_sax_dom_callback_parser::parse_error
bool parse_error(std::size_t, const std::string &, const Exception &ex)
Definition: json.hpp:7172
detail::json_sax_dom_callback_parser::string_t
typename BasicJsonType::string_t string_t
Definition: json.hpp:6989
detail::json_sax_dom_callback_parser::number_float
bool number_float(number_float_t val, const string_t &)
Definition: json.hpp:7033
detail::json_sax_dom_callback_parser::is_errored
constexpr bool is_errored() const
Definition: json.hpp:7184
detail::json_sax_dom_callback_parser::string
bool string(string_t &val)
Definition: json.hpp:7039
detail::json_sax_dom_callback_parser::json_sax_dom_callback_parser
json_sax_dom_callback_parser(const json_sax_dom_callback_parser &)=delete
detail::json_sax_dom_callback_parser::number_unsigned_t
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.hpp:6987
detail::json_sax_dom_callback_parser::binary_t
typename BasicJsonType::binary_t binary_t
Definition: json.hpp:6990
detail::json_sax_dom_callback_parser::start_object
bool start_object(std::size_t len)
Definition: json.hpp:7051
detail::json_sax_dom_callback_parser::start_array
bool start_array(std::size_t len)
Definition: json.hpp:7122
detail::json_sax_dom_callback_parser::number_integer_t
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.hpp:6986
detail::json_sax_dom_callback_parser::end_array
bool end_array()
Definition: json.hpp:7139
detail::json_sax_dom_callback_parser::json_sax_dom_callback_parser
json_sax_dom_callback_parser(json_sax_dom_callback_parser &&)=default
detail::json_sax_dom_callback_parser::key
bool key(string_t &val)
Definition: json.hpp:7069
detail::json_sax_dom_callback_parser::end_object
bool end_object()
Definition: json.hpp:7086
detail::json_sax_dom_callback_parser::operator=
json_sax_dom_callback_parser & operator=(const json_sax_dom_callback_parser &)=delete
detail::json_sax_dom_callback_parser::~json_sax_dom_callback_parser
~json_sax_dom_callback_parser()=default
detail::json_sax_dom_callback_parser::parse_event_t
typename BasicJsonType::parse_event_t parse_event_t
Definition: json.hpp:6992
detail::json_sax_dom_callback_parser::parser_callback_t
typename BasicJsonType::parser_callback_t parser_callback_t
Definition: json.hpp:6991
detail::json_sax_dom_callback_parser::number_unsigned
bool number_unsigned(number_unsigned_t val)
Definition: json.hpp:7027
detail::json_sax_dom_callback_parser::operator=
json_sax_dom_callback_parser & operator=(json_sax_dom_callback_parser &&)=default
detail::json_sax_dom_callback_parser::json_sax_dom_callback_parser
json_sax_dom_callback_parser(BasicJsonType &r, const parser_callback_t cb, const bool allow_exceptions_=true)
Definition: json.hpp:6994
detail::json_sax_dom_callback_parser::number_float_t
typename BasicJsonType::number_float_t number_float_t
Definition: json.hpp:6988
detail::json_sax_dom_callback_parser::number_integer
bool number_integer(number_integer_t val)
Definition: json.hpp:7021
detail::json_sax_dom_callback_parser::binary
bool binary(binary_t &val)
Definition: json.hpp:7045
detail::json_sax_dom_parser
SAX implementation to create a JSON value from SAX events.
Definition: json.hpp:6801
detail::json_sax_dom_parser::operator=
json_sax_dom_parser & operator=(json_sax_dom_parser &&)=default
detail::json_sax_dom_parser::json_sax_dom_parser
json_sax_dom_parser(const json_sax_dom_parser &)=delete
detail::json_sax_dom_parser::string
bool string(string_t &val)
Definition: json.hpp:6855
detail::json_sax_dom_parser::json_sax_dom_parser
json_sax_dom_parser(BasicJsonType &r, const bool allow_exceptions_=true)
Definition: json.hpp:6814
detail::json_sax_dom_parser::parse_error
bool parse_error(std::size_t, const std::string &, const Exception &ex)
Definition: json.hpp:6922
detail::json_sax_dom_parser::~json_sax_dom_parser
~json_sax_dom_parser()=default
detail::json_sax_dom_parser::string_t
typename BasicJsonType::string_t string_t
Definition: json.hpp:6806
detail::json_sax_dom_parser::start_object
bool start_object(std::size_t len)
Definition: json.hpp:6867
detail::json_sax_dom_parser::number_unsigned_t
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.hpp:6804
detail::json_sax_dom_parser::number_unsigned
bool number_unsigned(number_unsigned_t val)
Definition: json.hpp:6843
detail::json_sax_dom_parser::number_integer
bool number_integer(number_integer_t val)
Definition: json.hpp:6837
detail::json_sax_dom_parser::number_integer_t
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.hpp:6803
detail::json_sax_dom_parser::binary
bool binary(binary_t &val)
Definition: json.hpp:6861
detail::json_sax_dom_parser::json_sax_dom_parser
json_sax_dom_parser(json_sax_dom_parser &&)=default
detail::json_sax_dom_parser::boolean
bool boolean(bool val)
Definition: json.hpp:6831
detail::json_sax_dom_parser::end_array
bool end_array()
Definition: json.hpp:6911
detail::json_sax_dom_parser::operator=
json_sax_dom_parser & operator=(const json_sax_dom_parser &)=delete
detail::json_sax_dom_parser::number_float
bool number_float(number_float_t val, const string_t &)
Definition: json.hpp:6849
detail::json_sax_dom_parser::end_object
bool end_object()
Definition: json.hpp:6889
detail::json_sax_dom_parser::is_errored
constexpr bool is_errored() const
Definition: json.hpp:6934
detail::json_sax_dom_parser::binary_t
typename BasicJsonType::binary_t binary_t
Definition: json.hpp:6807
detail::json_sax_dom_parser::number_float_t
typename BasicJsonType::number_float_t number_float_t
Definition: json.hpp:6805
detail::json_sax_dom_parser::start_array
bool start_array(std::size_t len)
Definition: json.hpp:6899
detail::json_sax_dom_parser::key
bool key(string_t &val)
Definition: json.hpp:6879
detail::lexer_base
Definition: json.hpp:7408
detail::lexer_base::token_type_name
JSON_HEDLEY_RETURNS_NON_NULL static JSON_HEDLEY_CONST const char * token_type_name(const token_type t) noexcept
return name of values of type token_type (only used for errors)
Definition: json.hpp:7435
detail::lexer_base::token_type
token_type
token types for the parser
Definition: json.hpp:7412
detail::lexer
lexical analysis
Definition: json.hpp:7485
detail::lexer::skip_bom
bool skip_bom()
skip the UTF-8 byte order mark
Definition: json.hpp:8859
detail::lexer::skip_whitespace
void skip_whitespace()
Definition: json.hpp:8873
detail::lexer::operator=
lexer & operator=(lexer &&)=default
detail::lexer::lexer
lexer(InputAdapterType &&adapter, bool ignore_comments_=false) noexcept
Definition: json.hpp:7496
detail::lexer::get_token_string
std::string get_token_string() const
Definition: json.hpp:8821
detail::lexer::get_number_integer
constexpr number_integer_t get_number_integer() const noexcept
return integer value
Definition: json.hpp:8785
detail::lexer::get_position
constexpr position_t get_position() const noexcept
return position of last read token
Definition: json.hpp:8813
detail::lexer::scan
token_type scan()
Definition: json.hpp:8881
detail::lexer::get_number_unsigned
constexpr number_unsigned_t get_number_unsigned() const noexcept
return unsigned integer value
Definition: json.hpp:8791
detail::lexer::token_type
typename lexer_base< BasicJsonType >::token_type token_type
Definition: json.hpp:7494
detail::lexer::lexer
lexer(lexer &&)=default
detail::lexer::~lexer
~lexer()=default
detail::lexer::get_string
string_t & get_string()
return current string value (implicitly resets the token; useful only once)
Definition: json.hpp:8803
detail::lexer::operator=
lexer & operator=(lexer &)=delete
detail::lexer::lexer
lexer(const lexer &)=delete
detail::lexer::get_error_message
constexpr JSON_HEDLEY_RETURNS_NON_NULL const char * get_error_message() const noexcept
return syntax error message
Definition: json.hpp:8846
detail::lexer::get_number_float
constexpr number_float_t get_number_float() const noexcept
return floating-point value
Definition: json.hpp:8797
detail::other_error
exception indicating other library errors
Definition: json.hpp:4576
detail::other_error::create
static other_error create(int id_, const std::string &what_arg, BasicJsonContext context)
Definition: json.hpp:4579
detail::out_of_range
exception indicating access out of the defined range
Definition: json.hpp:4559
detail::out_of_range::create
static out_of_range create(int id_, const std::string &what_arg, BasicJsonContext context)
Definition: json.hpp:4562
detail::output_adapter
Definition: json.hpp:15036
detail::output_adapter::output_adapter
output_adapter(StringType &s)
Definition: json.hpp:15047
detail::output_adapter::output_adapter
output_adapter(std::basic_ostream< CharType > &s)
Definition: json.hpp:15043
detail::output_adapter::output_adapter
output_adapter(std::vector< CharType, AllocatorType > &vec)
Definition: json.hpp:15039
detail::output_stream_adapter
output adapter for output streams
Definition: json.hpp:14988
detail::output_stream_adapter::output_stream_adapter
output_stream_adapter(std::basic_ostream< CharType > &s) noexcept
Definition: json.hpp:14990
detail::output_stream_adapter::write_character
void write_character(CharType c) override
Definition: json.hpp:14994
detail::output_string_adapter
output adapter for basic_string
Definition: json.hpp:15013
detail::output_string_adapter::write_character
void write_character(CharType c) override
Definition: json.hpp:15019
detail::output_string_adapter::output_string_adapter
output_string_adapter(StringType &s) noexcept
Definition: json.hpp:15015
detail::output_vector_adapter
output adapter for byte vectors
Definition: json.hpp:14963
detail::output_vector_adapter::output_vector_adapter
output_vector_adapter(std::vector< CharType, AllocatorType > &vec) noexcept
Definition: json.hpp:14965
detail::output_vector_adapter::write_character
void write_character(CharType c) override
Definition: json.hpp:14969
detail::parse_error
exception indicating a parse error
Definition: json.hpp:4471
detail::parse_error::create
static parse_error create(int id_, const position_t &pos, const std::string &what_arg, BasicJsonContext context)
create a parse error exception
Definition: json.hpp:4483
detail::parse_error::create
static parse_error create(int id_, std::size_t byte_, const std::string &what_arg, BasicJsonContext context)
Definition: json.hpp:4491
detail::parse_error::byte
const std::size_t byte
byte index of the parse error
Definition: json.hpp:4508
detail::parser
syntax analysis
Definition: json.hpp:12228
detail::parser::parser
parser(InputAdapterType &&adapter, const parser_callback_t< BasicJsonType > cb=nullptr, const bool allow_exceptions_=true, const bool skip_comments=false)
a parser reading from an input adapter
Definition: json.hpp:12238
detail::parser::parse
void parse(const bool strict, BasicJsonType &result)
public parser interface
Definition: json.hpp:12260
detail::parser::accept
bool accept(const bool strict=true)
public accept interface
Definition: json.hpp:12320
detail::parser::sax_parse
bool sax_parse(SAX *sax, const bool strict=true)
Definition: json.hpp:12328
detail::primitive_iterator_t
Definition: json.hpp:12732
detail::primitive_iterator_t::operator+=
primitive_iterator_t & operator+=(difference_type n) noexcept
Definition: json.hpp:12820
detail::primitive_iterator_t::operator--
primitive_iterator_t & operator--() noexcept
Definition: json.hpp:12807
detail::primitive_iterator_t::is_begin
constexpr bool is_begin() const noexcept
return whether the iterator can be dereferenced
Definition: json.hpp:12761
detail::primitive_iterator_t::operator<
constexpr friend bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition: json.hpp:12777
detail::primitive_iterator_t::operator++
primitive_iterator_t & operator++() noexcept
Definition: json.hpp:12794
detail::primitive_iterator_t::set_end
void set_end() noexcept
set iterator to a defined past the end
Definition: json.hpp:12755
detail::primitive_iterator_t::operator-
constexpr friend difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition: json.hpp:12789
detail::primitive_iterator_t::is_end
constexpr bool is_end() const noexcept
return whether the iterator is at end
Definition: json.hpp:12767
detail::primitive_iterator_t::operator++
primitive_iterator_t operator++(int) &noexcept
Definition: json.hpp:12800
detail::primitive_iterator_t::get_value
constexpr difference_type get_value() const noexcept
Definition: json.hpp:12743
detail::primitive_iterator_t::operator+
primitive_iterator_t operator+(difference_type n) noexcept
Definition: json.hpp:12782
detail::primitive_iterator_t::operator-=
primitive_iterator_t & operator-=(difference_type n) noexcept
Definition: json.hpp:12826
detail::primitive_iterator_t::set_begin
void set_begin() noexcept
set iterator to a defined beginning
Definition: json.hpp:12749
detail::primitive_iterator_t::operator--
primitive_iterator_t operator--(int) &noexcept
Definition: json.hpp:12813
detail::primitive_iterator_t::operator==
constexpr friend bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition: json.hpp:12772
detail::serializer
Definition: json.hpp:18059
detail::serializer::operator=
serializer & operator=(serializer &&)=delete
detail::serializer::string_buffer
std::array< char, 512 > string_buffer
string buffer
Definition: json.hpp:18983
detail::serializer::state
std::uint8_t state
Definition: json.hpp:18401
detail::serializer::bytes_after_last_accept
std::size_t bytes_after_last_accept
Definition: json.hpp:18405
detail::serializer::serializer
serializer(output_adapter_t< char > s, const char ichar, error_handler_t error_handler_=error_handler_t::strict)
Definition: json.hpp:18074
detail::serializer::ensure_ascii
JSON_PRIVATE_UNLESS_TESTED const bool ensure_ascii
Definition: json.hpp:18399
detail::serializer::undumped_chars
std::size_t undumped_chars
Definition: json.hpp:18406
detail::serializer::thousands_sep
const char thousands_sep
the locale's thousand separator character
Definition: json.hpp:18978
detail::serializer::decimal_point
const char decimal_point
the locale's decimal point character
Definition: json.hpp:18980
detail::serializer::~serializer
~serializer()=default
detail::serializer::error_handler
const error_handler_t error_handler
error_handler how to react on decoding errors
Definition: json.hpp:18991
detail::serializer::indent_string
string_t indent_string
the indentation string
Definition: json.hpp:18988
detail::serializer::loc
const std::lconv * loc
the locale
Definition: json.hpp:18976
detail::serializer::operator=
serializer & operator=(const serializer &)=delete
detail::serializer::number_buffer
std::array< char, 64 > number_buffer
a (hopefully) large enough character buffer
Definition: json.hpp:18973
detail::serializer::indent_char
const char indent_char
the indentation character
Definition: json.hpp:18986
detail::serializer::bytes
std::size_t bytes
Definition: json.hpp:18402
detail::serializer::dump
void dump(const BasicJsonType &val, const bool pretty_print, const bool ensure_ascii, const unsigned int indent_step, const unsigned int current_indent=0)
internal implementation of the serialization function
Definition: json.hpp:18114
detail::serializer::serializer
serializer(const serializer &)=delete
detail::serializer::serializer
serializer(serializer &&)=delete
detail::span_input_adapter
Definition: json.hpp:6606
detail::span_input_adapter::span_input_adapter
span_input_adapter(CharT b, std::size_t l)
Definition: json.hpp:6614
detail::span_input_adapter::span_input_adapter
span_input_adapter(IteratorType first, IteratorType last)
Definition: json.hpp:6621
detail::span_input_adapter::get
contiguous_bytes_input_adapter && get()
Definition: json.hpp:6624
detail::type_error
exception indicating executing a member function with a wrong type
Definition: json.hpp:4542
detail::type_error::create
static type_error create(int id_, const std::string &what_arg, BasicJsonContext context)
Definition: json.hpp:4545
detail::wide_string_input_adapter
Definition: json.hpp:6441
detail::wide_string_input_adapter::wide_string_input_adapter
wide_string_input_adapter(BaseInputAdapter base)
Definition: json.hpp:6445
detail::wide_string_input_adapter::char_type
char char_type
Definition: json.hpp:6443
detail::wide_string_input_adapter::get_character
std::char_traits< char >::int_type get_character() noexcept
Definition: json.hpp:6448
json_pointer
JSON Pointer defines a string syntax for identifying a specific value within a JSON document.
Definition: json.hpp:13840
json_pointer::operator/
friend json_pointer operator/(const json_pointer &lhs, string_t token)
create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
Definition: json.hpp:13935
json_pointer::operator/=
json_pointer & operator/=(string_t token)
append an unescaped reference token at the end of this JSON pointer
Definition: json.hpp:13912
json_pointer::string_t
typename string_t_helper< RefStringType >::type string_t
Definition: json.hpp:13862
json_pointer::operator/
friend json_pointer operator/(const json_pointer &lhs, std::size_t array_idx)
create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
Definition: json.hpp:13942
json_pointer::operator/=
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
Definition: json.hpp:13902
json_pointer::json_pointer
json_pointer(const string_t &s="")
create JSON pointer
Definition: json.hpp:13866
json_pointer::empty
bool empty() const noexcept
return whether pointer points to the root document
Definition: json.hpp:14001
json_pointer::operator==
friend bool operator==(const json_pointer< RefStringTypeLhs > &lhs, const json_pointer< RefStringTypeRhs > &rhs) noexcept
compares two JSON pointers for equality
Definition: json.hpp:14735
json_pointer::operator<<
friend std::ostream & operator<<(std::ostream &o, const json_pointer &ptr)
write string representation of the JSON pointer to stream
Definition: json.hpp:13893
json_pointer::pop_back
void pop_back()
remove last reference token
Definition: json.hpp:13963
json_pointer::to_string
string_t to_string() const
return a string representation of the JSON pointer
Definition: json.hpp:13872
json_pointer::push_back
void push_back(string_t &&token)
append an unescaped token at the end of the reference pointer
Definition: json.hpp:13994
json_pointer::operator/
friend json_pointer operator/(const json_pointer &lhs, const json_pointer &rhs)
create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
Definition: json.hpp:13927
json_pointer::parent_pointer
json_pointer parent_pointer() const
returns the parent of this JSON pointer
Definition: json.hpp:13949
json_pointer::operator!=
friend bool operator!=(const json_pointer< RefStringTypeLhs > &lhs, const json_pointer< RefStringTypeRhs > &rhs) noexcept
compares two JSON pointers for inequality
Definition: json.hpp:14760
json_pointer::json_pointer
friend class json_pointer
Definition: json.hpp:13846
json_pointer::back
const string_t & back() const
return last reference token
Definition: json.hpp:13975
json_pointer::push_back
void push_back(const string_t &token)
append an unescaped token at the end of the reference pointer
Definition: json.hpp:13987
json_pointer::operator<
friend bool operator<(const json_pointer< RefStringTypeLhs > &lhs, const json_pointer< RefStringTypeRhs > &rhs) noexcept
compares two JSON pointer for less-than
Definition: json.hpp:14785
json_pointer::operator/=
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON pointer
Definition: json.hpp:13920
std::tuple_element< N, ::nlohmann::detail::iteration_proxy_value< IteratorType > >::type
decltype(get< N >(std::declval< ::nlohmann::detail::iteration_proxy_value< IteratorType > >())) type
Definition: json.hpp:5381
NLOHMANN_BASIC_JSON_TPL_DECLARATION
#define NLOHMANN_BASIC_JSON_TPL_DECLARATION
Definition: json.hpp:2596
JSON_HEDLEY_CONST
#define JSON_HEDLEY_CONST
Definition: json.hpp:1818
JSON_HEDLEY_DIAGNOSTIC_PUSH
#define JSON_HEDLEY_DIAGNOSTIC_PUSH
Definition: json.hpp:1102
JSON_INLINE_VARIABLE
#define JSON_INLINE_VARIABLE
Definition: json.hpp:2499
JSON_HEDLEY_WARN_UNUSED_RESULT
#define JSON_HEDLEY_WARN_UNUSED_RESULT
Definition: json.hpp:1448
JSON_PRIVATE_UNLESS_TESTED
#define JSON_PRIVATE_UNLESS_TESTED
Definition: json.hpp:2559
NLOHMANN_JSON_VERSION_PATCH
#define NLOHMANN_JSON_VERSION_PATCH
Definition: json.hpp:70
JSON_HEDLEY_LIKELY
#define JSON_HEDLEY_LIKELY(expr)
Definition: json.hpp:1713
JSON_HEDLEY_NON_NULL
#define JSON_HEDLEY_NON_NULL(...)
Definition: json.hpp:1606
JSON_INTERNAL_CATCH
#define JSON_INTERNAL_CATCH(exception)
Definition: json.hpp:2526
to_string
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
Definition: json.hpp:24455
JSON_HEDLEY_RETURNS_NON_NULL
#define JSON_HEDLEY_RETURNS_NON_NULL
Definition: json.hpp:2047
operator==
bool operator==(const json_pointer< RefStringTypeLhs > &lhs, const json_pointer< RefStringTypeRhs > &rhs) noexcept
Definition: json.hpp:14735
JSON_CATCH
#define JSON_CATCH(exception)
Definition: json.hpp:2525
JSON_ASSERT
#define JSON_ASSERT(x)
Definition: json.hpp:2552
JSON_THROW
#define JSON_THROW(exception)
Definition: json.hpp:2523
JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
Definition: json.hpp:77
NLOHMANN_JSON_VERSION_MAJOR
#define NLOHMANN_JSON_VERSION_MAJOR
Definition: json.hpp:68
NLOHMANN_BASIC_JSON_TPL
#define NLOHMANN_BASIC_JSON_TPL
Definition: json.hpp:2606
JSON_HEDLEY_UNLIKELY
#define JSON_HEDLEY_UNLIKELY(expr)
Definition: json.hpp:1714
JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
Definition: json.hpp:12118
JSON_TRY
#define JSON_TRY
Definition: json.hpp:2524
NLOHMANN_JSON_NAMESPACE_END
#define NLOHMANN_JSON_NAMESPACE_END
Definition: json.hpp:144
JSON_NO_UNIQUE_ADDRESS
#define JSON_NO_UNIQUE_ADDRESS
Definition: json.hpp:2505
operator!=
bool operator!=(const json_pointer< RefStringTypeLhs > &lhs, const json_pointer< RefStringTypeRhs > &rhs) noexcept
Definition: json.hpp:14760
NLOHMANN_JSON_VERSION_MINOR
#define NLOHMANN_JSON_VERSION_MINOR
Definition: json.hpp:69
NLOHMANN_CAN_CALL_STD_FUNC_IMPL
#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)
Definition: json.hpp:2786
NLOHMANN_JSON_NAMESPACE_BEGIN
#define NLOHMANN_JSON_NAMESPACE_BEGIN
Definition: json.hpp:134
JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
Definition: json.hpp:12115
json
basic_json<> json
default specialization
Definition: json.hpp:3423
JSON_HEDLEY_DIAGNOSTIC_POP
#define JSON_HEDLEY_DIAGNOSTIC_POP
Definition: json.hpp:1103
JSON_EXPLICIT
#define JSON_EXPLICIT
Definition: json.hpp:2823
JSON_HEDLEY_DEPRECATED_FOR
#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
Definition: json.hpp:1396
JSON_HEDLEY_PURE
#define JSON_HEDLEY_PURE
Definition: json.hpp:1787
operator<
bool operator<(const json_pointer< RefStringTypeLhs > &lhs, const json_pointer< RefStringTypeRhs > &rhs) noexcept
Definition: json.hpp:14785
JSON_IMPLEMENT_OPERATOR
#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)
Definition: json.hpp:22881
OrderbookView.fill
fill
Definition: OrderbookView.py:93
addOrder.root
root
Definition: addOrder.py:127
detail::dtoa_impl::find_largest_pow10
int find_largest_pow10(const std::uint32_t n, std::uint32_t &pow10)
Definition: json.hpp:17398
detail::dtoa_impl::get_cached_power_for_binary_exponent
cached_power get_cached_power_for_binary_exponent(int e)
Definition: json.hpp:17234
detail::dtoa_impl::reinterpret_bits
Target reinterpret_bits(const Source source)
Definition: json.hpp:16954
detail::dtoa_impl::compute_boundaries
boundaries compute_boundaries(FloatType value)
Definition: json.hpp:17095
detail::dtoa_impl::append_exponent
JSON_HEDLEY_RETURNS_NON_NULL char * append_exponent(char *buf, int e)
appends a decimal representation of e to buf
Definition: json.hpp:17834
detail::dtoa_impl::format_buffer
JSON_HEDLEY_RETURNS_NON_NULL char * format_buffer(char *buf, int len, int decimal_exponent, int min_exp, int max_exp)
prettify v = buf * 10^decimal_exponent
Definition: json.hpp:17886
detail::dtoa_impl::grisu2_round
void grisu2_round(char *buf, int len, std::uint64_t dist, std::uint64_t delta, std::uint64_t rest, std::uint64_t ten_k)
Definition: json.hpp:17452
detail::dtoa_impl::kAlpha
constexpr int kAlpha
Definition: json.hpp:17217
detail::dtoa_impl::grisu2
void grisu2(char *buf, int &len, int &decimal_exponent, diyfp m_minus, diyfp v, diyfp m_plus)
Definition: json.hpp:17734
detail::dtoa_impl::kGamma
constexpr int kGamma
Definition: json.hpp:17218
detail::dtoa_impl::grisu2_digit_gen
void grisu2_digit_gen(char *buffer, int &length, int &decimal_exponent, diyfp M_minus, diyfp w, diyfp M_plus)
Definition: json.hpp:17493
detail::impl::is_transparent
constexpr bool is_transparent()
Definition: json.hpp:4195
detail::impl::is_c_string
constexpr bool is_c_string()
Definition: json.hpp:4167
detail
detail namespace with internal helper functions
Definition: json.hpp:249
detail::input_format_t
input_format_t
the supported input formats
Definition: json.hpp:6177
detail::to_json_tuple_impl
void to_json_tuple_impl(BasicJsonType &j, const Tuple &t, index_sequence< Idx... >)
Definition: json.hpp:5781
detail::is_detected_exact
std::is_same< Expected, detected_t< Op, Args... > > is_detected_exact
Definition: json.hpp:309
detail::void_t
typename make_void< Ts... >::type void_t
Definition: json.hpp:255
detail::start_array_function_t
decltype(std::declval< T & >().start_array(std::declval< std::size_t >())) start_array_function_t
Definition: json.hpp:9074
detail::output_adapter_t
std::shared_ptr< output_adapter_protocol< CharType > > output_adapter_t
a type to simplify interfaces
Definition: json.hpp:14958
detail::string_can_append_op
decltype(std::declval< StringType & >()+=std::declval< Arg && >()) string_can_append_op
Definition: json.hpp:4276
detail::parse_error_function_t
decltype(std::declval< T & >().parse_error(std::declval< std::size_t >(), std::declval< const std::string & >(), std::declval< const Exception & >())) parse_error_function_t
Definition: json.hpp:9082
detail::make_array
constexpr std::array< T, sizeof...(Args)> make_array(Args &&... args)
Definition: json.hpp:3223
detail::parser_callback_t
std::function< bool(int, parse_event_t, BasicJsonType &)> parser_callback_t
Definition: json.hpp:12219
detail::concat
OutStringType concat(Args &&... args)
Definition: json.hpp:4350
detail::detect_string_can_append_iter
is_detected< string_can_append_iter, StringType, Arg > detect_string_can_append_iter
Definition: json.hpp:4285
detail::from_json_tuple_impl
std::pair< A1, A2 > from_json_tuple_impl(BasicJsonType &&j, identity_tag< std::pair< A1, A2 >>, priority_tag< 0 >)
Definition: json.hpp:5011
detail::to_json_function
decltype(T::to_json(std::declval< Args >()...)) to_json_function
Definition: json.hpp:3518
detail::get_template_function
decltype(std::declval< T >().template get< U >()) get_template_function
Definition: json.hpp:3524
detail::is_usable_as_basic_json_key_type
typename std::conditional< is_usable_as_key_type< typename BasicJsonType::object_comparator_t, typename BasicJsonType::object_t::key_type, KeyTypeCVRef, RequireTransparentComparator, ExcludeObjectKeyType >::value &&!is_json_iterator_of< BasicJsonType, KeyType >::value, std::true_type, std::false_type >::type is_usable_as_basic_json_key_type
Definition: json.hpp:4017
detail::to_json
void to_json(BasicJsonType &j, const T &b)
Definition: json.hpp:5775
detail::pointer_t
typename T::pointer pointer_t
Definition: json.hpp:3509
detail::string_can_append
decltype(std::declval< StringType & >().append(std::declval< Arg && >())) string_can_append
Definition: json.hpp:4270
detail::parse_event_t
parse_event_t
Definition: json.hpp:12202
detail::parse_event_t::value
@ value
the parser finished reading a JSON value
detail::parse_event_t::key
@ key
the parser read a key of a value in an object
detail::parse_event_t::array_end
@ array_end
the parser read ] and finished processing a JSON array
detail::parse_event_t::array_start
@ array_start
the parser read [ and started to process a JSON array
detail::parse_event_t::object_start
@ object_start
the parser read { and started to process a JSON object
detail::parse_event_t::object_end
@ object_end
the parser read } and finished processing a JSON object
detail::detect_string_can_append_op
is_detected< string_can_append_op, StringType, Arg > detect_string_can_append_op
Definition: json.hpp:4279
detail::index_sequence
integer_sequence< size_t, Ints... > index_sequence
Definition: json.hpp:3138
detail::from_json_array_impl
void from_json_array_impl(const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag< 3 >)
Definition: json.hpp:4822
detail::make_integer_sequence
typename utility_internal::Gen< T, N >::type make_integer_sequence
Definition: json.hpp:3184
detail::value_type_t
typename T::value_type value_type_t
Definition: json.hpp:3503
detail::is_detected_convertible
std::is_convertible< detected_t< Op, Args... >, To > is_detected_convertible
Definition: json.hpp:313
detail::conditional_static_cast
T conditional_static_cast(U value)
Definition: json.hpp:4051
detail::detect_string_can_append_data
is_detected< string_can_append_data, StringType, Arg > detect_string_can_append_data
Definition: json.hpp:4291
detail::enable_if_t
typename std::enable_if< B, T >::type enable_if_t
Definition: json.hpp:3096
detail::from_json
void from_json(const BasicJsonType &j, std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &m)
Definition: json.hpp:5070
detail::number_integer_function_t
decltype(std::declval< T & >().number_integer(std::declval< Integer >())) number_integer_function_t
Definition: json.hpp:9043
detail::mapped_type_t
typename T::mapped_type mapped_type_t
Definition: json.hpp:3497
detail::replace_substring
void replace_substring(StringType &s, const StringType &f, const StringType &t)
replace all occurrences of a substring by another string
Definition: json.hpp:2971
detail::number_float_function_t
decltype(std::declval< T & >().number_float(std::declval< Float >(), std::declval< const String & >())) number_float_function_t
Definition: json.hpp:9051
detail::iterator_t
enable_if_t< is_range< R >::value, result_of_begin< decltype(std::declval< R & >())> > iterator_t
Definition: json.hpp:3745
detail::get
auto get(const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())
Definition: json.hpp:5343
detail::cbor_tag_handler_t
cbor_tag_handler_t
how to treat CBOR tags
Definition: json.hpp:9185
detail::cbor_tag_handler_t::store
@ store
store tags as binary type
detail::cbor_tag_handler_t::error
@ error
throw a parse_error exception in case of a tag
detail::detected_or_t
typename detected_or< Default, Op, Args... >::type detected_or_t
Definition: json.hpp:306
detail::from_json_function
decltype(T::from_json(std::declval< Args >()...)) from_json_function
Definition: json.hpp:3521
detail::contiguous_bytes_input_adapter
decltype(input_adapter(std::declval< const char * >(), std::declval< const char * >())) contiguous_bytes_input_adapter
Definition: json.hpp:6579
detail::make_index_sequence
make_integer_sequence< size_t, N > make_index_sequence
Definition: json.hpp:3192
detail::bool_constant
std::integral_constant< bool, Value > bool_constant
Definition: json.hpp:4157
detail::concat_into
void concat_into(OutStringType &)
Definition: json.hpp:4266
detail::key_type_t
typename T::key_type key_type_t
Definition: json.hpp:3500
detail::value_in_range_of
constexpr bool value_in_range_of(T val)
Definition: json.hpp:4151
detail::value_t
value_t
the JSON type enumeration
Definition: json.hpp:2873
detail::value_t::null
@ null
null value
detail::value_t::number_integer
@ number_integer
number value (signed integer)
detail::value_t::boolean
@ boolean
boolean value
detail::value_t::discarded
@ discarded
discarded by the parser callback function
detail::value_t::binary
@ binary
binary array (ordered collection of bytes)
detail::value_t::object
@ object
object (unordered set of name/value pairs)
detail::value_t::string
@ string
string value
detail::value_t::number_float
@ number_float
number value (floating-point)
detail::value_t::number_unsigned
@ number_unsigned
number value (unsigned integer)
detail::value_t::array
@ array
array (ordered collection of values)
detail::same_sign
std::integral_constant< bool, all_signed< Types... >::value||all_unsigned< Types... >::value > same_sign
Definition: json.hpp:4074
detail::input_adapter
iterator_input_adapter_factory< IteratorType >::adapter_type input_adapter(IteratorType first, IteratorType last)
Definition: json.hpp:6522
detail::from_json_tuple_impl_base
std::tuple< Args... > from_json_tuple_impl_base(BasicJsonType &&j, index_sequence< Idx... >)
Definition: json.hpp:5005
detail::binary_function_t
decltype(std::declval< T & >().binary(std::declval< Binary & >())) binary_function_t
Definition: json.hpp:9059
detail::detected_t
typename detector< nonesuch, void, Op, Args... >::type detected_t
Definition: json.hpp:300
detail::hash
std::size_t hash(const BasicJsonType &j)
hash a JSON value
Definition: json.hpp:6023
detail::string_can_append_iter
decltype(std::declval< StringType & >().append(std::declval< const Arg & >().begin(), std::declval< const Arg & >().end())) string_can_append_iter
Definition: json.hpp:4282
detail::iterator_category_t
typename T::iterator_category iterator_category_t
Definition: json.hpp:3515
detail::combine
std::size_t combine(std::size_t seed, std::size_t h) noexcept
Definition: json.hpp:6005
detail::operator<
bool operator<(const value_t lhs, const value_t rhs) noexcept
comparison operator for JSON types
Definition: json.hpp:2902
detail::end_array_function_t
decltype(std::declval< T & >().end_array()) end_array_function_t
Definition: json.hpp:9077
detail::to_chars
JSON_HEDLEY_RETURNS_NON_NULL char * to_chars(char *first, const char *last, FloatType value)
generates a decimal representation of the floating-point number value in [first, last).
Definition: json.hpp:17971
detail::has_erase_with_key_type
typename std::conditional< is_detected< detect_erase_with_key_type, typename BasicJsonType::object_t, KeyType >::value, std::true_type, std::false_type >::type has_erase_with_key_type
Definition: json.hpp:4029
detail::error_handler_t
error_handler_t
how to treat decoding errors
Definition: json.hpp:18051
detail::error_handler_t::strict
@ strict
throw a type_error exception in case of invalid UTF-8
detail::error_handler_t::ignore
@ ignore
ignore invalid UTF-8 sequences
detail::error_handler_t::replace
@ replace
replace invalid UTF-8 sequences with U+FFFD
detail::concat_length
std::size_t concat_length()
Definition: json.hpp:4235
detail::range_value_t
value_type_t< iterator_traits< iterator_t< T > >> range_value_t
Definition: json.hpp:3748
detail::from_json
void from_json(const BasicJsonType &j, typename std::nullptr_t &n)
Definition: json.hpp:4665
detail::actual_object_comparator_t
typename actual_object_comparator< BasicJsonType >::type actual_object_comparator_t
Definition: json.hpp:3597
detail::to_json
void to_json(BasicJsonType &j, T b) noexcept
Definition: json.hpp:5643
detail::get_arithmetic_value
void get_arithmetic_value(const BasicJsonType &j, ArithmeticType &val)
Definition: json.hpp:4679
detail::null_function_t
decltype(std::declval< T & >().null()) null_function_t
Definition: json.hpp:9035
detail::index_sequence_for
make_index_sequence< sizeof...(Ts)> index_sequence_for
Definition: json.hpp:3200
detail::difference_type_t
typename T::difference_type difference_type_t
Definition: json.hpp:3506
detail::uncvref_t
typename std::remove_cv< typename std::remove_reference< T >::type >::type uncvref_t
Definition: json.hpp:3082
detail::detect_is_transparent
typename T::is_transparent detect_is_transparent
Definition: json.hpp:3987
detail::string_function_t
decltype(std::declval< T & >().string(std::declval< String & >())) string_function_t
Definition: json.hpp:9055
detail::json_base_class
typename std::conditional< std::is_same< T, void >::value, json_default_base, T >::type json_base_class
Definition: json.hpp:13794
detail::reference_t
typename T::reference reference_t
Definition: json.hpp:3512
detail::boolean_function_t
decltype(std::declval< T & >().boolean(std::declval< bool >())) boolean_function_t
Definition: json.hpp:9039
detail::end_object_function_t
decltype(std::declval< T & >().end_object()) end_object_function_t
Definition: json.hpp:9070
detail::detect_erase_with_key_type
decltype(std::declval< ObjectType & >().erase(std::declval< KeyType >())) detect_erase_with_key_type
Definition: json.hpp:4020
detail::detect_key_compare
typename T::key_compare detect_key_compare
Definition: json.hpp:3581
detail::start_object_function_t
decltype(std::declval< T & >().start_object(std::declval< std::size_t >())) start_object_function_t
Definition: json.hpp:9063
detail::string_can_append_data
decltype(std::declval< StringType & >().append(std::declval< const Arg & >().data(), std::declval< const Arg & >().size())) string_can_append_data
Definition: json.hpp:4288
detail::number_unsigned_function_t
decltype(std::declval< T & >().number_unsigned(std::declval< Unsigned >())) number_unsigned_function_t
Definition: json.hpp:9047
detail::is_detected
typename detector< nonesuch, void, Op, Args... >::value_t is_detected
Definition: json.hpp:294
detail::escape
StringType escape(StringType s)
string escaping as described in RFC 6901 (Sect. 4)
Definition: json.hpp:2991
detail::int_to_string
void int_to_string(string_type &target, std::size_t value)
Definition: json.hpp:5180
detail::never_out_of_range
std::integral_constant< bool,(std::is_signed< OfType >::value &&(sizeof(T)< sizeof(OfType)))||(same_sign< OfType, T >::value &&sizeof(OfType)==sizeof(T)) > never_out_of_range
Definition: json.hpp:4079
detail::is_usable_as_key_type
typename std::conditional< is_comparable< Comparator, ObjectKeyType, KeyTypeCVRef >::value &&!(ExcludeObjectKeyType &&std::is_same< KeyType, ObjectKeyType >::value) &&(!RequireTransparentComparator||is_detected< detect_is_transparent, Comparator >::value) &&!is_json_pointer< KeyType >::value, std::true_type, std::false_type >::type is_usable_as_key_type
Definition: json.hpp:4001
detail::detect_string_can_append
is_detected< string_can_append, StringType, Arg > detect_string_can_append
Definition: json.hpp:4273
detail::from_json_inplace_array_impl
std::array< T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType &&j, identity_tag< std::array< T, sizeof...(Idx)>>, index_sequence< Idx... >)
Definition: json.hpp:4905
detail::key_function_t
decltype(std::declval< T & >().key(std::declval< String & >())) key_function_t
Definition: json.hpp:9067
literals
Definition: json.hpp:24461
std
Definition: json.hpp:5364
std::swap
NLOHMANN_BASIC_JSON_TPL_DECLARATION void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL &j1, nlohmann::NLOHMANN_BASIC_JSON_TPL &j2) noexcept(//NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp) is_nothrow_move_constructible< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value &&//NOLINT(misc-redundant-expression, cppcoreguidelines-noexcept-swap, performance-noexcept-swap) is_nothrow_move_assignable< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value)
exchanges the values of two JSON objects
Definition: json.hpp:24536
adl_serializer
namespace for Niels Lohmann
Definition: json.hpp:5834
adl_serializer::to_json
static auto to_json(BasicJsonType &j, TargetType &&val) noexcept(noexcept(::nlohmann::to_json(j, std::forward< TargetType >(val)))) -> decltype(::nlohmann::to_json(j, std::forward< TargetType >(val)), void())
convert any value type to a JSON value
Definition: json.hpp:5858
adl_serializer::from_json
static auto from_json(BasicJsonType &&j) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), detail::identity_tag< TargetType > {}))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), detail::identity_tag< TargetType > {}))
convert a JSON value to any value type
Definition: json.hpp:5848
adl_serializer::from_json
static auto from_json(BasicJsonType &&j, TargetType &val) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), val))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), val), void())
convert a JSON value to any value type
Definition: json.hpp:5838
detail::actual_object_comparator
Definition: json.hpp:3589
detail::actual_object_comparator::object_t
typename BasicJsonType::object_t object_t
Definition: json.hpp:3590
detail::actual_object_comparator::object_comparator_t
typename BasicJsonType::default_object_comparator_t object_comparator_t
Definition: json.hpp:3591
detail::actual_object_comparator::type
typename std::conditional< has_key_compare< object_t >::value, typename object_t::key_compare, object_comparator_t >::type type
Definition: json.hpp:3593
detail::char_traits< signed char >::char_type
signed char char_type
Definition: json.hpp:3636
detail::char_traits< signed char >::eof
static constexpr int_type eof() noexcept
Definition: json.hpp:3650
detail::char_traits< signed char >::int_type
uint64_t int_type
Definition: json.hpp:3637
detail::char_traits< signed char >::to_char_type
static char_type to_char_type(int_type i) noexcept
Definition: json.hpp:3645
detail::char_traits< signed char >::to_int_type
static int_type to_int_type(char_type c) noexcept
Definition: json.hpp:3640
detail::char_traits< unsigned char >::to_char_type
static char_type to_char_type(int_type i) noexcept
Definition: json.hpp:3621
detail::char_traits< unsigned char >::eof
static constexpr int_type eof() noexcept
Definition: json.hpp:3626
detail::char_traits< unsigned char >::char_type
unsigned char char_type
Definition: json.hpp:3612
detail::char_traits< unsigned char >::int_type
uint64_t int_type
Definition: json.hpp:3613
detail::char_traits< unsigned char >::to_int_type
static int_type to_int_type(char_type c) noexcept
Definition: json.hpp:3616
detail::char_traits
Definition: json.hpp:3606
detail::conjunction< B >
Definition: json.hpp:3662
detail::conjunction
Definition: json.hpp:3661
detail::container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType, void_t< decltype(begin(std::declval< ContainerType >()), end(std::declval< ContainerType >()))> >::adapter_type
decltype(input_adapter(begin(std::declval< ContainerType >()), end(std::declval< ContainerType >()))) adapter_type
Definition: json.hpp:6545
detail::container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType, void_t< decltype(begin(std::declval< ContainerType >()), end(std::declval< ContainerType >()))> >::create
static adapter_type create(const ContainerType &container)
Definition: json.hpp:6547
detail::container_input_adapter_factory_impl::container_input_adapter_factory
Definition: json.hpp:6539
detail::detector< Default, void_t< Op< Args... > >, Op, Args... >::value_t
std::true_type value_t
Definition: json.hpp:289
detail::detector< Default, void_t< Op< Args... > >, Op, Args... >::type
Op< Args... > type
Definition: json.hpp:290
detail::detector
Definition: json.hpp:281
detail::detector::value_t
std::false_type value_t
Definition: json.hpp:282
detail::detector::type
Default type
Definition: json.hpp:283
detail::dtoa_impl::boundaries
Definition: json.hpp:17082
detail::dtoa_impl::boundaries::w
diyfp w
Definition: json.hpp:17083
detail::dtoa_impl::boundaries::minus
diyfp minus
Definition: json.hpp:17084
detail::dtoa_impl::boundaries::plus
diyfp plus
Definition: json.hpp:17085
detail::dtoa_impl::cached_power
Definition: json.hpp:17221
detail::dtoa_impl::cached_power::f
std::uint64_t f
Definition: json.hpp:17222
detail::dtoa_impl::cached_power::e
int e
Definition: json.hpp:17223
detail::dtoa_impl::cached_power::k
int k
Definition: json.hpp:17224
detail::dtoa_impl::diyfp
Definition: json.hpp:16964
detail::dtoa_impl::diyfp::mul
static diyfp mul(const diyfp &x, const diyfp &y) noexcept
returns x * y
Definition: json.hpp:16988
detail::dtoa_impl::diyfp::normalize_to
static diyfp normalize_to(const diyfp &x, const int target_exponent) noexcept
normalize x such that the result has the exponent E
Definition: json.hpp:17070
detail::dtoa_impl::diyfp::normalize
static diyfp normalize(diyfp x) noexcept
normalize x such that the significand is >= 2^(q-1)
Definition: json.hpp:17053
detail::dtoa_impl::diyfp::sub
static diyfp sub(const diyfp &x, const diyfp &y) noexcept
returns x - y
Definition: json.hpp:16976
detail::dtoa_impl::diyfp::diyfp
constexpr diyfp(std::uint64_t f_, int e_) noexcept
Definition: json.hpp:16970
detail::dtoa_impl::diyfp::kPrecision
static constexpr int kPrecision
Definition: json.hpp:16965
detail::dtoa_impl::diyfp::f
std::uint64_t f
Definition: json.hpp:16967
detail::dtoa_impl::diyfp::e
int e
Definition: json.hpp:16968
detail::external_constructor< value_t::array >::construct
static void construct(BasicJsonType &j, const std::vector< bool > &arr)
Definition: json.hpp:5568
detail::external_constructor< value_t::array >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::array_t &&arr)
Definition: json.hpp:5543
detail::external_constructor< value_t::array >::construct
static void construct(BasicJsonType &j, const typename BasicJsonType::array_t &arr)
Definition: json.hpp:5533
detail::external_constructor< value_t::array >::construct
static void construct(BasicJsonType &j, const CompatibleArrayType &arr)
Definition: json.hpp:5555
detail::external_constructor< value_t::array >::construct
static void construct(BasicJsonType &j, const std::valarray< T > &arr)
Definition: json.hpp:5584
detail::external_constructor< value_t::binary >::construct
static void construct(BasicJsonType &j, const typename BasicJsonType::binary_t &b)
Definition: json.hpp:5472
detail::external_constructor< value_t::binary >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::binary_t &&b)
Definition: json.hpp:5481
detail::external_constructor< value_t::boolean >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::boolean_t b) noexcept
Definition: json.hpp:5426
detail::external_constructor< value_t::number_float >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::number_float_t val) noexcept
Definition: json.hpp:5494
detail::external_constructor< value_t::number_integer >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::number_integer_t val) noexcept
Definition: json.hpp:5520
detail::external_constructor< value_t::number_unsigned >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::number_unsigned_t val) noexcept
Definition: json.hpp:5507
detail::external_constructor< value_t::object >::construct
static void construct(BasicJsonType &j, const typename BasicJsonType::object_t &obj)
Definition: json.hpp:5603
detail::external_constructor< value_t::object >::construct
static void construct(BasicJsonType &j, const CompatibleObjectType &obj)
Definition: json.hpp:5624
detail::external_constructor< value_t::object >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::object_t &&obj)
Definition: json.hpp:5613
detail::external_constructor< value_t::string >::construct
static void construct(BasicJsonType &j, typename BasicJsonType::string_t &&s)
Definition: json.hpp:5448
detail::external_constructor< value_t::string >::construct
static void construct(BasicJsonType &j, const CompatibleStringType &str)
Definition: json.hpp:5459
detail::external_constructor< value_t::string >::construct
static void construct(BasicJsonType &j, const typename BasicJsonType::string_t &s)
Definition: json.hpp:5439
detail::external_constructor
Definition: json.hpp:5420
detail::from_json_fn
Definition: json.hpp:5100
detail::from_json_fn::operator()
auto operator()(const BasicJsonType &j, T &&val) const noexcept(noexcept(from_json(j, std::forward< T >(val)))) -> decltype(from_json(j, std::forward< T >(val)))
Definition: json.hpp:5102
detail::has_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >::serializer
typename BasicJsonType::template json_serializer< T, void > serializer
Definition: json.hpp:3543
detail::has_from_json
Definition: json.hpp:3528
detail::has_key_compare
Definition: json.hpp:3584
detail::has_non_default_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >::serializer
typename BasicJsonType::template json_serializer< T, void > serializer
Definition: json.hpp:3558
detail::has_non_default_from_json
Definition: json.hpp:3553
detail::has_to_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >::serializer
typename BasicJsonType::template json_serializer< T, void > serializer
Definition: json.hpp:3573
detail::has_to_json
Definition: json.hpp:3568
detail::identity_tag
Definition: json.hpp:4616
detail::integer_sequence
Definition: json.hpp:3124
detail::integer_sequence::value_type
T value_type
Definition: json.hpp:3125
detail::integer_sequence::size
static constexpr std::size_t size() noexcept
Definition: json.hpp:3126
detail::internal_iterator
an iterator value
Definition: json.hpp:12848
detail::internal_iterator::array_iterator
BasicJsonType::array_t::iterator array_iterator
iterator for JSON arrays
Definition: json.hpp:12852
detail::internal_iterator::primitive_iterator
primitive_iterator_t primitive_iterator
generic iterator for all other types
Definition: json.hpp:12854
detail::internal_iterator::object_iterator
BasicJsonType::object_t::iterator object_iterator
iterator for JSON objects
Definition: json.hpp:12850
detail::is_basic_json_context
Definition: json.hpp:3477
detail::is_basic_json
Definition: json.hpp:3464
detail::is_c_string
Definition: json.hpp:4182
detail::is_comparable
Definition: json.hpp:3978
detail::is_compatible_array_type_impl
Definition: json.hpp:3842
detail::is_compatible_array_type
Definition: json.hpp:3861
detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value &&std::is_integral< CompatibleNumberIntegerType >::value &&!std::is_same< bool, CompatibleNumberIntegerType >::value > >::RealLimits
std::numeric_limits< RealIntegerType > RealLimits
Definition: json.hpp:3919
detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value &&std::is_integral< CompatibleNumberIntegerType >::value &&!std::is_same< bool, CompatibleNumberIntegerType >::value > >::CompatibleLimits
std::numeric_limits< CompatibleNumberIntegerType > CompatibleLimits
Definition: json.hpp:3920
detail::is_compatible_integer_type_impl
Definition: json.hpp:3909
detail::is_compatible_integer_type
Definition: json.hpp:3932
detail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value &&is_detected< key_type_t, CompatibleObjectType >::value > >::object_t
typename BasicJsonType::object_t object_t
Definition: json.hpp:3770
detail::is_compatible_object_type_impl
Definition: json.hpp:3762
detail::is_compatible_object_type
Definition: json.hpp:3782
detail::is_compatible_string_type
Definition: json.hpp:3819
detail::is_compatible_string_type::value
static constexpr auto value
Definition: json.hpp:3820
detail::is_compatible_type_impl
Definition: json.hpp:3935
detail::is_compatible_type
Definition: json.hpp:3948
detail::is_complete_type
Definition: json.hpp:3755
detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< !std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value &&!is_compatible_string_type< BasicJsonType, ConstructibleArrayType >::value &&is_default_constructible< ConstructibleArrayType >::value &&(std::is_move_assignable< ConstructibleArrayType >::value||std::is_copy_assignable< ConstructibleArrayType >::value) &&is_detected< iterator_t, ConstructibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, ConstructibleArrayType > > >::value &&is_detected< range_value_t, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, detected_t< range_value_t, ConstructibleArrayType > >::value &&is_complete_type< detected_t< range_value_t, ConstructibleArrayType > >::value > >::value_type
range_value_t< ConstructibleArrayType > value_type
Definition: json.hpp:3891
detail::is_constructible_array_type_impl
Definition: json.hpp:3864
detail::is_constructible_array_type
Definition: json.hpp:3905
detail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value &&is_detected< key_type_t, ConstructibleObjectType >::value > >::object_t
typename BasicJsonType::object_t object_t
Definition: json.hpp:3794
detail::is_constructible_object_type_impl
Definition: json.hpp:3786
detail::is_constructible_object_type
Definition: json.hpp:3815
detail::is_constructible_string_type
Definition: json.hpp:3826
detail::is_constructible_string_type::laundered_type
ConstructibleStringType laundered_type
Definition: json.hpp:3831
detail::is_constructible_string_type::value
static constexpr auto value
Definition: json.hpp:3834
detail::is_constructible_tuple
Definition: json.hpp:3951
detail::is_constructible
Definition: json.hpp:3693
detail::is_default_constructible
Definition: json.hpp:3674
detail::is_detected_lazy
Definition: json.hpp:297
detail::is_getable
Definition: json.hpp:3536
detail::is_getable::value
static constexpr bool value
Definition: json.hpp:3537
detail::is_iterator_of_multibyte
Definition: json.hpp:6498
detail::is_iterator_of_multibyte::value_type
typename std::iterator_traits< T >::value_type value_type
Definition: json.hpp:6499
detail::is_iterator_traits
Definition: json.hpp:3708
detail::is_json_iterator_of
Definition: json.hpp:3957
detail::is_json_ref
Definition: json.hpp:3487
detail::is_ordered_map::two
Definition: json.hpp:4039
detail::is_ordered_map::two::x
char x[2]
Definition: json.hpp:4040
detail::is_ordered_map
Definition: json.hpp:4035
detail::is_ordered_map::test
static one test(decltype(&C::capacity))
detail::is_ordered_map::value
@ value
Definition: json.hpp:4046
detail::is_ordered_map::one
char one
Definition: json.hpp:4036
detail::is_ordered_map::test
static two test(...)
detail::is_range
Definition: json.hpp:3727
detail::is_range::value
static constexpr bool value
Definition: json.hpp:3741
detail::is_sax_static_asserts
Definition: json.hpp:9117
detail::is_sax
Definition: json.hpp:9086
detail::is_sax::value
static constexpr bool value
Definition: json.hpp:9099
detail::is_specialization_of
Definition: json.hpp:3968
detail::is_transparent
Definition: json.hpp:4204
detail::iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >::char_type
typename std::iterator_traits< iterator_type >::value_type char_type
Definition: json.hpp:6510
detail::iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >::create
static adapter_type create(IteratorType first, IteratorType last)
Definition: json.hpp:6514
detail::iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >::iterator_type
IteratorType iterator_type
Definition: json.hpp:6509
detail::iterator_input_adapter_factory
Definition: json.hpp:6485
detail::iterator_input_adapter_factory::adapter_type
iterator_input_adapter< iterator_type > adapter_type
Definition: json.hpp:6488
detail::iterator_input_adapter_factory::char_type
typename std::iterator_traits< iterator_type >::value_type char_type
Definition: json.hpp:6487
detail::iterator_input_adapter_factory::create
static adapter_type create(IteratorType first, IteratorType last)
Definition: json.hpp:6490
detail::iterator_input_adapter_factory::iterator_type
IteratorType iterator_type
Definition: json.hpp:6486
detail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > >::value_type
T value_type
Definition: json.hpp:3305
detail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > >::pointer
T * pointer
Definition: json.hpp:3307
detail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > >::difference_type
ptrdiff_t difference_type
Definition: json.hpp:3306
detail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > >::reference
T & reference
Definition: json.hpp:3308
detail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > >::iterator_category
std::random_access_iterator_tag iterator_category
Definition: json.hpp:3304
detail::iterator_traits
Definition: json.hpp:3292
detail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >::iterator_category
typename It::iterator_category iterator_category
Definition: json.hpp:3285
detail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >::difference_type
typename It::difference_type difference_type
Definition: json.hpp:3281
detail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >::value_type
typename It::value_type value_type
Definition: json.hpp:3282
detail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >::reference
typename It::reference reference
Definition: json.hpp:3284
detail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >::pointer
typename It::pointer pointer
Definition: json.hpp:3283
detail::iterator_types
Definition: json.hpp:3273
detail::json_default_base
Default base class of the basic_json class.
Definition: json.hpp:13787
detail::make_void
Definition: json.hpp:252
detail::make_void::type
void type
Definition: json.hpp:253
detail::negation
Definition: json.hpp:3668
detail::nonesuch
Definition: json.hpp:267
detail::nonesuch::nonesuch
nonesuch(nonesuch const &&)=delete
detail::nonesuch::~nonesuch
~nonesuch()=delete
detail::nonesuch::operator=
void operator=(nonesuch &&)=delete
detail::nonesuch::operator=
void operator=(nonesuch const &)=delete
detail::nonesuch::nonesuch
nonesuch(nonesuch const &)=delete
detail::output_adapter_protocol
abstract output adapter interface
Definition: json.hpp:14944
detail::output_adapter_protocol::output_adapter_protocol
output_adapter_protocol(const output_adapter_protocol &)=default
detail::output_adapter_protocol::~output_adapter_protocol
virtual ~output_adapter_protocol()=default
detail::output_adapter_protocol::write_character
virtual void write_character(CharType c)=0
detail::output_adapter_protocol::output_adapter_protocol
output_adapter_protocol(output_adapter_protocol &&) noexcept=default
detail::output_adapter_protocol::output_adapter_protocol
output_adapter_protocol()=default
detail::output_adapter_protocol::write_characters
virtual void write_characters(const CharType *s, std::size_t length)=0
detail::position_t
struct to capture the start position of the current token
Definition: json.hpp:3037
detail::position_t::chars_read_current_line
std::size_t chars_read_current_line
the number of characters read in the current line
Definition: json.hpp:3041
detail::position_t::lines_read
std::size_t lines_read
the number of lines read
Definition: json.hpp:3043
detail::position_t::chars_read_total
std::size_t chars_read_total
the total number of characters read
Definition: json.hpp:3039
detail::priority_tag< 0 >
Definition: json.hpp:3208
detail::priority_tag
Definition: json.hpp:3207
detail::static_const
Definition: json.hpp:3213
detail::static_const::value
static constexpr JSON_INLINE_VARIABLE T value
Definition: json.hpp:3214
detail::to_json_fn
Definition: json.hpp:5801
detail::to_json_fn::operator()
auto operator()(BasicJsonType &j, T &&val) const noexcept(noexcept(to_json(j, std::forward< T >(val)))) -> decltype(to_json(j, std::forward< T >(val)), void())
Definition: json.hpp:5803
detail::utility_internal::Extend
Definition: json.hpp:3144
detail::utility_internal::Gen
Definition: json.hpp:3163
detail::utility_internal::Gen::type
typename Extend< typename Gen< T, N/2 >::type, N/2, N % 2 >::type type
Definition: json.hpp:3165
detail::value_in_range_of_impl1< OfType, T, false >::test
static constexpr bool test(T val)
Definition: json.hpp:4135
detail::value_in_range_of_impl1< OfType, T, true >::test
static constexpr bool test(T)
Definition: json.hpp:4144
detail::value_in_range_of_impl1
Definition: json.hpp:4130
detail::value_in_range_of_impl2< OfType, T, false, false >::test
static constexpr bool test(T val)
Definition: json.hpp:4089
detail::value_in_range_of_impl2< OfType, T, false, true >::test
static constexpr bool test(T val)
Definition: json.hpp:4109
detail::value_in_range_of_impl2< OfType, T, true, false >::test
static constexpr bool test(T val)
Definition: json.hpp:4099
detail::value_in_range_of_impl2< OfType, T, true, true >::test
static constexpr bool test(T val)
Definition: json.hpp:4119
detail::value_in_range_of_impl2
Definition: json.hpp:4084
detail::wide_string_input_helper< BaseInputAdapter, 2 >::fill_buffer
static void fill_buffer(BaseInputAdapter &input, std::array< std::char_traits< char >::int_type, 4 > &utf8_bytes, size_t &utf8_bytes_index, size_t &utf8_bytes_filled)
Definition: json.hpp:6380
detail::wide_string_input_helper< BaseInputAdapter, 4 >::fill_buffer
static void fill_buffer(BaseInputAdapter &input, std::array< std::char_traits< char >::int_type, 4 > &utf8_bytes, size_t &utf8_bytes_index, size_t &utf8_bytes_filled)
Definition: json.hpp:6322
detail::wide_string_input_helper
Definition: json.hpp:6316
json_sax
SAX interface.
Definition: json.hpp:6671
json_sax::binary
virtual bool binary(binary_t &val)=0
a binary value was read
json_sax::number_float
virtual bool number_float(number_float_t val, const string_t &s)=0
a floating-point number was read
json_sax::number_unsigned
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
json_sax::key
virtual bool key(string_t &val)=0
an object key was read
json_sax::json_sax
json_sax()=default
json_sax::string
virtual bool string(string_t &val)=0
a string value was read
json_sax::number_integer
virtual bool number_integer(number_integer_t val)=0
an integer number was read
json_sax::start_object
virtual bool start_object(std::size_t elements)=0
the beginning of an object was read
json_sax::number_integer_t
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.hpp:6672
json_sax::string_t
typename BasicJsonType::string_t string_t
Definition: json.hpp:6675
json_sax::end_array
virtual bool end_array()=0
the end of an array was read
json_sax::json_sax
json_sax(const json_sax &)=default
json_sax::boolean
virtual bool boolean(bool val)=0
a boolean value was read
json_sax::end_object
virtual bool end_object()=0
the end of an object was read
json_sax::number_float_t
typename BasicJsonType::number_float_t number_float_t
Definition: json.hpp:6674
json_sax::number_unsigned_t
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.hpp:6673
json_sax::json_sax
json_sax(json_sax &&) noexcept=default
json_sax::binary_t
typename BasicJsonType::binary_t binary_t
Definition: json.hpp:6676
json_sax::parse_error
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
json_sax::start_array
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
ordered_map
a minimal map-like container that preserves insertion order
Definition: json.hpp:19033
ordered_map::at
const T & at(const key_type &key) const
Definition: json.hpp:19137
ordered_map::Container
std::vector< std::pair< const Key, T >, Allocator > Container
Definition: json.hpp:19036
ordered_map::operator[]
const T & operator[](const key_type &key) const
Definition: json.hpp:19097
ordered_map::emplace
std::pair< iterator, bool > emplace(KeyType &&key, T &&t)
Definition: json.hpp:19072
ordered_map::value_type
typename Container::value_type value_type
Definition: json.hpp:19040
ordered_map::key_compare
std::equal_to< Key > key_compare
Definition: json.hpp:19044
ordered_map::erase
iterator erase(iterator pos)
Definition: json.hpp:19205
ordered_map::mapped_type
T mapped_type
Definition: json.hpp:19035
ordered_map::ordered_map
ordered_map(const Allocator &alloc) noexcept(noexcept(Container(alloc)))
Definition: json.hpp:19050
ordered_map::iterator
typename Container::iterator iterator
Definition: json.hpp:19037
ordered_map::operator[]
T & operator[](KeyType &&key)
Definition: json.hpp:19092
ordered_map::find
iterator find(const key_type &key)
Definition: json.hpp:19289
ordered_map::at
T & at(const key_type &key)
Definition: json.hpp:19109
ordered_map::erase
iterator erase(iterator first, iterator last)
Definition: json.hpp:19210
ordered_map::find
const_iterator find(const key_type &key) const
Definition: json.hpp:19315
ordered_map::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: json.hpp:19332
ordered_map::erase
size_type erase(KeyType &&key)
Definition: json.hpp:19186
ordered_map::size_type
typename Container::size_type size_type
Definition: json.hpp:19039
ordered_map::at
const T & at(KeyType &&key) const
Definition: json.hpp:19152
ordered_map::emplace
std::pair< iterator, bool > emplace(const key_type &key, T &&t)
Definition: json.hpp:19057
ordered_map::ordered_map
ordered_map() noexcept(noexcept(Container()))
Definition: json.hpp:19049
ordered_map::insert
void insert(InputIt first, InputIt last)
Definition: json.hpp:19350
ordered_map::operator[]
T & operator[](const key_type &key)
Definition: json.hpp:19085
ordered_map::count
size_type count(const key_type &key) const
Definition: json.hpp:19263
ordered_map::erase
size_type erase(const key_type &key)
Definition: json.hpp:19165
ordered_map::insert
std::pair< iterator, bool > insert(value_type &&value)
Definition: json.hpp:19327
ordered_map::ordered_map
ordered_map(std::initializer_list< value_type > init, const Allocator &alloc=Allocator())
Definition: json.hpp:19054
ordered_map::count
size_type count(KeyType &&key) const
Definition: json.hpp:19277
ordered_map::key_type
Key key_type
Definition: json.hpp:19034
ordered_map::ordered_map
ordered_map(It first, It last, const Allocator &alloc=Allocator())
Definition: json.hpp:19052
ordered_map::require_input_iter
typename std::enable_if< std::is_convertible< typename std::iterator_traits< InputIt >::iterator_category, std::input_iterator_tag >::value >::type require_input_iter
Definition: json.hpp:19347
ordered_map::find
iterator find(KeyType &&key)
Definition: json.hpp:19303
ordered_map::at
T & at(KeyType &&key)
Definition: json.hpp:19124
ordered_map::const_iterator
typename Container::const_iterator const_iterator
Definition: json.hpp:19038
ordered_map::operator[]
const T & operator[](KeyType &&key) const
Definition: json.hpp:19104
std::hash< nlohmann::NLOHMANN_BASIC_JSON_TPL >::operator()
std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL &j) const
Definition: json.hpp:24505
std::less< ::nlohmann::detail::value_t >::operator()
bool operator()(::nlohmann::detail::value_t lhs, ::nlohmann::detail::value_t rhs) const noexcept
compare two value_t enum values
Definition: json.hpp:24519
Generated by doxygen 1.9.1