hey! this is a static git repo viewer. commit diffs, file history, older commits and other revisions won't load without javascript.

you are still able to view source files on branch/tag tips, but the experience is degraded.

char-fork/llama.cpp

git clone https://git.t4t.associates/char-fork/llama.cpp

Georgi Gerganovsync : vendor (#13901)53f9250742025-05-30

1//     __ _____ _____ _____
2//  __|  |   __|     |   | |  JSON for Modern C++
3// |  |  |__   |  |  | | | |  version 3.12.0
4// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
5//
6// SPDX-FileCopyrightText: 2013 - 2025 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.12.0
38// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
39//
40// SPDX-FileCopyrightText: 2013 - 2025 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.12.0
51// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
52//
53// SPDX-FileCopyrightText: 2013 - 2025 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 != 12 || NLOHMANN_JSON_VERSION_PATCH != 0
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 12  // NOLINT(modernize-macro-to-enum)
70#define NLOHMANN_JSON_VERSION_PATCH 0   // NOLINT(modernize-macro-to-enum)
71
72#ifndef JSON_DIAGNOSTICS
73    #define JSON_DIAGNOSTICS 0
74#endif
75
76#ifndef JSON_DIAGNOSTIC_POSITIONS
77    #define JSON_DIAGNOSTIC_POSITIONS 0
78#endif
79
80#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
81    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
82#endif
83
84#if JSON_DIAGNOSTICS
85    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
86#else
87    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
88#endif
89
90#if JSON_DIAGNOSTIC_POSITIONS
91    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp
92#else
93    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS
94#endif
95
96#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
97    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
98#else
99    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
100#endif
101
102#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
103    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
104#endif
105
106// Construct the namespace ABI tags component
107#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c
108#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
109    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)
110
111#define NLOHMANN_JSON_ABI_TAGS                                       \
112    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
113            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
114            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
115            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)
116
117// Construct the namespace version component
118#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
119    _v ## major ## _ ## minor ## _ ## patch
120#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
121    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
122
123#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
124#define NLOHMANN_JSON_NAMESPACE_VERSION
125#else
126#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
127    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
128                                           NLOHMANN_JSON_VERSION_MINOR, \
129                                           NLOHMANN_JSON_VERSION_PATCH)
130#endif
131
132// Combine namespace components
133#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
134#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
135    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
136
137#ifndef NLOHMANN_JSON_NAMESPACE
138#define NLOHMANN_JSON_NAMESPACE               \
139    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
140            NLOHMANN_JSON_ABI_TAGS,           \
141            NLOHMANN_JSON_NAMESPACE_VERSION)
142#endif
143
144#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
145#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
146    namespace nlohmann                               \
147    {                                                \
148    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
149                NLOHMANN_JSON_ABI_TAGS,              \
150                NLOHMANN_JSON_NAMESPACE_VERSION)     \
151    {
152#endif
153
154#ifndef NLOHMANN_JSON_NAMESPACE_END
155#define NLOHMANN_JSON_NAMESPACE_END                                     \
156    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
157    }  // namespace nlohmann
158#endif
159
160// #include <nlohmann/detail/conversions/from_json.hpp>
161//     __ _____ _____ _____
162//  __|  |   __|     |   | |  JSON for Modern C++
163// |  |  |__   |  |  | | | |  version 3.12.0
164// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
165//
166// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
167// SPDX-License-Identifier: MIT
168
169
170
171#include <algorithm> // transform
172#include <array> // array
173#include <forward_list> // forward_list
174#include <iterator> // inserter, front_inserter, end
175#include <map> // map
176#ifdef JSON_HAS_CPP_17
177    #include <optional> // optional
178#endif
179#include <string> // string
180#include <tuple> // tuple, make_tuple
181#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
182#include <unordered_map> // unordered_map
183#include <utility> // pair, declval
184#include <valarray> // valarray
185
186// #include <nlohmann/detail/exceptions.hpp>
187//     __ _____ _____ _____
188//  __|  |   __|     |   | |  JSON for Modern C++
189// |  |  |__   |  |  | | | |  version 3.12.0
190// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
191//
192// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
193// SPDX-License-Identifier: MIT
194
195
196
197#include <cstddef> // nullptr_t
198#include <exception> // exception
199#if JSON_DIAGNOSTICS
200    #include <numeric> // accumulate
201#endif
202#include <stdexcept> // runtime_error
203#include <string> // to_string
204#include <vector> // vector
205
206// #include <nlohmann/detail/value_t.hpp>
207//     __ _____ _____ _____
208//  __|  |   __|     |   | |  JSON for Modern C++
209// |  |  |__   |  |  | | | |  version 3.12.0
210// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
211//
212// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
213// SPDX-License-Identifier: MIT
214
215
216
217#include <array> // array
218#include <cstddef> // size_t
219#include <cstdint> // uint8_t
220#include <string> // string
221
222// #include <nlohmann/detail/macro_scope.hpp>
223//     __ _____ _____ _____
224//  __|  |   __|     |   | |  JSON for Modern C++
225// |  |  |__   |  |  | | | |  version 3.12.0
226// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
227//
228// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
229// SPDX-License-Identifier: MIT
230
231
232
233#include <utility> // declval, pair
234// #include <nlohmann/detail/meta/detected.hpp>
235//     __ _____ _____ _____
236//  __|  |   __|     |   | |  JSON for Modern C++
237// |  |  |__   |  |  | | | |  version 3.12.0
238// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
239//
240// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
241// SPDX-License-Identifier: MIT
242
243
244
245#include <type_traits>
246
247// #include <nlohmann/detail/meta/void_t.hpp>
248//     __ _____ _____ _____
249//  __|  |   __|     |   | |  JSON for Modern C++
250// |  |  |__   |  |  | | | |  version 3.12.0
251// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
252//
253// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
254// SPDX-License-Identifier: MIT
255
256
257
258// #include <nlohmann/detail/abi_macros.hpp>
259
260
261NLOHMANN_JSON_NAMESPACE_BEGIN
262namespace detail
263{
264
265template<typename ...Ts> struct make_void
266{
267    using type = void;
268};
269template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
270
271}  // namespace detail
272NLOHMANN_JSON_NAMESPACE_END
273
274
275NLOHMANN_JSON_NAMESPACE_BEGIN
276namespace detail
277{
278
279// https://en.cppreference.com/w/cpp/experimental/is_detected
280struct nonesuch
281{
282    nonesuch() = delete;
283    ~nonesuch() = delete;
284    nonesuch(nonesuch const&) = delete;
285    nonesuch(nonesuch const&&) = delete;
286    void operator=(nonesuch const&) = delete;
287    void operator=(nonesuch&&) = delete;
288};
289
290template<class Default,
291         class AlwaysVoid,
292         template<class...> class Op,
293         class... Args>
294struct detector
295{
296    using value_t = std::false_type;
297    using type = Default;
298};
299
300template<class Default, template<class...> class Op, class... Args>
301struct detector<Default, void_t<Op<Args...>>, Op, Args...>
302{
303    using value_t = std::true_type;
304    using type = Op<Args...>;
305};
306
307template<template<class...> class Op, class... Args>
308using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
309
310template<template<class...> class Op, class... Args>
311struct is_detected_lazy : is_detected<Op, Args...> { };
312
313template<template<class...> class Op, class... Args>
314using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
315
316template<class Default, template<class...> class Op, class... Args>
317using detected_or = detector<Default, void, Op, Args...>;
318
319template<class Default, template<class...> class Op, class... Args>
320using detected_or_t = typename detected_or<Default, Op, Args...>::type;
321
322template<class Expected, template<class...> class Op, class... Args>
323using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
324
325template<class To, template<class...> class Op, class... Args>
326using is_detected_convertible =
327    std::is_convertible<detected_t<Op, Args...>, To>;
328
329}  // namespace detail
330NLOHMANN_JSON_NAMESPACE_END
331
332// #include <nlohmann/thirdparty/hedley/hedley.hpp>
333
334
335//     __ _____ _____ _____
336//  __|  |   __|     |   | |  JSON for Modern C++
337// |  |  |__   |  |  | | | |  version 3.12.0
338// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
339//
340// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
341// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson <evan@nemerson.com>
342// SPDX-License-Identifier: MIT
343
344/* Hedley - https://nemequ.github.io/hedley
345 * Created by Evan Nemerson <evan@nemerson.com>
346 */
347
348#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
349#if defined(JSON_HEDLEY_VERSION)
350    #undef JSON_HEDLEY_VERSION
351#endif
352#define JSON_HEDLEY_VERSION 15
353
354#if defined(JSON_HEDLEY_STRINGIFY_EX)
355    #undef JSON_HEDLEY_STRINGIFY_EX
356#endif
357#define JSON_HEDLEY_STRINGIFY_EX(x) #x
358
359#if defined(JSON_HEDLEY_STRINGIFY)
360    #undef JSON_HEDLEY_STRINGIFY
361#endif
362#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
363
364#if defined(JSON_HEDLEY_CONCAT_EX)
365    #undef JSON_HEDLEY_CONCAT_EX
366#endif
367#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
368
369#if defined(JSON_HEDLEY_CONCAT)
370    #undef JSON_HEDLEY_CONCAT
371#endif
372#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
373
374#if defined(JSON_HEDLEY_CONCAT3_EX)
375    #undef JSON_HEDLEY_CONCAT3_EX
376#endif
377#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
378
379#if defined(JSON_HEDLEY_CONCAT3)
380    #undef JSON_HEDLEY_CONCAT3
381#endif
382#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
383
384#if defined(JSON_HEDLEY_VERSION_ENCODE)
385    #undef JSON_HEDLEY_VERSION_ENCODE
386#endif
387#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
388
389#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
390    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
391#endif
392#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
393
394#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
395    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
396#endif
397#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
398
399#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
400    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
401#endif
402#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
403
404#if defined(JSON_HEDLEY_GNUC_VERSION)
405    #undef JSON_HEDLEY_GNUC_VERSION
406#endif
407#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
408    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
409#elif defined(__GNUC__)
410    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
411#endif
412
413#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
414    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
415#endif
416#if defined(JSON_HEDLEY_GNUC_VERSION)
417    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
418#else
419    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
420#endif
421
422#if defined(JSON_HEDLEY_MSVC_VERSION)
423    #undef JSON_HEDLEY_MSVC_VERSION
424#endif
425#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
426    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
427#elif defined(_MSC_FULL_VER) && !defined(__ICL)
428    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
429#elif defined(_MSC_VER) && !defined(__ICL)
430    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
431#endif
432
433#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
434    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
435#endif
436#if !defined(JSON_HEDLEY_MSVC_VERSION)
437    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
438#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
439    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
440#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
441    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
442#else
443    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
444#endif
445
446#if defined(JSON_HEDLEY_INTEL_VERSION)
447    #undef JSON_HEDLEY_INTEL_VERSION
448#endif
449#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
450    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
451#elif defined(__INTEL_COMPILER) && !defined(__ICL)
452    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
453#endif
454
455#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
456    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
457#endif
458#if defined(JSON_HEDLEY_INTEL_VERSION)
459    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
460#else
461    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
462#endif
463
464#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
465    #undef JSON_HEDLEY_INTEL_CL_VERSION
466#endif
467#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
468    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
469#endif
470
471#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
472    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
473#endif
474#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
475    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
476#else
477    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
478#endif
479
480#if defined(JSON_HEDLEY_PGI_VERSION)
481    #undef JSON_HEDLEY_PGI_VERSION
482#endif
483#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
484    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
485#endif
486
487#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
488    #undef JSON_HEDLEY_PGI_VERSION_CHECK
489#endif
490#if defined(JSON_HEDLEY_PGI_VERSION)
491    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
492#else
493    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
494#endif
495
496#if defined(JSON_HEDLEY_SUNPRO_VERSION)
497    #undef JSON_HEDLEY_SUNPRO_VERSION
498#endif
499#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
500    #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)
501#elif defined(__SUNPRO_C)
502    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
503#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
504    #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)
505#elif defined(__SUNPRO_CC)
506    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
507#endif
508
509#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
510    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
511#endif
512#if defined(JSON_HEDLEY_SUNPRO_VERSION)
513    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
514#else
515    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
516#endif
517
518#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
519    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
520#endif
521#if defined(__EMSCRIPTEN__)
522    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
523#endif
524
525#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
526    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
527#endif
528#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
529    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
530#else
531    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
532#endif
533
534#if defined(JSON_HEDLEY_ARM_VERSION)
535    #undef JSON_HEDLEY_ARM_VERSION
536#endif
537#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
538    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
539#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
540    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
541#endif
542
543#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
544    #undef JSON_HEDLEY_ARM_VERSION_CHECK
545#endif
546#if defined(JSON_HEDLEY_ARM_VERSION)
547    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
548#else
549    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
550#endif
551
552#if defined(JSON_HEDLEY_IBM_VERSION)
553    #undef JSON_HEDLEY_IBM_VERSION
554#endif
555#if defined(__ibmxl__)
556    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
557#elif defined(__xlC__) && defined(__xlC_ver__)
558    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
559#elif defined(__xlC__)
560    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
561#endif
562
563#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
564    #undef JSON_HEDLEY_IBM_VERSION_CHECK
565#endif
566#if defined(JSON_HEDLEY_IBM_VERSION)
567    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
568#else
569    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
570#endif
571
572#if defined(JSON_HEDLEY_TI_VERSION)
573    #undef JSON_HEDLEY_TI_VERSION
574#endif
575#if \
576    defined(__TI_COMPILER_VERSION__) && \
577    ( \
578      defined(__TMS470__) || defined(__TI_ARM__) || \
579      defined(__MSP430__) || \
580      defined(__TMS320C2000__) \
581    )
582#if (__TI_COMPILER_VERSION__ >= 16000000)
583    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
584#endif
585#endif
586
587#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
588    #undef JSON_HEDLEY_TI_VERSION_CHECK
589#endif
590#if defined(JSON_HEDLEY_TI_VERSION)
591    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
592#else
593    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
594#endif
595
596#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
597    #undef JSON_HEDLEY_TI_CL2000_VERSION
598#endif
599#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
600    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
601#endif
602
603#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
604    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
605#endif
606#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
607    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
608#else
609    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
610#endif
611
612#if defined(JSON_HEDLEY_TI_CL430_VERSION)
613    #undef JSON_HEDLEY_TI_CL430_VERSION
614#endif
615#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
616    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
617#endif
618
619#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
620    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
621#endif
622#if defined(JSON_HEDLEY_TI_CL430_VERSION)
623    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
624#else
625    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
626#endif
627
628#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
629    #undef JSON_HEDLEY_TI_ARMCL_VERSION
630#endif
631#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
632    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
633#endif
634
635#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
636    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
637#endif
638#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
639    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
640#else
641    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
642#endif
643
644#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
645    #undef JSON_HEDLEY_TI_CL6X_VERSION
646#endif
647#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
648    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
649#endif
650
651#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
652    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
653#endif
654#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
655    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
656#else
657    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
658#endif
659
660#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
661    #undef JSON_HEDLEY_TI_CL7X_VERSION
662#endif
663#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
664    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
665#endif
666
667#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
668    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
669#endif
670#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
671    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
672#else
673    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
674#endif
675
676#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
677    #undef JSON_HEDLEY_TI_CLPRU_VERSION
678#endif
679#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
680    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
681#endif
682
683#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
684    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
685#endif
686#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
687    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
688#else
689    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
690#endif
691
692#if defined(JSON_HEDLEY_CRAY_VERSION)
693    #undef JSON_HEDLEY_CRAY_VERSION
694#endif
695#if defined(_CRAYC)
696    #if defined(_RELEASE_PATCHLEVEL)
697        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
698    #else
699        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
700    #endif
701#endif
702
703#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
704    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
705#endif
706#if defined(JSON_HEDLEY_CRAY_VERSION)
707    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
708#else
709    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
710#endif
711
712#if defined(JSON_HEDLEY_IAR_VERSION)
713    #undef JSON_HEDLEY_IAR_VERSION
714#endif
715#if defined(__IAR_SYSTEMS_ICC__)
716    #if __VER__ > 1000
717        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
718    #else
719        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
720    #endif
721#endif
722
723#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
724    #undef JSON_HEDLEY_IAR_VERSION_CHECK
725#endif
726#if defined(JSON_HEDLEY_IAR_VERSION)
727    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
728#else
729    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
730#endif
731
732#if defined(JSON_HEDLEY_TINYC_VERSION)
733    #undef JSON_HEDLEY_TINYC_VERSION
734#endif
735#if defined(__TINYC__)
736    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
737#endif
738
739#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
740    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
741#endif
742#if defined(JSON_HEDLEY_TINYC_VERSION)
743    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
744#else
745    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
746#endif
747
748#if defined(JSON_HEDLEY_DMC_VERSION)
749    #undef JSON_HEDLEY_DMC_VERSION
750#endif
751#if defined(__DMC__)
752    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
753#endif
754
755#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
756    #undef JSON_HEDLEY_DMC_VERSION_CHECK
757#endif
758#if defined(JSON_HEDLEY_DMC_VERSION)
759    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
760#else
761    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
762#endif
763
764#if defined(JSON_HEDLEY_COMPCERT_VERSION)
765    #undef JSON_HEDLEY_COMPCERT_VERSION
766#endif
767#if defined(__COMPCERT_VERSION__)
768    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
769#endif
770
771#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
772    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
773#endif
774#if defined(JSON_HEDLEY_COMPCERT_VERSION)
775    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
776#else
777    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
778#endif
779
780#if defined(JSON_HEDLEY_PELLES_VERSION)
781    #undef JSON_HEDLEY_PELLES_VERSION
782#endif
783#if defined(__POCC__)
784    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
785#endif
786
787#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
788    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
789#endif
790#if defined(JSON_HEDLEY_PELLES_VERSION)
791    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
792#else
793    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
794#endif
795
796#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
797    #undef JSON_HEDLEY_MCST_LCC_VERSION
798#endif
799#if defined(__LCC__) && defined(__LCC_MINOR__)
800    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
801#endif
802
803#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
804    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
805#endif
806#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
807    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
808#else
809    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
810#endif
811
812#if defined(JSON_HEDLEY_GCC_VERSION)
813    #undef JSON_HEDLEY_GCC_VERSION
814#endif
815#if \
816    defined(JSON_HEDLEY_GNUC_VERSION) && \
817    !defined(__clang__) && \
818    !defined(JSON_HEDLEY_INTEL_VERSION) && \
819    !defined(JSON_HEDLEY_PGI_VERSION) && \
820    !defined(JSON_HEDLEY_ARM_VERSION) && \
821    !defined(JSON_HEDLEY_CRAY_VERSION) && \
822    !defined(JSON_HEDLEY_TI_VERSION) && \
823    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
824    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
825    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
826    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
827    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
828    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
829    !defined(__COMPCERT__) && \
830    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
831    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
832#endif
833
834#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
835    #undef JSON_HEDLEY_GCC_VERSION_CHECK
836#endif
837#if defined(JSON_HEDLEY_GCC_VERSION)
838    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
839#else
840    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
841#endif
842
843#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
844    #undef JSON_HEDLEY_HAS_ATTRIBUTE
845#endif
846#if \
847  defined(__has_attribute) && \
848  ( \
849    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
850  )
851#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
852#else
853#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
854#endif
855
856#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
857    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
858#endif
859#if defined(__has_attribute)
860    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
861#else
862    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
863#endif
864
865#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
866    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
867#endif
868#if defined(__has_attribute)
869    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
870#else
871    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
872#endif
873
874#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
875    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
876#endif
877#if \
878    defined(__has_cpp_attribute) && \
879    defined(__cplusplus) && \
880    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
881    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
882#else
883    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
884#endif
885
886#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
887    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
888#endif
889#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
890    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
891#elif \
892    !defined(JSON_HEDLEY_PGI_VERSION) && \
893    !defined(JSON_HEDLEY_IAR_VERSION) && \
894    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
895    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
896    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
897#else
898    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
899#endif
900
901#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
902    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
903#endif
904#if defined(__has_cpp_attribute) && defined(__cplusplus)
905    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
906#else
907    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
908#endif
909
910#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
911    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
912#endif
913#if defined(__has_cpp_attribute) && defined(__cplusplus)
914    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
915#else
916    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
917#endif
918
919#if defined(JSON_HEDLEY_HAS_BUILTIN)
920    #undef JSON_HEDLEY_HAS_BUILTIN
921#endif
922#if defined(__has_builtin)
923    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
924#else
925    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
926#endif
927
928#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
929    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
930#endif
931#if defined(__has_builtin)
932    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
933#else
934    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
935#endif
936
937#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
938    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
939#endif
940#if defined(__has_builtin)
941    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
942#else
943    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
944#endif
945
946#if defined(JSON_HEDLEY_HAS_FEATURE)
947    #undef JSON_HEDLEY_HAS_FEATURE
948#endif
949#if defined(__has_feature)
950    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
951#else
952    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
953#endif
954
955#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
956    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
957#endif
958#if defined(__has_feature)
959    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
960#else
961    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
962#endif
963
964#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
965    #undef JSON_HEDLEY_GCC_HAS_FEATURE
966#endif
967#if defined(__has_feature)
968    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
969#else
970    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
971#endif
972
973#if defined(JSON_HEDLEY_HAS_EXTENSION)
974    #undef JSON_HEDLEY_HAS_EXTENSION
975#endif
976#if defined(__has_extension)
977    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
978#else
979    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
980#endif
981
982#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
983    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
984#endif
985#if defined(__has_extension)
986    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
987#else
988    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
989#endif
990
991#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
992    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
993#endif
994#if defined(__has_extension)
995    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
996#else
997    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
998#endif
999
1000#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
1001    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
1002#endif
1003#if defined(__has_declspec_attribute)
1004    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
1005#else
1006    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
1007#endif
1008
1009#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
1010    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
1011#endif
1012#if defined(__has_declspec_attribute)
1013    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
1014#else
1015    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
1016#endif
1017
1018#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
1019    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
1020#endif
1021#if defined(__has_declspec_attribute)
1022    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
1023#else
1024    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1025#endif
1026
1027#if defined(JSON_HEDLEY_HAS_WARNING)
1028    #undef JSON_HEDLEY_HAS_WARNING
1029#endif
1030#if defined(__has_warning)
1031    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
1032#else
1033    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
1034#endif
1035
1036#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
1037    #undef JSON_HEDLEY_GNUC_HAS_WARNING
1038#endif
1039#if defined(__has_warning)
1040    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
1041#else
1042    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
1043#endif
1044
1045#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
1046    #undef JSON_HEDLEY_GCC_HAS_WARNING
1047#endif
1048#if defined(__has_warning)
1049    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
1050#else
1051    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1052#endif
1053
1054#if \
1055    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1056    defined(__clang__) || \
1057    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1058    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1059    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1060    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1061    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1062    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1063    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1064    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1065    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1066    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
1067    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1068    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1069    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
1070    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
1071    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
1072    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
1073    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
1074#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1075    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
1076#else
1077    #define JSON_HEDLEY_PRAGMA(value)
1078#endif
1079
1080#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
1081    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
1082#endif
1083#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
1084    #undef JSON_HEDLEY_DIAGNOSTIC_POP
1085#endif
1086#if defined(__clang__)
1087    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
1088    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
1089#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1090    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
1091    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
1092#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1093    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
1094    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
1095#elif \
1096    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
1097    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1098    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
1099    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
1100#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
1101    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
1102    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
1103#elif \
1104    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1105    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1106    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
1107    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1108    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1109    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1110    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
1111    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
1112#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1113    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
1114    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
1115#else
1116    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
1117    #define JSON_HEDLEY_DIAGNOSTIC_POP
1118#endif
1119
1120/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
1121   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
1122#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1123    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
1124#endif
1125#if defined(__cplusplus)
1126#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
1127#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
1128#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
1129#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1130    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1131    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1132    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
1133    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
1134    xpr \
1135    JSON_HEDLEY_DIAGNOSTIC_POP
1136#      else
1137#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1138    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1139    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1140    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
1141    xpr \
1142    JSON_HEDLEY_DIAGNOSTIC_POP
1143#      endif
1144#    else
1145#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1146    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1147    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1148    xpr \
1149    JSON_HEDLEY_DIAGNOSTIC_POP
1150#    endif
1151#  endif
1152#endif
1153#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1154    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
1155#endif
1156
1157#if defined(JSON_HEDLEY_CONST_CAST)
1158    #undef JSON_HEDLEY_CONST_CAST
1159#endif
1160#if defined(__cplusplus)
1161#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1162#elif \
1163  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1164  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1165  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1166#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1167        JSON_HEDLEY_DIAGNOSTIC_PUSH \
1168        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1169        ((T) (expr)); \
1170        JSON_HEDLEY_DIAGNOSTIC_POP \
1171    }))
1172#else
1173#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1174#endif
1175
1176#if defined(JSON_HEDLEY_REINTERPRET_CAST)
1177    #undef JSON_HEDLEY_REINTERPRET_CAST
1178#endif
1179#if defined(__cplusplus)
1180    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1181#else
1182    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1183#endif
1184
1185#if defined(JSON_HEDLEY_STATIC_CAST)
1186    #undef JSON_HEDLEY_STATIC_CAST
1187#endif
1188#if defined(__cplusplus)
1189    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1190#else
1191    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1192#endif
1193
1194#if defined(JSON_HEDLEY_CPP_CAST)
1195    #undef JSON_HEDLEY_CPP_CAST
1196#endif
1197#if defined(__cplusplus)
1198#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1199#    define JSON_HEDLEY_CPP_CAST(T, expr) \
1200    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1201    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1202    ((T) (expr)) \
1203    JSON_HEDLEY_DIAGNOSTIC_POP
1204#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1205#    define JSON_HEDLEY_CPP_CAST(T, expr) \
1206    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1207    _Pragma("diag_suppress=Pe137") \
1208    JSON_HEDLEY_DIAGNOSTIC_POP
1209#  else
1210#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1211#  endif
1212#else
1213#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1214#endif
1215
1216#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1217    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1218#endif
1219#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1220    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1221#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1222    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1223#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1224    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1225#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1226    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1227#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1228    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1229#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1230    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1231#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1232    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1233#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1234    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1235#elif \
1236    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1237    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1238    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1239    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1240    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1241    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1242    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1243    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1244    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1245    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1246    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1247    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1248#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1249    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1250#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1251    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1252#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1253    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1254#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1255    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1256#else
1257    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1258#endif
1259
1260#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1261    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1262#endif
1263#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1264    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1265#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1266    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1267#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1268    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1269#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1270    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1271#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1272    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1273#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1274    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1275#elif \
1276    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1277    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1278    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1279    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1280    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1281#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1282    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1283#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1284    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1285#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1286    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1287#else
1288    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1289#endif
1290
1291#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1292    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1293#endif
1294#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1295    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1296#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1297    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1298#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1299    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1300#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1301    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1302#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1303    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1304#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1305    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1306#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1307    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1308#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1309    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1310#elif \
1311    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1312    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1313    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1314    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1315#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1316    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1317#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1318    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1319#else
1320    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1321#endif
1322
1323#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1324    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1325#endif
1326#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1327    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1328#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1329    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1330#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1331    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1332#else
1333    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1334#endif
1335
1336#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1337    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1338#endif
1339#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1340    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1341#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1342    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1343#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1344    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1345#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1346    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1347#else
1348    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1349#endif
1350
1351#if defined(JSON_HEDLEY_DEPRECATED)
1352    #undef JSON_HEDLEY_DEPRECATED
1353#endif
1354#if defined(JSON_HEDLEY_DEPRECATED_FOR)
1355    #undef JSON_HEDLEY_DEPRECATED_FOR
1356#endif
1357#if \
1358    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1359    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1360    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1361    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1362#elif \
1363    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1364    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1365    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1366    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1367    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1368    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1369    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1370    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1371    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1372    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1373    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1374    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1375    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1376    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1377#elif defined(__cplusplus) && (__cplusplus >= 201402L)
1378    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1379    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1380#elif \
1381    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1382    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1383    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1384    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1385    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1386    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1387    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1388    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1389    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1390    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1391    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1392    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1393    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1394    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1395    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1396    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1397    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1398    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1399#elif \
1400    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1401    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1402    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1403    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1404    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1405#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1406    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1407    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1408#else
1409    #define JSON_HEDLEY_DEPRECATED(since)
1410    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1411#endif
1412
1413#if defined(JSON_HEDLEY_UNAVAILABLE)
1414    #undef JSON_HEDLEY_UNAVAILABLE
1415#endif
1416#if \
1417    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1418    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1419    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1420    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1421    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1422#else
1423    #define JSON_HEDLEY_UNAVAILABLE(available_since)
1424#endif
1425
1426#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1427    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1428#endif
1429#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1430    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1431#endif
1432#if \
1433    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1434    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1435    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1436    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1437    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1438    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1439    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1440    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1441    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1442    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1443    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1444    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1445    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1446    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1447    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1448    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1449    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1450    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1451    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1452#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1453    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1454    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1455#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1456    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1457    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1458#elif defined(_Check_return_) /* SAL */
1459    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1460    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1461#else
1462    #define JSON_HEDLEY_WARN_UNUSED_RESULT
1463    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1464#endif
1465
1466#if defined(JSON_HEDLEY_SENTINEL)
1467    #undef JSON_HEDLEY_SENTINEL
1468#endif
1469#if \
1470    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1471    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1472    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1473    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1474    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1475    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1476#else
1477    #define JSON_HEDLEY_SENTINEL(position)
1478#endif
1479
1480#if defined(JSON_HEDLEY_NO_RETURN)
1481    #undef JSON_HEDLEY_NO_RETURN
1482#endif
1483#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1484    #define JSON_HEDLEY_NO_RETURN __noreturn
1485#elif \
1486    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1487    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1488    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1489#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1490    #define JSON_HEDLEY_NO_RETURN _Noreturn
1491#elif defined(__cplusplus) && (__cplusplus >= 201103L)
1492    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1493#elif \
1494    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1495    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1496    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1497    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1498    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1499    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1500    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1501    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1502    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1503    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1504    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1505    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1506    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1507    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1508    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1509    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1510    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1511    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1512#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1513    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1514#elif \
1515    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1516    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1517    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1518#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1519    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1520#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1521    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1522#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1523    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1524#else
1525    #define JSON_HEDLEY_NO_RETURN
1526#endif
1527
1528#if defined(JSON_HEDLEY_NO_ESCAPE)
1529    #undef JSON_HEDLEY_NO_ESCAPE
1530#endif
1531#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1532    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1533#else
1534    #define JSON_HEDLEY_NO_ESCAPE
1535#endif
1536
1537#if defined(JSON_HEDLEY_UNREACHABLE)
1538    #undef JSON_HEDLEY_UNREACHABLE
1539#endif
1540#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1541    #undef JSON_HEDLEY_UNREACHABLE_RETURN
1542#endif
1543#if defined(JSON_HEDLEY_ASSUME)
1544    #undef JSON_HEDLEY_ASSUME
1545#endif
1546#if \
1547    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1548    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1549    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1550    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1551#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1552    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1553#elif \
1554    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1555    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1556    #if defined(__cplusplus)
1557        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1558    #else
1559        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1560    #endif
1561#endif
1562#if \
1563    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1564    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1565    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1566    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1567    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1568    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1569    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1570    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1571#elif defined(JSON_HEDLEY_ASSUME)
1572    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1573#endif
1574#if !defined(JSON_HEDLEY_ASSUME)
1575    #if defined(JSON_HEDLEY_UNREACHABLE)
1576        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1577    #else
1578        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1579    #endif
1580#endif
1581#if defined(JSON_HEDLEY_UNREACHABLE)
1582    #if  \
1583        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1584        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1585        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1586    #else
1587        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1588    #endif
1589#else
1590    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1591#endif
1592#if !defined(JSON_HEDLEY_UNREACHABLE)
1593    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1594#endif
1595
1596JSON_HEDLEY_DIAGNOSTIC_PUSH
1597#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1598    #pragma clang diagnostic ignored "-Wpedantic"
1599#endif
1600#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1601    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1602#endif
1603#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1604    #if defined(__clang__)
1605        #pragma clang diagnostic ignored "-Wvariadic-macros"
1606    #elif defined(JSON_HEDLEY_GCC_VERSION)
1607        #pragma GCC diagnostic ignored "-Wvariadic-macros"
1608    #endif
1609#endif
1610#if defined(JSON_HEDLEY_NON_NULL)
1611    #undef JSON_HEDLEY_NON_NULL
1612#endif
1613#if \
1614    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1615    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1616    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1617    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1618    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1619#else
1620    #define JSON_HEDLEY_NON_NULL(...)
1621#endif
1622JSON_HEDLEY_DIAGNOSTIC_POP
1623
1624#if defined(JSON_HEDLEY_PRINTF_FORMAT)
1625    #undef JSON_HEDLEY_PRINTF_FORMAT
1626#endif
1627#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1628    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1629#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1630    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1631#elif \
1632    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1633    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1634    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1635    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1636    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1637    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1638    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1639    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1640    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1641    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1642    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1643    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1644    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1645    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1646    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1647    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1648    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1649    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1650#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1651    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1652#else
1653    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1654#endif
1655
1656#if defined(JSON_HEDLEY_CONSTEXPR)
1657    #undef JSON_HEDLEY_CONSTEXPR
1658#endif
1659#if defined(__cplusplus)
1660    #if __cplusplus >= 201103L
1661        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1662    #endif
1663#endif
1664#if !defined(JSON_HEDLEY_CONSTEXPR)
1665    #define JSON_HEDLEY_CONSTEXPR
1666#endif
1667
1668#if defined(JSON_HEDLEY_PREDICT)
1669    #undef JSON_HEDLEY_PREDICT
1670#endif
1671#if defined(JSON_HEDLEY_LIKELY)
1672    #undef JSON_HEDLEY_LIKELY
1673#endif
1674#if defined(JSON_HEDLEY_UNLIKELY)
1675    #undef JSON_HEDLEY_UNLIKELY
1676#endif
1677#if defined(JSON_HEDLEY_UNPREDICTABLE)
1678    #undef JSON_HEDLEY_UNPREDICTABLE
1679#endif
1680#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1681    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1682#endif
1683#if \
1684  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1685  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1686  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1687#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
1688#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
1689#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
1690#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
1691#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
1692#elif \
1693  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1694  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1695  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1696  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1697  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1698  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1699  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1700  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1701  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1702  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1703  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1704  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1705  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1706  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1707  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1708  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1709#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1710    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1711#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1712    (__extension__ ({ \
1713        double hedley_probability_ = (probability); \
1714        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1715    }))
1716#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1717    (__extension__ ({ \
1718        double hedley_probability_ = (probability); \
1719        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1720    }))
1721#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
1722#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1723#else
1724#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1725#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1726#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1727#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1728#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1729#endif
1730#if !defined(JSON_HEDLEY_UNPREDICTABLE)
1731    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1732#endif
1733
1734#if defined(JSON_HEDLEY_MALLOC)
1735    #undef JSON_HEDLEY_MALLOC
1736#endif
1737#if \
1738    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1739    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1740    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1741    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1742    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1743    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1744    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1745    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1746    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1747    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1748    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1749    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1750    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1751    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1752    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1753    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1754    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1755    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1756    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1757#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1758    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1759#elif \
1760    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1761    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1762    #define JSON_HEDLEY_MALLOC __declspec(restrict)
1763#else
1764    #define JSON_HEDLEY_MALLOC
1765#endif
1766
1767#if defined(JSON_HEDLEY_PURE)
1768    #undef JSON_HEDLEY_PURE
1769#endif
1770#if \
1771  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1772  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1773  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1774  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1775  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1776  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1777  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1778  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1779  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1780  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1781  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1782  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1783  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1784  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1785  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1786  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1787  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1788  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1789  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1790#  define JSON_HEDLEY_PURE __attribute__((__pure__))
1791#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1792#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1793#elif defined(__cplusplus) && \
1794    ( \
1795      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1796      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1797      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1798    )
1799#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1800#else
1801#  define JSON_HEDLEY_PURE
1802#endif
1803
1804#if defined(JSON_HEDLEY_CONST)
1805    #undef JSON_HEDLEY_CONST
1806#endif
1807#if \
1808    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1809    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1810    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1811    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1812    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1813    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1814    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1815    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1816    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1817    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1818    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1819    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1820    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1821    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1822    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1823    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1824    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1825    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1826    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1827    #define JSON_HEDLEY_CONST __attribute__((__const__))
1828#elif \
1829    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1830    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1831#else
1832    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1833#endif
1834
1835#if defined(JSON_HEDLEY_RESTRICT)
1836    #undef JSON_HEDLEY_RESTRICT
1837#endif
1838#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1839    #define JSON_HEDLEY_RESTRICT restrict
1840#elif \
1841    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1842    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1843    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1844    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1845    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1846    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1847    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1848    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1849    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1850    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1851    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1852    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1853    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1854    defined(__clang__) || \
1855    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1856    #define JSON_HEDLEY_RESTRICT __restrict
1857#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1858    #define JSON_HEDLEY_RESTRICT _Restrict
1859#else
1860    #define JSON_HEDLEY_RESTRICT
1861#endif
1862
1863#if defined(JSON_HEDLEY_INLINE)
1864    #undef JSON_HEDLEY_INLINE
1865#endif
1866#if \
1867    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1868    (defined(__cplusplus) && (__cplusplus >= 199711L))
1869    #define JSON_HEDLEY_INLINE inline
1870#elif \
1871    defined(JSON_HEDLEY_GCC_VERSION) || \
1872    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1873    #define JSON_HEDLEY_INLINE __inline__
1874#elif \
1875    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1876    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1877    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1878    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1879    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1880    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1881    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1882    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1883    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1884    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1885    #define JSON_HEDLEY_INLINE __inline
1886#else
1887    #define JSON_HEDLEY_INLINE
1888#endif
1889
1890#if defined(JSON_HEDLEY_ALWAYS_INLINE)
1891    #undef JSON_HEDLEY_ALWAYS_INLINE
1892#endif
1893#if \
1894  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1895  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1896  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1897  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1898  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1899  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1900  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1901  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1902  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1903  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1904  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1905  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1906  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1907  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1908  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1909  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1910  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1911  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1912  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1913#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1914#elif \
1915  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1916  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1917#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1918#elif defined(__cplusplus) && \
1919    ( \
1920      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1921      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1922      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1923      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1924      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1925      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1926    )
1927#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1928#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1929#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1930#else
1931#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1932#endif
1933
1934#if defined(JSON_HEDLEY_NEVER_INLINE)
1935    #undef JSON_HEDLEY_NEVER_INLINE
1936#endif
1937#if \
1938    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1939    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1940    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1941    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1942    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1943    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1944    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1945    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1946    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1947    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1948    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1949    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1950    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1951    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1952    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1953    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1954    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1955    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1956    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1957    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1958#elif \
1959    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1960    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1961    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1962#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1963    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1964#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1965    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1966#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1967    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1968#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1969    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1970#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1971    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1972#else
1973    #define JSON_HEDLEY_NEVER_INLINE
1974#endif
1975
1976#if defined(JSON_HEDLEY_PRIVATE)
1977    #undef JSON_HEDLEY_PRIVATE
1978#endif
1979#if defined(JSON_HEDLEY_PUBLIC)
1980    #undef JSON_HEDLEY_PUBLIC
1981#endif
1982#if defined(JSON_HEDLEY_IMPORT)
1983    #undef JSON_HEDLEY_IMPORT
1984#endif
1985#if defined(_WIN32) || defined(__CYGWIN__)
1986#  define JSON_HEDLEY_PRIVATE
1987#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
1988#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
1989#else
1990#  if \
1991    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1992    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1993    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1994    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1995    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1996    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1997    ( \
1998      defined(__TI_EABI__) && \
1999      ( \
2000        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
2001        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
2002      ) \
2003    ) || \
2004    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2005#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
2006#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
2007#  else
2008#    define JSON_HEDLEY_PRIVATE
2009#    define JSON_HEDLEY_PUBLIC
2010#  endif
2011#  define JSON_HEDLEY_IMPORT    extern
2012#endif
2013
2014#if defined(JSON_HEDLEY_NO_THROW)
2015    #undef JSON_HEDLEY_NO_THROW
2016#endif
2017#if \
2018    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
2019    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
2020    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2021    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2022    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
2023#elif \
2024    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
2025    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
2026    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
2027    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
2028#else
2029    #define JSON_HEDLEY_NO_THROW
2030#endif
2031
2032#if defined(JSON_HEDLEY_FALL_THROUGH)
2033    #undef JSON_HEDLEY_FALL_THROUGH
2034#endif
2035#if \
2036    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
2037    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
2038    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2039    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
2040#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
2041    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
2042#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
2043    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
2044#elif defined(__fallthrough) /* SAL */
2045    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
2046#else
2047    #define JSON_HEDLEY_FALL_THROUGH
2048#endif
2049
2050#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
2051    #undef JSON_HEDLEY_RETURNS_NON_NULL
2052#endif
2053#if \
2054    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
2055    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
2056    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2057    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
2058#elif defined(_Ret_notnull_) /* SAL */
2059    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
2060#else
2061    #define JSON_HEDLEY_RETURNS_NON_NULL
2062#endif
2063
2064#if defined(JSON_HEDLEY_ARRAY_PARAM)
2065    #undef JSON_HEDLEY_ARRAY_PARAM
2066#endif
2067#if \
2068    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
2069    !defined(__STDC_NO_VLA__) && \
2070    !defined(__cplusplus) && \
2071    !defined(JSON_HEDLEY_PGI_VERSION) && \
2072    !defined(JSON_HEDLEY_TINYC_VERSION)
2073    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
2074#else
2075    #define JSON_HEDLEY_ARRAY_PARAM(name)
2076#endif
2077
2078#if defined(JSON_HEDLEY_IS_CONSTANT)
2079    #undef JSON_HEDLEY_IS_CONSTANT
2080#endif
2081#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
2082    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
2083#endif
2084/* JSON_HEDLEY_IS_CONSTEXPR_ is for
2085   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
2086#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2087    #undef JSON_HEDLEY_IS_CONSTEXPR_
2088#endif
2089#if \
2090    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
2091    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
2092    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2093    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
2094    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
2095    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
2096    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
2097    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
2098    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
2099    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2100    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
2101#endif
2102#if !defined(__cplusplus)
2103#  if \
2104       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
2105       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
2106       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2107       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
2108       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
2109       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
2110       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
2111#if defined(__INTPTR_TYPE__)
2112    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
2113#else
2114    #include <stdint.h>
2115    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
2116#endif
2117#  elif \
2118       ( \
2119          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
2120          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
2121          !defined(JSON_HEDLEY_PGI_VERSION) && \
2122          !defined(JSON_HEDLEY_IAR_VERSION)) || \
2123       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
2124       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
2125       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
2126       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
2127       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
2128#if defined(__INTPTR_TYPE__)
2129    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
2130#else
2131    #include <stdint.h>
2132    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
2133#endif
2134#  elif \
2135       defined(JSON_HEDLEY_GCC_VERSION) || \
2136       defined(JSON_HEDLEY_INTEL_VERSION) || \
2137       defined(JSON_HEDLEY_TINYC_VERSION) || \
2138       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
2139       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
2140       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
2141       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
2142       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
2143       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
2144       defined(__clang__)
2145#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
2146        sizeof(void) != \
2147        sizeof(*( \
2148                  1 ? \
2149                  ((void*) ((expr) * 0L) ) : \
2150((struct { char v[sizeof(void) * 2]; } *) 1) \
2151                ) \
2152              ) \
2153                                            )
2154#  endif
2155#endif
2156#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2157    #if !defined(JSON_HEDLEY_IS_CONSTANT)
2158        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
2159    #endif
2160    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2161#else
2162    #if !defined(JSON_HEDLEY_IS_CONSTANT)
2163        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2164    #endif
2165    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2166#endif
2167
2168#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2169    #undef JSON_HEDLEY_BEGIN_C_DECLS
2170#endif
2171#if defined(JSON_HEDLEY_END_C_DECLS)
2172    #undef JSON_HEDLEY_END_C_DECLS
2173#endif
2174#if defined(JSON_HEDLEY_C_DECL)
2175    #undef JSON_HEDLEY_C_DECL
2176#endif
2177#if defined(__cplusplus)
2178    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2179    #define JSON_HEDLEY_END_C_DECLS }
2180    #define JSON_HEDLEY_C_DECL extern "C"
2181#else
2182    #define JSON_HEDLEY_BEGIN_C_DECLS
2183    #define JSON_HEDLEY_END_C_DECLS
2184    #define JSON_HEDLEY_C_DECL
2185#endif
2186
2187#if defined(JSON_HEDLEY_STATIC_ASSERT)
2188    #undef JSON_HEDLEY_STATIC_ASSERT
2189#endif
2190#if \
2191  !defined(__cplusplus) && ( \
2192      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2193      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2194      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2195      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2196      defined(_Static_assert) \
2197    )
2198#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2199#elif \
2200  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2201  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2202  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2203#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2204#else
2205#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2206#endif
2207
2208#if defined(JSON_HEDLEY_NULL)
2209    #undef JSON_HEDLEY_NULL
2210#endif
2211#if defined(__cplusplus)
2212    #if __cplusplus >= 201103L
2213        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2214    #elif defined(NULL)
2215        #define JSON_HEDLEY_NULL NULL
2216    #else
2217        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2218    #endif
2219#elif defined(NULL)
2220    #define JSON_HEDLEY_NULL NULL
2221#else
2222    #define JSON_HEDLEY_NULL ((void*) 0)
2223#endif
2224
2225#if defined(JSON_HEDLEY_MESSAGE)
2226    #undef JSON_HEDLEY_MESSAGE
2227#endif
2228#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2229#  define JSON_HEDLEY_MESSAGE(msg) \
2230    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2231    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2232    JSON_HEDLEY_PRAGMA(message msg) \
2233    JSON_HEDLEY_DIAGNOSTIC_POP
2234#elif \
2235  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2236  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2237#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2238#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2239#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2240#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2241#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2242#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2243#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2244#else
2245#  define JSON_HEDLEY_MESSAGE(msg)
2246#endif
2247
2248#if defined(JSON_HEDLEY_WARNING)
2249    #undef JSON_HEDLEY_WARNING
2250#endif
2251#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2252#  define JSON_HEDLEY_WARNING(msg) \
2253    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2254    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2255    JSON_HEDLEY_PRAGMA(clang warning msg) \
2256    JSON_HEDLEY_DIAGNOSTIC_POP
2257#elif \
2258  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2259  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2260  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2261#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2262#elif \
2263  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2264  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2265#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2266#else
2267#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2268#endif
2269
2270#if defined(JSON_HEDLEY_REQUIRE)
2271    #undef JSON_HEDLEY_REQUIRE
2272#endif
2273#if defined(JSON_HEDLEY_REQUIRE_MSG)
2274    #undef JSON_HEDLEY_REQUIRE_MSG
2275#endif
2276#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2277#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2278#    define JSON_HEDLEY_REQUIRE(expr) \
2279    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2280    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2281    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2282    JSON_HEDLEY_DIAGNOSTIC_POP
2283#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2284    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2285    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2286    __attribute__((diagnose_if(!(expr), msg, "error"))) \
2287    JSON_HEDLEY_DIAGNOSTIC_POP
2288#  else
2289#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2290#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2291#  endif
2292#else
2293#  define JSON_HEDLEY_REQUIRE(expr)
2294#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2295#endif
2296
2297#if defined(JSON_HEDLEY_FLAGS)
2298    #undef JSON_HEDLEY_FLAGS
2299#endif
2300#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2301    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2302#else
2303    #define JSON_HEDLEY_FLAGS
2304#endif
2305
2306#if defined(JSON_HEDLEY_FLAGS_CAST)
2307    #undef JSON_HEDLEY_FLAGS_CAST
2308#endif
2309#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2310#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2311        JSON_HEDLEY_DIAGNOSTIC_PUSH \
2312        _Pragma("warning(disable:188)") \
2313        ((T) (expr)); \
2314        JSON_HEDLEY_DIAGNOSTIC_POP \
2315    }))
2316#else
2317#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2318#endif
2319
2320#if defined(JSON_HEDLEY_EMPTY_BASES)
2321    #undef JSON_HEDLEY_EMPTY_BASES
2322#endif
2323#if \
2324    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2325    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2326    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2327#else
2328    #define JSON_HEDLEY_EMPTY_BASES
2329#endif
2330
2331/* Remaining macros are deprecated. */
2332
2333#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2334    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2335#endif
2336#if defined(__clang__)
2337    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2338#else
2339    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2340#endif
2341
2342#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2343    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2344#endif
2345#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2346
2347#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2348    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2349#endif
2350#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2351
2352#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2353    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2354#endif
2355#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2356
2357#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2358    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2359#endif
2360#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2361
2362#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2363    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2364#endif
2365#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2366
2367#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2368    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2369#endif
2370#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2371
2372#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2373    #undef JSON_HEDLEY_CLANG_HAS_WARNING
2374#endif
2375#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2376
2377#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2378
2379
2380// This file contains all internal macro definitions (except those affecting ABI)
2381// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2382
2383// #include <nlohmann/detail/abi_macros.hpp>
2384
2385
2386// exclude unsupported compilers
2387#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2388    #if defined(__clang__)
2389        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2390            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2391        #endif
2392    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2393        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2394            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2395        #endif
2396    #endif
2397#endif
2398
2399// C++ language standard detection
2400// if the user manually specified the used c++ version this is skipped
2401#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2402    #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L)
2403        #define JSON_HAS_CPP_23
2404        #define JSON_HAS_CPP_20
2405        #define JSON_HAS_CPP_17
2406        #define JSON_HAS_CPP_14
2407    #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L)
2408        #define JSON_HAS_CPP_20
2409        #define JSON_HAS_CPP_17
2410        #define JSON_HAS_CPP_14
2411    #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2412        #define JSON_HAS_CPP_17
2413        #define JSON_HAS_CPP_14
2414    #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2415        #define JSON_HAS_CPP_14
2416    #endif
2417    // the cpp 11 flag is always specified because it is the minimal required version
2418    #define JSON_HAS_CPP_11
2419#endif
2420
2421#ifdef __has_include
2422    #if __has_include(<version>)
2423        #include <version>
2424    #endif
2425#endif
2426
2427#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
2428    #ifdef JSON_HAS_CPP_17
2429        #if defined(__cpp_lib_filesystem)
2430            #define JSON_HAS_FILESYSTEM 1
2431        #elif defined(__cpp_lib_experimental_filesystem)
2432            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2433        #elif !defined(__has_include)
2434            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2435        #elif __has_include(<filesystem>)
2436            #define JSON_HAS_FILESYSTEM 1
2437        #elif __has_include(<experimental/filesystem>)
2438            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2439        #endif
2440
2441        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
2442        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
2443            #undef JSON_HAS_FILESYSTEM
2444            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2445        #endif
2446
2447        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
2448        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
2449            #undef JSON_HAS_FILESYSTEM
2450            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2451        #endif
2452
2453        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
2454        #if defined(__clang_major__) && __clang_major__ < 7
2455            #undef JSON_HAS_FILESYSTEM
2456            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2457        #endif
2458
2459        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
2460        #if defined(_MSC_VER) && _MSC_VER < 1914
2461            #undef JSON_HAS_FILESYSTEM
2462            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2463        #endif
2464
2465        // no filesystem support before iOS 13
2466        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
2467            #undef JSON_HAS_FILESYSTEM
2468            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2469        #endif
2470
2471        // no filesystem support before macOS Catalina
2472        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
2473            #undef JSON_HAS_FILESYSTEM
2474            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2475        #endif
2476    #endif
2477#endif
2478
2479#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2480    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
2481#endif
2482
2483#ifndef JSON_HAS_FILESYSTEM
2484    #define JSON_HAS_FILESYSTEM 0
2485#endif
2486
2487#ifndef JSON_HAS_THREE_WAY_COMPARISON
2488    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
2489        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
2490        #define JSON_HAS_THREE_WAY_COMPARISON 1
2491    #else
2492        #define JSON_HAS_THREE_WAY_COMPARISON 0
2493    #endif
2494#endif
2495
2496#ifndef JSON_HAS_RANGES
2497    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
2498    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
2499        #define JSON_HAS_RANGES 0
2500    #elif defined(__cpp_lib_ranges)
2501        #define JSON_HAS_RANGES 1
2502    #else
2503        #define JSON_HAS_RANGES 0
2504    #endif
2505#endif
2506
2507#ifndef JSON_HAS_STATIC_RTTI
2508    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
2509        #define JSON_HAS_STATIC_RTTI 1
2510    #else
2511        #define JSON_HAS_STATIC_RTTI 0
2512    #endif
2513#endif
2514
2515#ifdef JSON_HAS_CPP_17
2516    #define JSON_INLINE_VARIABLE inline
2517#else
2518    #define JSON_INLINE_VARIABLE
2519#endif
2520
2521#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
2522    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
2523#else
2524    #define JSON_NO_UNIQUE_ADDRESS
2525#endif
2526
2527// disable documentation warnings on clang
2528#if defined(__clang__)
2529    #pragma clang diagnostic push
2530    #pragma clang diagnostic ignored "-Wdocumentation"
2531    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2532#endif
2533
2534// allow disabling exceptions
2535#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2536    #define JSON_THROW(exception) throw exception
2537    #define JSON_TRY try
2538    #define JSON_CATCH(exception) catch(exception)
2539    #define JSON_INTERNAL_CATCH(exception) catch(exception)
2540#else
2541    #include <cstdlib>
2542    #define JSON_THROW(exception) std::abort()
2543    #define JSON_TRY if(true)
2544    #define JSON_CATCH(exception) if(false)
2545    #define JSON_INTERNAL_CATCH(exception) if(false)
2546#endif
2547
2548// override exception macros
2549#if defined(JSON_THROW_USER)
2550    #undef JSON_THROW
2551    #define JSON_THROW JSON_THROW_USER
2552#endif
2553#if defined(JSON_TRY_USER)
2554    #undef JSON_TRY
2555    #define JSON_TRY JSON_TRY_USER
2556#endif
2557#if defined(JSON_CATCH_USER)
2558    #undef JSON_CATCH
2559    #define JSON_CATCH JSON_CATCH_USER
2560    #undef JSON_INTERNAL_CATCH
2561    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2562#endif
2563#if defined(JSON_INTERNAL_CATCH_USER)
2564    #undef JSON_INTERNAL_CATCH
2565    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2566#endif
2567
2568// allow overriding assert
2569#if !defined(JSON_ASSERT)
2570    #include <cassert> // assert
2571    #define JSON_ASSERT(x) assert(x)
2572#endif
2573
2574// allow to access some private functions (needed by the test suite)
2575#if defined(JSON_TESTS_PRIVATE)
2576    #define JSON_PRIVATE_UNLESS_TESTED public
2577#else
2578    #define JSON_PRIVATE_UNLESS_TESTED private
2579#endif
2580
2581/*!
2582@brief macro to briefly define a mapping between an enum and JSON
2583@def NLOHMANN_JSON_SERIALIZE_ENUM
2584@since version 3.4.0
2585*/
2586#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
2587    template<typename BasicJsonType>                                                            \
2588    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
2589    {                                                                                           \
2590        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
2591        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2592        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
2593        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2594        auto it = std::find_if(std::begin(m), std::end(m),                                      \
2595                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
2596        {                                                                                       \
2597            return ej_pair.first == e;                                                          \
2598        });                                                                                     \
2599        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
2600    }                                                                                           \
2601    template<typename BasicJsonType>                                                            \
2602    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
2603    {                                                                                           \
2604        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
2605        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2606        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
2607        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2608        auto it = std::find_if(std::begin(m), std::end(m),                                      \
2609                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2610        {                                                                                       \
2611            return ej_pair.second == j;                                                         \
2612        });                                                                                     \
2613        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
2614    }
2615
2616// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2617// may be removed in the future once the class is split.
2618
2619#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
2620    template<template<typename, typename, typename...> class ObjectType,   \
2621             template<typename, typename...> class ArrayType,              \
2622             class StringType, class BooleanType, class NumberIntegerType, \
2623             class NumberUnsignedType, class NumberFloatType,              \
2624             template<typename> class AllocatorType,                       \
2625             template<typename, typename = void> class JSONSerializer,     \
2626             class BinaryType,                                             \
2627             class CustomBaseClass>
2628
2629#define NLOHMANN_BASIC_JSON_TPL                                            \
2630    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
2631    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
2632    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
2633
2634// Macros to simplify conversion from/to types
2635
2636#define NLOHMANN_JSON_EXPAND( x ) x
2637#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
2638#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2639        NLOHMANN_JSON_PASTE64, \
2640        NLOHMANN_JSON_PASTE63, \
2641        NLOHMANN_JSON_PASTE62, \
2642        NLOHMANN_JSON_PASTE61, \
2643        NLOHMANN_JSON_PASTE60, \
2644        NLOHMANN_JSON_PASTE59, \
2645        NLOHMANN_JSON_PASTE58, \
2646        NLOHMANN_JSON_PASTE57, \
2647        NLOHMANN_JSON_PASTE56, \
2648        NLOHMANN_JSON_PASTE55, \
2649        NLOHMANN_JSON_PASTE54, \
2650        NLOHMANN_JSON_PASTE53, \
2651        NLOHMANN_JSON_PASTE52, \
2652        NLOHMANN_JSON_PASTE51, \
2653        NLOHMANN_JSON_PASTE50, \
2654        NLOHMANN_JSON_PASTE49, \
2655        NLOHMANN_JSON_PASTE48, \
2656        NLOHMANN_JSON_PASTE47, \
2657        NLOHMANN_JSON_PASTE46, \
2658        NLOHMANN_JSON_PASTE45, \
2659        NLOHMANN_JSON_PASTE44, \
2660        NLOHMANN_JSON_PASTE43, \
2661        NLOHMANN_JSON_PASTE42, \
2662        NLOHMANN_JSON_PASTE41, \
2663        NLOHMANN_JSON_PASTE40, \
2664        NLOHMANN_JSON_PASTE39, \
2665        NLOHMANN_JSON_PASTE38, \
2666        NLOHMANN_JSON_PASTE37, \
2667        NLOHMANN_JSON_PASTE36, \
2668        NLOHMANN_JSON_PASTE35, \
2669        NLOHMANN_JSON_PASTE34, \
2670        NLOHMANN_JSON_PASTE33, \
2671        NLOHMANN_JSON_PASTE32, \
2672        NLOHMANN_JSON_PASTE31, \
2673        NLOHMANN_JSON_PASTE30, \
2674        NLOHMANN_JSON_PASTE29, \
2675        NLOHMANN_JSON_PASTE28, \
2676        NLOHMANN_JSON_PASTE27, \
2677        NLOHMANN_JSON_PASTE26, \
2678        NLOHMANN_JSON_PASTE25, \
2679        NLOHMANN_JSON_PASTE24, \
2680        NLOHMANN_JSON_PASTE23, \
2681        NLOHMANN_JSON_PASTE22, \
2682        NLOHMANN_JSON_PASTE21, \
2683        NLOHMANN_JSON_PASTE20, \
2684        NLOHMANN_JSON_PASTE19, \
2685        NLOHMANN_JSON_PASTE18, \
2686        NLOHMANN_JSON_PASTE17, \
2687        NLOHMANN_JSON_PASTE16, \
2688        NLOHMANN_JSON_PASTE15, \
2689        NLOHMANN_JSON_PASTE14, \
2690        NLOHMANN_JSON_PASTE13, \
2691        NLOHMANN_JSON_PASTE12, \
2692        NLOHMANN_JSON_PASTE11, \
2693        NLOHMANN_JSON_PASTE10, \
2694        NLOHMANN_JSON_PASTE9, \
2695        NLOHMANN_JSON_PASTE8, \
2696        NLOHMANN_JSON_PASTE7, \
2697        NLOHMANN_JSON_PASTE6, \
2698        NLOHMANN_JSON_PASTE5, \
2699        NLOHMANN_JSON_PASTE4, \
2700        NLOHMANN_JSON_PASTE3, \
2701        NLOHMANN_JSON_PASTE2, \
2702        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2703#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2704#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2705#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2706#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2707#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2708#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)
2709#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)
2710#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)
2711#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)
2712#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)
2713#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)
2714#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)
2715#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)
2716#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)
2717#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)
2718#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)
2719#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)
2720#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)
2721#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)
2722#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)
2723#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)
2724#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)
2725#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)
2726#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)
2727#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)
2728#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)
2729#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)
2730#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)
2731#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)
2732#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)
2733#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)
2734#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)
2735#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)
2736#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)
2737#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)
2738#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)
2739#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)
2740#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)
2741#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)
2742#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)
2743#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)
2744#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)
2745#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)
2746#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)
2747#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)
2748#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)
2749#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)
2750#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)
2751#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)
2752#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)
2753#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)
2754#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)
2755#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)
2756#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)
2757#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)
2758#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)
2759#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)
2760#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)
2761#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)
2762#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)
2763#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)
2764#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)
2765#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)
2766
2767#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2768#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2769#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1;
2770
2771/*!
2772@brief macro
2773@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
2774@since version 3.9.0
2775@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
2776*/
2777#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
2778    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2779    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2780    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2781    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2782
2783/*!
2784@brief macro
2785@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT
2786@since version 3.11.0
2787@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
2788*/
2789#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
2790    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2791    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2792    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2793    friend void from_json(const BasicJsonType& 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__)) }
2794
2795/*!
2796@brief macro
2797@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE
2798@since version 3.11.3
2799@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
2800*/
2801#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
2802    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2803    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2804
2805/*!
2806@brief macro
2807@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
2808@since version 3.9.0
2809@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
2810*/
2811#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
2812    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2813    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2814    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2815    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2816
2817/*!
2818@brief macro
2819@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT
2820@since version 3.11.0
2821@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
2822*/
2823#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
2824    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2825    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2826    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2827    void from_json(const BasicJsonType& 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__)) }
2828
2829/*!
2830@brief macro
2831@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE
2832@since version 3.11.3
2833@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
2834*/
2835#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
2836    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2837    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2838
2839/*!
2840@brief macro
2841@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE
2842@since version 3.12.0
2843@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
2844*/
2845#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
2846    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2847    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2848    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2849    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2850
2851/*!
2852@brief macro
2853@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT
2854@since version 3.12.0
2855@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
2856*/
2857#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
2858    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2859    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2860    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2861    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2862
2863/*!
2864@brief macro
2865@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE
2866@since version 3.12.0
2867@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
2868*/
2869#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
2870    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2871    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2872
2873/*!
2874@brief macro
2875@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE
2876@since version 3.12.0
2877@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
2878*/
2879#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
2880    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2881    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2882    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2883    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2884
2885/*!
2886@brief macro
2887@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT
2888@since version 3.12.0
2889@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
2890*/
2891#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
2892    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2893    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2894    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2895    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2896
2897/*!
2898@brief macro
2899@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE
2900@since version 3.12.0
2901@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
2902*/
2903#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
2904    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
2905    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2906
2907// inspired from https://stackoverflow.com/a/26745591
2908// allows calling any std function as if (e.g., with begin):
2909// using std::begin; begin(x);
2910//
2911// it allows using the detected idiom to retrieve the return type
2912// of such an expression
2913#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
2914    namespace detail {                                                            \
2915    using std::std_name;                                                          \
2916    \
2917    template<typename... T>                                                       \
2918    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2919    }                                                                             \
2920    \
2921    namespace detail2 {                                                           \
2922    struct std_name##_tag                                                         \
2923    {                                                                             \
2924    };                                                                            \
2925    \
2926    template<typename... T>                                                       \
2927    std_name##_tag std_name(T&&...);                                              \
2928    \
2929    template<typename... T>                                                       \
2930    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2931    \
2932    template<typename... T>                                                       \
2933    struct would_call_std_##std_name                                              \
2934    {                                                                             \
2935        static constexpr auto const value = ::nlohmann::detail::                  \
2936                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
2937    };                                                                            \
2938    } /* namespace detail2 */ \
2939    \
2940    template<typename... T>                                                       \
2941    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
2942    {                                                                             \
2943    }
2944
2945#ifndef JSON_USE_IMPLICIT_CONVERSIONS
2946    #define JSON_USE_IMPLICIT_CONVERSIONS 1
2947#endif
2948
2949#if JSON_USE_IMPLICIT_CONVERSIONS
2950    #define JSON_EXPLICIT
2951#else
2952    #define JSON_EXPLICIT explicit
2953#endif
2954
2955#ifndef JSON_DISABLE_ENUM_SERIALIZATION
2956    #define JSON_DISABLE_ENUM_SERIALIZATION 0
2957#endif
2958
2959#ifndef JSON_USE_GLOBAL_UDLS
2960    #define JSON_USE_GLOBAL_UDLS 1
2961#endif
2962
2963#if JSON_HAS_THREE_WAY_COMPARISON
2964    #include <compare> // partial_ordering
2965#endif
2966
2967NLOHMANN_JSON_NAMESPACE_BEGIN
2968namespace detail
2969{
2970
2971///////////////////////////
2972// JSON type enumeration //
2973///////////////////////////
2974
2975/*!
2976@brief the JSON type enumeration
2977
2978This enumeration collects the different JSON types. It is internally used to
2979distinguish the stored values, and the functions @ref basic_json::is_null(),
2980@ref basic_json::is_object(), @ref basic_json::is_array(),
2981@ref basic_json::is_string(), @ref basic_json::is_boolean(),
2982@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
2983@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
2984@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
2985@ref basic_json::is_structured() rely on it.
2986
2987@note There are three enumeration entries (number_integer, number_unsigned, and
2988number_float), because the library distinguishes these three types for numbers:
2989@ref basic_json::number_unsigned_t is used for unsigned integers,
2990@ref basic_json::number_integer_t is used for signed integers, and
2991@ref basic_json::number_float_t is used for floating-point numbers or to
2992approximate integers which do not fit in the limits of their respective type.
2993
2994@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
2995value with the default value for a given type
2996
2997@since version 1.0.0
2998*/
2999enum class value_t : std::uint8_t
3000{
3001    null,             ///< null value
3002    object,           ///< object (unordered set of name/value pairs)
3003    array,            ///< array (ordered collection of values)
3004    string,           ///< string value
3005    boolean,          ///< boolean value
3006    number_integer,   ///< number value (signed integer)
3007    number_unsigned,  ///< number value (unsigned integer)
3008    number_float,     ///< number value (floating-point)
3009    binary,           ///< binary array (ordered collection of bytes)
3010    discarded         ///< discarded by the parser callback function
3011};
3012
3013/*!
3014@brief comparison operator for JSON types
3015
3016Returns an ordering that is similar to Python:
3017- order: null < boolean < number < object < array < string < binary
3018- furthermore, each type is not smaller than itself
3019- discarded values are not comparable
3020- binary is represented as a b"" string in python and directly comparable to a
3021  string; however, making a binary array directly comparable with a string would
3022  be surprising behavior in a JSON file.
3023
3024@since version 1.0.0
3025*/
3026#if JSON_HAS_THREE_WAY_COMPARISON
3027    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
3028#else
3029    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
3030#endif
3031{
3032    static constexpr std::array<std::uint8_t, 9> order = {{
3033            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
3034            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
3035            6 /* binary */
3036        }
3037    };
3038
3039    const auto l_index = static_cast<std::size_t>(lhs);
3040    const auto r_index = static_cast<std::size_t>(rhs);
3041#if JSON_HAS_THREE_WAY_COMPARISON
3042    if (l_index < order.size() && r_index < order.size())
3043    {
3044        return order[l_index] <=> order[r_index]; // *NOPAD*
3045    }
3046    return std::partial_ordering::unordered;
3047#else
3048    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
3049#endif
3050}
3051
3052// GCC selects the built-in operator< over an operator rewritten from
3053// a user-defined spaceship operator
3054// Clang, MSVC, and ICC select the rewritten candidate
3055// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
3056#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
3057inline bool operator<(const value_t lhs, const value_t rhs) noexcept
3058{
3059    return std::is_lt(lhs <=> rhs); // *NOPAD*
3060}
3061#endif
3062
3063}  // namespace detail
3064NLOHMANN_JSON_NAMESPACE_END
3065
3066// #include <nlohmann/detail/string_escape.hpp>
3067//     __ _____ _____ _____
3068//  __|  |   __|     |   | |  JSON for Modern C++
3069// |  |  |__   |  |  | | | |  version 3.12.0
3070// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3071//
3072// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3073// SPDX-License-Identifier: MIT
3074
3075
3076
3077// #include <nlohmann/detail/abi_macros.hpp>
3078
3079
3080NLOHMANN_JSON_NAMESPACE_BEGIN
3081namespace detail
3082{
3083
3084/*!
3085@brief replace all occurrences of a substring by another string
3086
3087@param[in,out] s  the string to manipulate; changed so that all
3088               occurrences of @a f are replaced with @a t
3089@param[in]     f  the substring to replace with @a t
3090@param[in]     t  the string to replace @a f
3091
3092@pre The search string @a f must not be empty. **This precondition is
3093enforced with an assertion.**
3094
3095@since version 2.0.0
3096*/
3097template<typename StringType>
3098inline void replace_substring(StringType& s, const StringType& f,
3099                              const StringType& t)
3100{
3101    JSON_ASSERT(!f.empty());
3102    for (auto pos = s.find(f);                // find first occurrence of f
3103            pos != StringType::npos;          // make sure f was found
3104            s.replace(pos, f.size(), t),      // replace with t, and
3105            pos = s.find(f, pos + t.size()))  // find next occurrence of f
3106    {}
3107}
3108
3109/*!
3110 * @brief string escaping as described in RFC 6901 (Sect. 4)
3111 * @param[in] s string to escape
3112 * @return    escaped string
3113 *
3114 * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
3115 */
3116template<typename StringType>
3117inline StringType escape(StringType s)
3118{
3119    replace_substring(s, StringType{"~"}, StringType{"~0"});
3120    replace_substring(s, StringType{"/"}, StringType{"~1"});
3121    return s;
3122}
3123
3124/*!
3125 * @brief string unescaping as described in RFC 6901 (Sect. 4)
3126 * @param[in] s string to unescape
3127 * @return    unescaped string
3128 *
3129 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
3130 */
3131template<typename StringType>
3132static void unescape(StringType& s)
3133{
3134    replace_substring(s, StringType{"~1"}, StringType{"/"});
3135    replace_substring(s, StringType{"~0"}, StringType{"~"});
3136}
3137
3138}  // namespace detail
3139NLOHMANN_JSON_NAMESPACE_END
3140
3141// #include <nlohmann/detail/input/position_t.hpp>
3142//     __ _____ _____ _____
3143//  __|  |   __|     |   | |  JSON for Modern C++
3144// |  |  |__   |  |  | | | |  version 3.12.0
3145// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3146//
3147// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3148// SPDX-License-Identifier: MIT
3149
3150
3151
3152#include <cstddef> // size_t
3153
3154// #include <nlohmann/detail/abi_macros.hpp>
3155
3156
3157NLOHMANN_JSON_NAMESPACE_BEGIN
3158namespace detail
3159{
3160
3161/// struct to capture the start position of the current token
3162struct position_t
3163{
3164    /// the total number of characters read
3165    std::size_t chars_read_total = 0;
3166    /// the number of characters read in the current line
3167    std::size_t chars_read_current_line = 0;
3168    /// the number of lines read
3169    std::size_t lines_read = 0;
3170
3171    /// conversion to size_t to preserve SAX interface
3172    constexpr operator size_t() const
3173    {
3174        return chars_read_total;
3175    }
3176};
3177
3178}  // namespace detail
3179NLOHMANN_JSON_NAMESPACE_END
3180
3181// #include <nlohmann/detail/macro_scope.hpp>
3182
3183// #include <nlohmann/detail/meta/cpp_future.hpp>
3184//     __ _____ _____ _____
3185//  __|  |   __|     |   | |  JSON for Modern C++
3186// |  |  |__   |  |  | | | |  version 3.12.0
3187// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3188//
3189// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3190// SPDX-FileCopyrightText: 2018 The Abseil Authors
3191// SPDX-License-Identifier: MIT
3192
3193
3194
3195#include <array> // array
3196#include <cstddef> // size_t
3197#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
3198#include <utility> // index_sequence, make_index_sequence, index_sequence_for
3199
3200// #include <nlohmann/detail/macro_scope.hpp>
3201
3202
3203NLOHMANN_JSON_NAMESPACE_BEGIN
3204namespace detail
3205{
3206
3207template<typename T>
3208using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3209
3210#ifdef JSON_HAS_CPP_14
3211
3212// the following utilities are natively available in C++14
3213using std::enable_if_t;
3214using std::index_sequence;
3215using std::make_index_sequence;
3216using std::index_sequence_for;
3217
3218#else
3219
3220// alias templates to reduce boilerplate
3221template<bool B, typename T = void>
3222using enable_if_t = typename std::enable_if<B, T>::type;
3223
3224// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
3225// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
3226
3227//// START OF CODE FROM GOOGLE ABSEIL
3228
3229// integer_sequence
3230//
3231// Class template representing a compile-time integer sequence. An instantiation
3232// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
3233// type through its template arguments (which is a common need when
3234// working with C++11 variadic templates). `absl::integer_sequence` is designed
3235// to be a drop-in replacement for C++14's `std::integer_sequence`.
3236//
3237// Example:
3238//
3239//   template< class T, T... Ints >
3240//   void user_function(integer_sequence<T, Ints...>);
3241//
3242//   int main()
3243//   {
3244//     // user_function's `T` will be deduced to `int` and `Ints...`
3245//     // will be deduced to `0, 1, 2, 3, 4`.
3246//     user_function(make_integer_sequence<int, 5>());
3247//   }
3248template <typename T, T... Ints>
3249struct integer_sequence
3250{
3251    using value_type = T;
3252    static constexpr std::size_t size() noexcept
3253    {
3254        return sizeof...(Ints);
3255    }
3256};
3257
3258// index_sequence
3259//
3260// A helper template for an `integer_sequence` of `size_t`,
3261// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
3262// `std::index_sequence`.
3263template <size_t... Ints>
3264using index_sequence = integer_sequence<size_t, Ints...>;
3265
3266namespace utility_internal
3267{
3268
3269template <typename Seq, size_t SeqSize, size_t Rem>
3270struct Extend;
3271
3272// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
3273template <typename T, T... Ints, size_t SeqSize>
3274struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3275{
3276    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3277};
3278
3279template <typename T, T... Ints, size_t SeqSize>
3280struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3281{
3282    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3283};
3284
3285// Recursion helper for 'make_integer_sequence<T, N>'.
3286// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
3287template <typename T, size_t N>
3288struct Gen
3289{
3290    using type =
3291        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3292};
3293
3294template <typename T>
3295struct Gen<T, 0>
3296{
3297    using type = integer_sequence<T>;
3298};
3299
3300}  // namespace utility_internal
3301
3302// Compile-time sequences of integers
3303
3304// make_integer_sequence
3305//
3306// This template alias is equivalent to
3307// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
3308// replacement for C++14's `std::make_integer_sequence`.
3309template <typename T, T N>
3310using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
3311
3312// make_index_sequence
3313//
3314// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
3315// and is designed to be a drop-in replacement for C++14's
3316// `std::make_index_sequence`.
3317template <size_t N>
3318using make_index_sequence = make_integer_sequence<size_t, N>;
3319
3320// index_sequence_for
3321//
3322// Converts a typename pack into an index sequence of the same length, and
3323// is designed to be a drop-in replacement for C++14's
3324// `std::index_sequence_for()`
3325template <typename... Ts>
3326using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
3327
3328//// END OF CODE FROM GOOGLE ABSEIL
3329
3330#endif
3331
3332// dispatch utility (taken from ranges-v3)
3333template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
3334template<> struct priority_tag<0> {};
3335
3336// taken from ranges-v3
3337template<typename T>
3338struct static_const
3339{
3340    static JSON_INLINE_VARIABLE constexpr T value{};
3341};
3342
3343#ifndef JSON_HAS_CPP_17
3344    template<typename T>
3345    constexpr T static_const<T>::value;
3346#endif
3347
3348template<typename T, typename... Args>
3349constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
3350{
3351    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
3352}
3353
3354}  // namespace detail
3355NLOHMANN_JSON_NAMESPACE_END
3356
3357// #include <nlohmann/detail/meta/type_traits.hpp>
3358//     __ _____ _____ _____
3359//  __|  |   __|     |   | |  JSON for Modern C++
3360// |  |  |__   |  |  | | | |  version 3.12.0
3361// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3362//
3363// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3364// SPDX-License-Identifier: MIT
3365
3366
3367
3368#include <limits> // numeric_limits
3369#include <string> // char_traits
3370#include <tuple> // tuple
3371#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
3372#include <utility> // declval
3373
3374// #include <nlohmann/detail/iterators/iterator_traits.hpp>
3375//     __ _____ _____ _____
3376//  __|  |   __|     |   | |  JSON for Modern C++
3377// |  |  |__   |  |  | | | |  version 3.12.0
3378// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3379//
3380// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3381// SPDX-License-Identifier: MIT
3382
3383
3384
3385#include <iterator> // random_access_iterator_tag
3386
3387// #include <nlohmann/detail/abi_macros.hpp>
3388
3389// #include <nlohmann/detail/meta/void_t.hpp>
3390
3391// #include <nlohmann/detail/meta/cpp_future.hpp>
3392
3393
3394NLOHMANN_JSON_NAMESPACE_BEGIN
3395namespace detail
3396{
3397
3398template<typename It, typename = void>
3399struct iterator_types {};
3400
3401template<typename It>
3402struct iterator_types <
3403    It,
3404    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3405    typename It::reference, typename It::iterator_category >>
3406{
3407    using difference_type = typename It::difference_type;
3408    using value_type = typename It::value_type;
3409    using pointer = typename It::pointer;
3410    using reference = typename It::reference;
3411    using iterator_category = typename It::iterator_category;
3412};
3413
3414// This is required as some compilers implement std::iterator_traits in a way that
3415// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
3416template<typename T, typename = void>
3417struct iterator_traits
3418{
3419};
3420
3421template<typename T>
3422struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3423    : iterator_types<T>
3424{
3425};
3426
3427template<typename T>
3428struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3429{
3430    using iterator_category = std::random_access_iterator_tag;
3431    using value_type = T;
3432    using difference_type = ptrdiff_t;
3433    using pointer = T*;
3434    using reference = T&;
3435};
3436
3437}  // namespace detail
3438NLOHMANN_JSON_NAMESPACE_END
3439
3440// #include <nlohmann/detail/macro_scope.hpp>
3441
3442// #include <nlohmann/detail/meta/call_std/begin.hpp>
3443//     __ _____ _____ _____
3444//  __|  |   __|     |   | |  JSON for Modern C++
3445// |  |  |__   |  |  | | | |  version 3.12.0
3446// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3447//
3448// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3449// SPDX-License-Identifier: MIT
3450
3451
3452
3453// #include <nlohmann/detail/macro_scope.hpp>
3454
3455
3456NLOHMANN_JSON_NAMESPACE_BEGIN
3457
3458NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
3459
3460NLOHMANN_JSON_NAMESPACE_END
3461
3462// #include <nlohmann/detail/meta/call_std/end.hpp>
3463//     __ _____ _____ _____
3464//  __|  |   __|     |   | |  JSON for Modern C++
3465// |  |  |__   |  |  | | | |  version 3.12.0
3466// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3467//
3468// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3469// SPDX-License-Identifier: MIT
3470
3471
3472
3473// #include <nlohmann/detail/macro_scope.hpp>
3474
3475
3476NLOHMANN_JSON_NAMESPACE_BEGIN
3477
3478NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
3479
3480NLOHMANN_JSON_NAMESPACE_END
3481
3482// #include <nlohmann/detail/meta/cpp_future.hpp>
3483
3484// #include <nlohmann/detail/meta/detected.hpp>
3485
3486// #include <nlohmann/json_fwd.hpp>
3487//     __ _____ _____ _____
3488//  __|  |   __|     |   | |  JSON for Modern C++
3489// |  |  |__   |  |  | | | |  version 3.12.0
3490// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3491//
3492// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
3493// SPDX-License-Identifier: MIT
3494
3495#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3496    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3497
3498    #include <cstdint> // int64_t, uint64_t
3499    #include <map> // map
3500    #include <memory> // allocator
3501    #include <string> // string
3502    #include <vector> // vector
3503
3504    // #include <nlohmann/detail/abi_macros.hpp>
3505
3506
3507    /*!
3508    @brief namespace for Niels Lohmann
3509    @see https://github.com/nlohmann
3510    @since version 1.0.0
3511    */
3512    NLOHMANN_JSON_NAMESPACE_BEGIN
3513
3514    /*!
3515    @brief default JSONSerializer template argument
3516
3517    This serializer ignores the template arguments and uses ADL
3518    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
3519    for serialization.
3520    */
3521    template<typename T = void, typename SFINAE = void>
3522    struct adl_serializer;
3523
3524    /// a class to store JSON values
3525    /// @sa https://json.nlohmann.me/api/basic_json/
3526    template<template<typename U, typename V, typename... Args> class ObjectType =
3527    std::map,
3528    template<typename U, typename... Args> class ArrayType = std::vector,
3529    class StringType = std::string, class BooleanType = bool,
3530    class NumberIntegerType = std::int64_t,
3531    class NumberUnsignedType = std::uint64_t,
3532    class NumberFloatType = double,
3533    template<typename U> class AllocatorType = std::allocator,
3534    template<typename T, typename SFINAE = void> class JSONSerializer =
3535    adl_serializer,
3536    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
3537    class CustomBaseClass = void>
3538    class basic_json;
3539
3540    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
3541    /// @sa https://json.nlohmann.me/api/json_pointer/
3542    template<typename RefStringType>
3543    class json_pointer;
3544
3545    /*!
3546    @brief default specialization
3547    @sa https://json.nlohmann.me/api/json/
3548    */
3549    using json = basic_json<>;
3550
3551    /// @brief a minimal map-like container that preserves insertion order
3552    /// @sa https://json.nlohmann.me/api/ordered_map/
3553    template<class Key, class T, class IgnoredLess, class Allocator>
3554    struct ordered_map;
3555
3556    /// @brief specialization that maintains the insertion order of object keys
3557    /// @sa https://json.nlohmann.me/api/ordered_json/
3558    using ordered_json = basic_json<nlohmann::ordered_map>;
3559
3560    NLOHMANN_JSON_NAMESPACE_END
3561
3562#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
3563
3564
3565NLOHMANN_JSON_NAMESPACE_BEGIN
3566/*!
3567@brief detail namespace with internal helper functions
3568
3569This namespace collects functions that should not be exposed,
3570implementations of some @ref basic_json methods, and meta-programming helpers.
3571
3572@since version 2.1.0
3573*/
3574namespace detail
3575{
3576
3577/////////////
3578// helpers //
3579/////////////
3580
3581// Note to maintainers:
3582//
3583// Every trait in this file expects a non CV-qualified type.
3584// The only exceptions are in the 'aliases for detected' section
3585// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
3586//
3587// In this case, T has to be properly CV-qualified to constraint the function arguments
3588// (e.g. to_json(BasicJsonType&, const T&))
3589
3590template<typename> struct is_basic_json : std::false_type {};
3591
3592NLOHMANN_BASIC_JSON_TPL_DECLARATION
3593struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3594
3595// used by exceptions create() member functions
3596// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
3597// false_type otherwise
3598template<typename BasicJsonContext>
3599struct is_basic_json_context :
3600    std::integral_constant < bool,
3601    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
3602    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
3603{};
3604
3605//////////////////////
3606// json_ref helpers //
3607//////////////////////
3608
3609template<typename>
3610class json_ref;
3611
3612template<typename>
3613struct is_json_ref : std::false_type {};
3614
3615template<typename T>
3616struct is_json_ref<json_ref<T>> : std::true_type {};
3617
3618//////////////////////////
3619// aliases for detected //
3620//////////////////////////
3621
3622template<typename T>
3623using mapped_type_t = typename T::mapped_type;
3624
3625template<typename T>
3626using key_type_t = typename T::key_type;
3627
3628template<typename T>
3629using value_type_t = typename T::value_type;
3630
3631template<typename T>
3632using difference_type_t = typename T::difference_type;
3633
3634template<typename T>
3635using pointer_t = typename T::pointer;
3636
3637template<typename T>
3638using reference_t = typename T::reference;
3639
3640template<typename T>
3641using iterator_category_t = typename T::iterator_category;
3642
3643template<typename T, typename... Args>
3644using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3645
3646template<typename T, typename... Args>
3647using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3648
3649template<typename T, typename U>
3650using get_template_function = decltype(std::declval<T>().template get<U>());
3651
3652// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3653template<typename BasicJsonType, typename T, typename = void>
3654struct has_from_json : std::false_type {};
3655
3656// trait checking if j.get<T> is valid
3657// use this trait instead of std::is_constructible or std::is_convertible,
3658// both rely on, or make use of implicit conversions, and thus fail when T
3659// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3660template <typename BasicJsonType, typename T>
3661struct is_getable
3662{
3663    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3664};
3665
3666template<typename BasicJsonType, typename T>
3667struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3668{
3669    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3670
3671    static constexpr bool value =
3672        is_detected_exact<void, from_json_function, serializer,
3673        const BasicJsonType&, T&>::value;
3674};
3675
3676// This trait checks if JSONSerializer<T>::from_json(json const&) exists
3677// this overload is used for non-default-constructible user-defined-types
3678template<typename BasicJsonType, typename T, typename = void>
3679struct has_non_default_from_json : std::false_type {};
3680
3681template<typename BasicJsonType, typename T>
3682struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3683{
3684    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3685
3686    static constexpr bool value =
3687        is_detected_exact<T, from_json_function, serializer,
3688        const BasicJsonType&>::value;
3689};
3690
3691// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3692// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3693template<typename BasicJsonType, typename T, typename = void>
3694struct has_to_json : std::false_type {};
3695
3696template<typename BasicJsonType, typename T>
3697struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3698{
3699    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3700
3701    static constexpr bool value =
3702        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3703        T>::value;
3704};
3705
3706template<typename T>
3707using detect_key_compare = typename T::key_compare;
3708
3709template<typename T>
3710struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
3711
3712// obtains the actual object key comparator
3713template<typename BasicJsonType>
3714struct actual_object_comparator
3715{
3716    using object_t = typename BasicJsonType::object_t;
3717    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
3718    using type = typename std::conditional < has_key_compare<object_t>::value,
3719          typename object_t::key_compare, object_comparator_t>::type;
3720};
3721
3722template<typename BasicJsonType>
3723using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
3724
3725/////////////////
3726// char_traits //
3727/////////////////
3728
3729// Primary template of char_traits calls std char_traits
3730template<typename T>
3731struct char_traits : std::char_traits<T>
3732{};
3733
3734// Explicitly define char traits for unsigned char since it is not standard
3735template<>
3736struct char_traits<unsigned char> : std::char_traits<char>
3737{
3738    using char_type = unsigned char;
3739    using int_type = uint64_t;
3740
3741    // Redefine to_int_type function
3742    static int_type to_int_type(char_type c) noexcept
3743    {
3744        return static_cast<int_type>(c);
3745    }
3746
3747    static char_type to_char_type(int_type i) noexcept
3748    {
3749        return static_cast<char_type>(i);
3750    }
3751
3752    static constexpr int_type eof() noexcept
3753    {
3754        return static_cast<int_type>(std::char_traits<char>::eof());
3755    }
3756};
3757
3758// Explicitly define char traits for signed char since it is not standard
3759template<>
3760struct char_traits<signed char> : std::char_traits<char>
3761{
3762    using char_type = signed char;
3763    using int_type = uint64_t;
3764
3765    // Redefine to_int_type function
3766    static int_type to_int_type(char_type c) noexcept
3767    {
3768        return static_cast<int_type>(c);
3769    }
3770
3771    static char_type to_char_type(int_type i) noexcept
3772    {
3773        return static_cast<char_type>(i);
3774    }
3775
3776    static constexpr int_type eof() noexcept
3777    {
3778        return static_cast<int_type>(std::char_traits<char>::eof());
3779    }
3780};
3781
3782///////////////////
3783// is_ functions //
3784///////////////////
3785
3786// https://en.cppreference.com/w/cpp/types/conjunction
3787template<class...> struct conjunction : std::true_type { };
3788template<class B> struct conjunction<B> : B { };
3789template<class B, class... Bn>
3790struct conjunction<B, Bn...>
3791: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
3792
3793// https://en.cppreference.com/w/cpp/types/negation
3794template<class B> struct negation : std::integral_constant < bool, !B::value > { };
3795
3796// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
3797// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
3798// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
3799template <typename T>
3800struct is_default_constructible : std::is_default_constructible<T> {};
3801
3802template <typename T1, typename T2>
3803struct is_default_constructible<std::pair<T1, T2>>
3804    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3805
3806template <typename T1, typename T2>
3807struct is_default_constructible<const std::pair<T1, T2>>
3808    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3809
3810template <typename... Ts>
3811struct is_default_constructible<std::tuple<Ts...>>
3812    : conjunction<is_default_constructible<Ts>...> {};
3813
3814template <typename... Ts>
3815struct is_default_constructible<const std::tuple<Ts...>>
3816    : conjunction<is_default_constructible<Ts>...> {};
3817
3818template <typename T, typename... Args>
3819struct is_constructible : std::is_constructible<T, Args...> {};
3820
3821template <typename T1, typename T2>
3822struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3823
3824template <typename T1, typename T2>
3825struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3826
3827template <typename... Ts>
3828struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3829
3830template <typename... Ts>
3831struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3832
3833template<typename T, typename = void>
3834struct is_iterator_traits : std::false_type {};
3835
3836template<typename T>
3837struct is_iterator_traits<iterator_traits<T>>
3838{
3839  private:
3840    using traits = iterator_traits<T>;
3841
3842  public:
3843    static constexpr auto value =
3844        is_detected<value_type_t, traits>::value &&
3845        is_detected<difference_type_t, traits>::value &&
3846        is_detected<pointer_t, traits>::value &&
3847        is_detected<iterator_category_t, traits>::value &&
3848        is_detected<reference_t, traits>::value;
3849};
3850
3851template<typename T>
3852struct is_range
3853{
3854  private:
3855    using t_ref = typename std::add_lvalue_reference<T>::type;
3856
3857    using iterator = detected_t<result_of_begin, t_ref>;
3858    using sentinel = detected_t<result_of_end, t_ref>;
3859
3860    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
3861    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
3862    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
3863    static constexpr auto is_iterator_begin =
3864        is_iterator_traits<iterator_traits<iterator>>::value;
3865
3866  public:
3867    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
3868};
3869
3870template<typename R>
3871using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3872
3873template<typename T>
3874using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
3875
3876// The following implementation of is_complete_type is taken from
3877// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
3878// and is written by Xiang Fan who agreed to using it in this library.
3879
3880template<typename T, typename = void>
3881struct is_complete_type : std::false_type {};
3882
3883template<typename T>
3884struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3885
3886template<typename BasicJsonType, typename CompatibleObjectType,
3887         typename = void>
3888struct is_compatible_object_type_impl : std::false_type {};
3889
3890template<typename BasicJsonType, typename CompatibleObjectType>
3891struct is_compatible_object_type_impl <
3892    BasicJsonType, CompatibleObjectType,
3893    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3894    is_detected<key_type_t, CompatibleObjectType>::value >>
3895{
3896    using object_t = typename BasicJsonType::object_t;
3897
3898    // macOS's is_constructible does not play well with nonesuch...
3899    static constexpr bool value =
3900        is_constructible<typename object_t::key_type,
3901        typename CompatibleObjectType::key_type>::value &&
3902        is_constructible<typename object_t::mapped_type,
3903        typename CompatibleObjectType::mapped_type>::value;
3904};
3905
3906template<typename BasicJsonType, typename CompatibleObjectType>
3907struct is_compatible_object_type
3908    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3909
3910template<typename BasicJsonType, typename ConstructibleObjectType,
3911         typename = void>
3912struct is_constructible_object_type_impl : std::false_type {};
3913
3914template<typename BasicJsonType, typename ConstructibleObjectType>
3915struct is_constructible_object_type_impl <
3916    BasicJsonType, ConstructibleObjectType,
3917    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3918    is_detected<key_type_t, ConstructibleObjectType>::value >>
3919{
3920    using object_t = typename BasicJsonType::object_t;
3921
3922    static constexpr bool value =
3923        (is_default_constructible<ConstructibleObjectType>::value &&
3924         (std::is_move_assignable<ConstructibleObjectType>::value ||
3925          std::is_copy_assignable<ConstructibleObjectType>::value) &&
3926         (is_constructible<typename ConstructibleObjectType::key_type,
3927          typename object_t::key_type>::value &&
3928          std::is_same <
3929          typename object_t::mapped_type,
3930          typename ConstructibleObjectType::mapped_type >::value)) ||
3931        (has_from_json<BasicJsonType,
3932         typename ConstructibleObjectType::mapped_type>::value ||
3933         has_non_default_from_json <
3934         BasicJsonType,
3935         typename ConstructibleObjectType::mapped_type >::value);
3936};
3937
3938template<typename BasicJsonType, typename ConstructibleObjectType>
3939struct is_constructible_object_type
3940    : is_constructible_object_type_impl<BasicJsonType,
3941      ConstructibleObjectType> {};
3942
3943template<typename BasicJsonType, typename CompatibleStringType>
3944struct is_compatible_string_type
3945{
3946    static constexpr auto value =
3947        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3948};
3949
3950template<typename BasicJsonType, typename ConstructibleStringType>
3951struct is_constructible_string_type
3952{
3953    // launder type through decltype() to fix compilation failure on ICPC
3954#ifdef __INTEL_COMPILER
3955    using laundered_type = decltype(std::declval<ConstructibleStringType>());
3956#else
3957    using laundered_type = ConstructibleStringType;
3958#endif
3959
3960    static constexpr auto value =
3961        conjunction <
3962        is_constructible<laundered_type, typename BasicJsonType::string_t>,
3963        is_detected_exact<typename BasicJsonType::string_t::value_type,
3964        value_type_t, laundered_type >>::value;
3965};
3966
3967template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3968struct is_compatible_array_type_impl : std::false_type {};
3969
3970template<typename BasicJsonType, typename CompatibleArrayType>
3971struct is_compatible_array_type_impl <
3972    BasicJsonType, CompatibleArrayType,
3973    enable_if_t <
3974    is_detected<iterator_t, CompatibleArrayType>::value&&
3975    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
3976// special case for types like std::filesystem::path whose iterator's value_type are themselves
3977// c.f. https://github.com/nlohmann/json/pull/3073
3978    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3979{
3980    static constexpr bool value =
3981        is_constructible<BasicJsonType,
3982        range_value_t<CompatibleArrayType>>::value;
3983};
3984
3985template<typename BasicJsonType, typename CompatibleArrayType>
3986struct is_compatible_array_type
3987    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3988
3989template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3990struct is_constructible_array_type_impl : std::false_type {};
3991
3992template<typename BasicJsonType, typename ConstructibleArrayType>
3993struct is_constructible_array_type_impl <
3994    BasicJsonType, ConstructibleArrayType,
3995    enable_if_t<std::is_same<ConstructibleArrayType,
3996    typename BasicJsonType::value_type>::value >>
3997            : std::true_type {};
3998
3999template<typename BasicJsonType, typename ConstructibleArrayType>
4000struct is_constructible_array_type_impl <
4001    BasicJsonType, ConstructibleArrayType,
4002    enable_if_t < !std::is_same<ConstructibleArrayType,
4003    typename BasicJsonType::value_type>::value&&
4004    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4005    is_default_constructible<ConstructibleArrayType>::value&&
4006(std::is_move_assignable<ConstructibleArrayType>::value ||
4007 std::is_copy_assignable<ConstructibleArrayType>::value)&&
4008is_detected<iterator_t, ConstructibleArrayType>::value&&
4009is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
4010is_detected<range_value_t, ConstructibleArrayType>::value&&
4011// special case for types like std::filesystem::path whose iterator's value_type are themselves
4012// c.f. https://github.com/nlohmann/json/pull/3073
4013!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
4014is_complete_type <
4015detected_t<range_value_t, ConstructibleArrayType >>::value >>
4016{
4017    using value_type = range_value_t<ConstructibleArrayType>;
4018
4019    static constexpr bool value =
4020        std::is_same<value_type,
4021        typename BasicJsonType::array_t::value_type>::value ||
4022        has_from_json<BasicJsonType,
4023        value_type>::value ||
4024        has_non_default_from_json <
4025        BasicJsonType,
4026        value_type >::value;
4027};
4028
4029template<typename BasicJsonType, typename ConstructibleArrayType>
4030struct is_constructible_array_type
4031    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
4032
4033template<typename RealIntegerType, typename CompatibleNumberIntegerType,
4034         typename = void>
4035struct is_compatible_integer_type_impl : std::false_type {};
4036
4037template<typename RealIntegerType, typename CompatibleNumberIntegerType>
4038struct is_compatible_integer_type_impl <
4039    RealIntegerType, CompatibleNumberIntegerType,
4040    enable_if_t < std::is_integral<RealIntegerType>::value&&
4041    std::is_integral<CompatibleNumberIntegerType>::value&&
4042    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
4043{
4044    // is there an assert somewhere on overflows?
4045    using RealLimits = std::numeric_limits<RealIntegerType>;
4046    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
4047
4048    static constexpr auto value =
4049        is_constructible<RealIntegerType,
4050        CompatibleNumberIntegerType>::value &&
4051        CompatibleLimits::is_integer &&
4052        RealLimits::is_signed == CompatibleLimits::is_signed;
4053};
4054
4055template<typename RealIntegerType, typename CompatibleNumberIntegerType>
4056struct is_compatible_integer_type
4057    : is_compatible_integer_type_impl<RealIntegerType,
4058      CompatibleNumberIntegerType> {};
4059
4060template<typename BasicJsonType, typename CompatibleType, typename = void>
4061struct is_compatible_type_impl: std::false_type {};
4062
4063template<typename BasicJsonType, typename CompatibleType>
4064struct is_compatible_type_impl <
4065    BasicJsonType, CompatibleType,
4066    enable_if_t<is_complete_type<CompatibleType>::value >>
4067{
4068    static constexpr bool value =
4069        has_to_json<BasicJsonType, CompatibleType>::value;
4070};
4071
4072template<typename BasicJsonType, typename CompatibleType>
4073struct is_compatible_type
4074    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
4075
4076template<typename T1, typename T2>
4077struct is_constructible_tuple : std::false_type {};
4078
4079template<typename T1, typename... Args>
4080struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
4081
4082template<typename BasicJsonType, typename T>
4083struct is_json_iterator_of : std::false_type {};
4084
4085template<typename BasicJsonType>
4086struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
4087
4088template<typename BasicJsonType>
4089struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
4090{};
4091
4092// checks if a given type T is a template specialization of Primary
4093template<template <typename...> class Primary, typename T>
4094struct is_specialization_of : std::false_type {};
4095
4096template<template <typename...> class Primary, typename... Args>
4097struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
4098
4099template<typename T>
4100using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
4101
4102// checks if A and B are comparable using Compare functor
4103template<typename Compare, typename A, typename B, typename = void>
4104struct is_comparable : std::false_type {};
4105
4106template<typename Compare, typename A, typename B>
4107struct is_comparable<Compare, A, B, void_t<
4108decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
4109decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
4110>> : std::true_type {};
4111
4112template<typename T>
4113using detect_is_transparent = typename T::is_transparent;
4114
4115// type trait to check if KeyType can be used as object key (without a BasicJsonType)
4116// see is_usable_as_basic_json_key_type below
4117template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
4118         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
4119using is_usable_as_key_type = typename std::conditional <
4120                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
4121                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
4122                                   ObjectKeyType>::value)
4123                              && (!RequireTransparentComparator
4124                                  || is_detected <detect_is_transparent, Comparator>::value)
4125                              && !is_json_pointer<KeyType>::value,
4126                              std::true_type,
4127                              std::false_type >::type;
4128
4129// type trait to check if KeyType can be used as object key
4130// true if:
4131//   - KeyType is comparable with BasicJsonType::object_t::key_type
4132//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
4133//   - the comparator is transparent or RequireTransparentComparator is false
4134//   - KeyType is not a JSON iterator or json_pointer
4135template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
4136         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
4137using is_usable_as_basic_json_key_type = typename std::conditional <
4138    is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
4139    typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
4140    RequireTransparentComparator, ExcludeObjectKeyType>::value
4141    && !is_json_iterator_of<BasicJsonType, KeyType>::value,
4142    std::true_type,
4143    std::false_type >::type;
4144
4145template<typename ObjectType, typename KeyType>
4146using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
4147
4148// type trait to check if object_t has an erase() member functions accepting KeyType
4149template<typename BasicJsonType, typename KeyType>
4150using has_erase_with_key_type = typename std::conditional <
4151                                is_detected <
4152                                detect_erase_with_key_type,
4153                                typename BasicJsonType::object_t, KeyType >::value,
4154                                std::true_type,
4155                                std::false_type >::type;
4156
4157// a naive helper to check if a type is an ordered_map (exploits the fact that
4158// ordered_map inherits capacity() from std::vector)
4159template <typename T>
4160struct is_ordered_map
4161{
4162    using one = char;
4163
4164    struct two
4165    {
4166        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4167    };
4168
4169    template <typename C> static one test( decltype(&C::capacity) ) ;
4170    template <typename C> static two test(...);
4171
4172    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
4173};
4174
4175// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
4176template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
4177T conditional_static_cast(U value)
4178{
4179    return static_cast<T>(value);
4180}
4181
4182template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
4183T conditional_static_cast(U value)
4184{
4185    return value;
4186}
4187
4188template<typename... Types>
4189using all_integral = conjunction<std::is_integral<Types>...>;
4190
4191template<typename... Types>
4192using all_signed = conjunction<std::is_signed<Types>...>;
4193
4194template<typename... Types>
4195using all_unsigned = conjunction<std::is_unsigned<Types>...>;
4196
4197// there's a disjunction trait in another PR; replace when merged
4198template<typename... Types>
4199using same_sign = std::integral_constant < bool,
4200      all_signed<Types...>::value || all_unsigned<Types...>::value >;
4201
4202template<typename OfType, typename T>
4203using never_out_of_range = std::integral_constant < bool,
4204      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
4205      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
4206
4207template<typename OfType, typename T,
4208         bool OfTypeSigned = std::is_signed<OfType>::value,
4209         bool TSigned = std::is_signed<T>::value>
4210struct value_in_range_of_impl2;
4211
4212template<typename OfType, typename T>
4213struct value_in_range_of_impl2<OfType, T, false, false>
4214{
4215    static constexpr bool test(T val)
4216    {
4217        using CommonType = typename std::common_type<OfType, T>::type;
4218        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4219    }
4220};
4221
4222template<typename OfType, typename T>
4223struct value_in_range_of_impl2<OfType, T, true, false>
4224{
4225    static constexpr bool test(T val)
4226    {
4227        using CommonType = typename std::common_type<OfType, T>::type;
4228        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4229    }
4230};
4231
4232template<typename OfType, typename T>
4233struct value_in_range_of_impl2<OfType, T, false, true>
4234{
4235    static constexpr bool test(T val)
4236    {
4237        using CommonType = typename std::common_type<OfType, T>::type;
4238        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4239    }
4240};
4241
4242template<typename OfType, typename T>
4243struct value_in_range_of_impl2<OfType, T, true, true>
4244{
4245    static constexpr bool test(T val)
4246    {
4247        using CommonType = typename std::common_type<OfType, T>::type;
4248        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
4249               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4250    }
4251};
4252
4253template<typename OfType, typename T,
4254         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
4255         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
4256struct value_in_range_of_impl1;
4257
4258template<typename OfType, typename T>
4259struct value_in_range_of_impl1<OfType, T, false>
4260{
4261    static constexpr bool test(T val)
4262    {
4263        return value_in_range_of_impl2<OfType, T>::test(val);
4264    }
4265};
4266
4267template<typename OfType, typename T>
4268struct value_in_range_of_impl1<OfType, T, true>
4269{
4270    static constexpr bool test(T /*val*/)
4271    {
4272        return true;
4273    }
4274};
4275
4276template<typename OfType, typename T>
4277constexpr bool value_in_range_of(T val)
4278{
4279    return value_in_range_of_impl1<OfType, T>::test(val);
4280}
4281
4282template<bool Value>
4283using bool_constant = std::integral_constant<bool, Value>;
4284
4285///////////////////////////////////////////////////////////////////////////////
4286// is_c_string
4287///////////////////////////////////////////////////////////////////////////////
4288
4289namespace impl
4290{
4291
4292template<typename T>
4293constexpr bool is_c_string()
4294{
4295    using TUnExt = typename std::remove_extent<T>::type;
4296    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
4297    using TUnPtr = typename std::remove_pointer<T>::type;
4298    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
4299    return
4300        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
4301        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
4302}
4303
4304}  // namespace impl
4305
4306// checks whether T is a [cv] char */[cv] char[] C string
4307template<typename T>
4308struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
4309
4310template<typename T>
4311using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
4312
4313///////////////////////////////////////////////////////////////////////////////
4314// is_transparent
4315///////////////////////////////////////////////////////////////////////////////
4316
4317namespace impl
4318{
4319
4320template<typename T>
4321constexpr bool is_transparent()
4322{
4323    return is_detected<detect_is_transparent, T>::value;
4324}
4325
4326}  // namespace impl
4327
4328// checks whether T has a member named is_transparent
4329template<typename T>
4330struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
4331
4332///////////////////////////////////////////////////////////////////////////////
4333
4334}  // namespace detail
4335NLOHMANN_JSON_NAMESPACE_END
4336
4337// #include <nlohmann/detail/string_concat.hpp>
4338//     __ _____ _____ _____
4339//  __|  |   __|     |   | |  JSON for Modern C++
4340// |  |  |__   |  |  | | | |  version 3.12.0
4341// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
4342//
4343// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
4344// SPDX-License-Identifier: MIT
4345
4346
4347
4348#include <cstring> // strlen
4349#include <string> // string
4350#include <utility> // forward
4351
4352// #include <nlohmann/detail/meta/cpp_future.hpp>
4353
4354// #include <nlohmann/detail/meta/detected.hpp>
4355
4356
4357NLOHMANN_JSON_NAMESPACE_BEGIN
4358namespace detail
4359{
4360
4361inline std::size_t concat_length()
4362{
4363    return 0;
4364}
4365
4366template<typename... Args>
4367inline std::size_t concat_length(const char* cstr, const Args& ... rest);
4368
4369template<typename StringType, typename... Args>
4370inline std::size_t concat_length(const StringType& str, const Args& ... rest);
4371
4372template<typename... Args>
4373inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
4374{
4375    return 1 + concat_length(rest...);
4376}
4377
4378template<typename... Args>
4379inline std::size_t concat_length(const char* cstr, const Args& ... rest)
4380{
4381    // cppcheck-suppress ignoredReturnValue
4382    return ::strlen(cstr) + concat_length(rest...);
4383}
4384
4385template<typename StringType, typename... Args>
4386inline std::size_t concat_length(const StringType& str, const Args& ... rest)
4387{
4388    return str.size() + concat_length(rest...);
4389}
4390
4391template<typename OutStringType>
4392inline void concat_into(OutStringType& /*out*/)
4393{}
4394
4395template<typename StringType, typename Arg>
4396using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
4397
4398template<typename StringType, typename Arg>
4399using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
4400
4401template<typename StringType, typename Arg>
4402using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
4403
4404template<typename StringType, typename Arg>
4405using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
4406
4407template<typename StringType, typename Arg>
4408using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
4409
4410template<typename StringType, typename Arg>
4411using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
4412
4413template<typename StringType, typename Arg>
4414using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
4415
4416template<typename StringType, typename Arg>
4417using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
4418
4419template < typename OutStringType, typename Arg, typename... Args,
4420           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4421                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
4422inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
4423
4424template < typename OutStringType, typename Arg, typename... Args,
4425           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4426                         && !detect_string_can_append_op<OutStringType, Arg>::value
4427                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
4428inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4429
4430template < typename OutStringType, typename Arg, typename... Args,
4431           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4432                         && !detect_string_can_append_op<OutStringType, Arg>::value
4433                         && !detect_string_can_append_iter<OutStringType, Arg>::value
4434                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
4435inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4436
4437template<typename OutStringType, typename Arg, typename... Args,
4438         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
4439inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
4440{
4441    out.append(std::forward<Arg>(arg));
4442    concat_into(out, std::forward<Args>(rest)...);
4443}
4444
4445template < typename OutStringType, typename Arg, typename... Args,
4446           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4447                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
4448inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
4449{
4450    out += std::forward<Arg>(arg);
4451    concat_into(out, std::forward<Args>(rest)...);
4452}
4453
4454template < typename OutStringType, typename Arg, typename... Args,
4455           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4456                         && !detect_string_can_append_op<OutStringType, Arg>::value
4457                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
4458inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4459{
4460    out.append(arg.begin(), arg.end());
4461    concat_into(out, std::forward<Args>(rest)...);
4462}
4463
4464template < typename OutStringType, typename Arg, typename... Args,
4465           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4466                         && !detect_string_can_append_op<OutStringType, Arg>::value
4467                         && !detect_string_can_append_iter<OutStringType, Arg>::value
4468                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
4469inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4470{
4471    out.append(arg.data(), arg.size());
4472    concat_into(out, std::forward<Args>(rest)...);
4473}
4474
4475template<typename OutStringType = std::string, typename... Args>
4476inline OutStringType concat(Args && ... args)
4477{
4478    OutStringType str;
4479    str.reserve(concat_length(args...));
4480    concat_into(str, std::forward<Args>(args)...);
4481    return str;
4482}
4483
4484}  // namespace detail
4485NLOHMANN_JSON_NAMESPACE_END
4486
4487
4488// With -Wweak-vtables, Clang will complain about the exception classes as they
4489// have no out-of-line virtual method definitions and their vtable will be
4490// emitted in every translation unit. This issue cannot be fixed with a
4491// header-only library as there is no implementation file to move these
4492// functions to. As a result, we suppress this warning here to avoid client
4493// code to stumble over this. See https://github.com/nlohmann/json/issues/4087
4494// for a discussion.
4495#if defined(__clang__)
4496    #pragma clang diagnostic push
4497    #pragma clang diagnostic ignored "-Wweak-vtables"
4498#endif
4499
4500NLOHMANN_JSON_NAMESPACE_BEGIN
4501namespace detail
4502{
4503
4504////////////////
4505// exceptions //
4506////////////////
4507
4508/// @brief general exception of the @ref basic_json class
4509/// @sa https://json.nlohmann.me/api/basic_json/exception/
4510class exception : public std::exception
4511{
4512  public:
4513    /// returns the explanatory string
4514    const char* what() const noexcept override
4515    {
4516        return m.what();
4517    }
4518
4519    /// the id of the exception
4520    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
4521
4522  protected:
4523    JSON_HEDLEY_NON_NULL(3)
4524    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
4525
4526    static std::string name(const std::string& ename, int id_)
4527    {
4528        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
4529    }
4530
4531    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
4532    {
4533        return "";
4534    }
4535
4536    template<typename BasicJsonType>
4537    static std::string diagnostics(const BasicJsonType* leaf_element)
4538    {
4539#if JSON_DIAGNOSTICS
4540        std::vector<std::string> tokens;
4541        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
4542        {
4543            switch (current->m_parent->type())
4544            {
4545                case value_t::array:
4546                {
4547                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
4548                    {
4549                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
4550                        {
4551                            tokens.emplace_back(std::to_string(i));
4552                            break;
4553                        }
4554                    }
4555                    break;
4556                }
4557
4558                case value_t::object:
4559                {
4560                    for (const auto& element : *current->m_parent->m_data.m_value.object)
4561                    {
4562                        if (&element.second == current)
4563                        {
4564                            tokens.emplace_back(element.first.c_str());
4565                            break;
4566                        }
4567                    }
4568                    break;
4569                }
4570
4571                case value_t::null: // LCOV_EXCL_LINE
4572                case value_t::string: // LCOV_EXCL_LINE
4573                case value_t::boolean: // LCOV_EXCL_LINE
4574                case value_t::number_integer: // LCOV_EXCL_LINE
4575                case value_t::number_unsigned: // LCOV_EXCL_LINE
4576                case value_t::number_float: // LCOV_EXCL_LINE
4577                case value_t::binary: // LCOV_EXCL_LINE
4578                case value_t::discarded: // LCOV_EXCL_LINE
4579                default:   // LCOV_EXCL_LINE
4580                    break; // LCOV_EXCL_LINE
4581            }
4582        }
4583
4584        if (tokens.empty())
4585        {
4586            return "";
4587        }
4588
4589        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
4590                                   [](const std::string & a, const std::string & b)
4591        {
4592            return concat(a, '/', detail::escape(b));
4593        });
4594
4595        return concat('(', str, ") ", get_byte_positions(leaf_element));
4596#else
4597        return get_byte_positions(leaf_element);
4598#endif
4599    }
4600
4601  private:
4602    /// an exception object as storage for error messages
4603    std::runtime_error m;
4604#if JSON_DIAGNOSTIC_POSITIONS
4605    template<typename BasicJsonType>
4606    static std::string get_byte_positions(const BasicJsonType* leaf_element)
4607    {
4608        if ((leaf_element->start_pos() != std::string::npos) && (leaf_element->end_pos() != std::string::npos))
4609        {
4610            return concat("(bytes ", std::to_string(leaf_element->start_pos()), "-", std::to_string(leaf_element->end_pos()), ") ");
4611        }
4612        return "";
4613    }
4614#else
4615    template<typename BasicJsonType>
4616    static std::string get_byte_positions(const BasicJsonType* leaf_element)
4617    {
4618        static_cast<void>(leaf_element);
4619        return "";
4620    }
4621#endif
4622};
4623
4624/// @brief exception indicating a parse error
4625/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
4626class parse_error : public exception
4627{
4628  public:
4629    /*!
4630    @brief create a parse error exception
4631    @param[in] id_       the id of the exception
4632    @param[in] pos       the position where the error occurred (or with
4633                         chars_read_total=0 if the position cannot be
4634                         determined)
4635    @param[in] what_arg  the explanatory string
4636    @return parse_error object
4637    */
4638    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4639    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
4640    {
4641        const std::string w = concat(exception::name("parse_error", id_), "parse error",
4642                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
4643        return {id_, pos.chars_read_total, w.c_str()};
4644    }
4645
4646    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4647    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
4648    {
4649        const std::string w = concat(exception::name("parse_error", id_), "parse error",
4650                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
4651                                     ": ", exception::diagnostics(context), what_arg);
4652        return {id_, byte_, w.c_str()};
4653    }
4654
4655    /*!
4656    @brief byte index of the parse error
4657
4658    The byte index of the last read character in the input file.
4659
4660    @note For an input with n bytes, 1 is the index of the first character and
4661          n+1 is the index of the terminating null byte or the end of file.
4662          This also holds true when reading a byte vector (CBOR or MessagePack).
4663    */
4664    const std::size_t byte;
4665
4666  private:
4667    parse_error(int id_, std::size_t byte_, const char* what_arg)
4668        : exception(id_, what_arg), byte(byte_) {}
4669
4670    static std::string position_string(const position_t& pos)
4671    {
4672        return concat(" at line ", std::to_string(pos.lines_read + 1),
4673                      ", column ", std::to_string(pos.chars_read_current_line));
4674    }
4675};
4676
4677/// @brief exception indicating errors with iterators
4678/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
4679class invalid_iterator : public exception
4680{
4681  public:
4682    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4683    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
4684    {
4685        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
4686        return {id_, w.c_str()};
4687    }
4688
4689  private:
4690    JSON_HEDLEY_NON_NULL(3)
4691    invalid_iterator(int id_, const char* what_arg)
4692        : exception(id_, what_arg) {}
4693};
4694
4695/// @brief exception indicating executing a member function with a wrong type
4696/// @sa https://json.nlohmann.me/api/basic_json/type_error/
4697class type_error : public exception
4698{
4699  public:
4700    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4701    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4702    {
4703        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
4704        return {id_, w.c_str()};
4705    }
4706
4707  private:
4708    JSON_HEDLEY_NON_NULL(3)
4709    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
4710};
4711
4712/// @brief exception indicating access out of the defined range
4713/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
4714class out_of_range : public exception
4715{
4716  public:
4717    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4718    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
4719    {
4720        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
4721        return {id_, w.c_str()};
4722    }
4723
4724  private:
4725    JSON_HEDLEY_NON_NULL(3)
4726    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
4727};
4728
4729/// @brief exception indicating other library errors
4730/// @sa https://json.nlohmann.me/api/basic_json/other_error/
4731class other_error : public exception
4732{
4733  public:
4734    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
4735    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4736    {
4737        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
4738        return {id_, w.c_str()};
4739    }
4740
4741  private:
4742    JSON_HEDLEY_NON_NULL(3)
4743    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
4744};
4745
4746}  // namespace detail
4747NLOHMANN_JSON_NAMESPACE_END
4748
4749#if defined(__clang__)
4750    #pragma clang diagnostic pop
4751#endif
4752
4753// #include <nlohmann/detail/macro_scope.hpp>
4754
4755// #include <nlohmann/detail/meta/cpp_future.hpp>
4756
4757// #include <nlohmann/detail/meta/identity_tag.hpp>
4758//     __ _____ _____ _____
4759//  __|  |   __|     |   | |  JSON for Modern C++
4760// |  |  |__   |  |  | | | |  version 3.12.0
4761// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
4762//
4763// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
4764// SPDX-License-Identifier: MIT
4765
4766
4767
4768// #include <nlohmann/detail/abi_macros.hpp>
4769
4770
4771NLOHMANN_JSON_NAMESPACE_BEGIN
4772namespace detail
4773{
4774
4775// dispatching helper struct
4776template <class T> struct identity_tag {};
4777
4778}  // namespace detail
4779NLOHMANN_JSON_NAMESPACE_END
4780
4781// #include <nlohmann/detail/meta/std_fs.hpp>
4782//     __ _____ _____ _____
4783//  __|  |   __|     |   | |  JSON for Modern C++
4784// |  |  |__   |  |  | | | |  version 3.12.0
4785// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
4786//
4787// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
4788// SPDX-License-Identifier: MIT
4789
4790
4791
4792// #include <nlohmann/detail/macro_scope.hpp>
4793
4794
4795#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
4796#include <experimental/filesystem>
4797NLOHMANN_JSON_NAMESPACE_BEGIN
4798namespace detail
4799{
4800namespace std_fs = std::experimental::filesystem;
4801}  // namespace detail
4802NLOHMANN_JSON_NAMESPACE_END
4803#elif JSON_HAS_FILESYSTEM
4804#include <filesystem> // NOLINT(build/c++17)
4805NLOHMANN_JSON_NAMESPACE_BEGIN
4806namespace detail
4807{
4808namespace std_fs = std::filesystem;
4809}  // namespace detail
4810NLOHMANN_JSON_NAMESPACE_END
4811#endif
4812
4813// #include <nlohmann/detail/meta/type_traits.hpp>
4814
4815// #include <nlohmann/detail/string_concat.hpp>
4816
4817// #include <nlohmann/detail/value_t.hpp>
4818
4819
4820NLOHMANN_JSON_NAMESPACE_BEGIN
4821namespace detail
4822{
4823
4824template<typename BasicJsonType>
4825inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
4826{
4827    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
4828    {
4829        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
4830    }
4831    n = nullptr;
4832}
4833
4834#ifdef JSON_HAS_CPP_17
4835#ifndef JSON_USE_IMPLICIT_CONVERSIONS
4836template<typename BasicJsonType, typename T>
4837void from_json(const BasicJsonType& j, std::optional<T>& opt)
4838{
4839    if (j.is_null())
4840    {
4841        opt = std::nullopt;
4842    }
4843    else
4844    {
4845        opt.emplace(j.template get<T>());
4846    }
4847}
4848
4849#endif // JSON_USE_IMPLICIT_CONVERSIONS
4850#endif // JSON_HAS_CPP_17
4851
4852// overloads for basic_json template parameters
4853template < typename BasicJsonType, typename ArithmeticType,
4854           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
4855                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4856                         int > = 0 >
4857void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
4858{
4859    switch (static_cast<value_t>(j))
4860    {
4861        case value_t::number_unsigned:
4862        {
4863            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4864            break;
4865        }
4866        case value_t::number_integer:
4867        {
4868            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4869            break;
4870        }
4871        case value_t::number_float:
4872        {
4873            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4874            break;
4875        }
4876
4877        case value_t::null:
4878        case value_t::object:
4879        case value_t::array:
4880        case value_t::string:
4881        case value_t::boolean:
4882        case value_t::binary:
4883        case value_t::discarded:
4884        default:
4885            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
4886    }
4887}
4888
4889template<typename BasicJsonType>
4890inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
4891{
4892    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
4893    {
4894        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
4895    }
4896    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
4897}
4898
4899template<typename BasicJsonType>
4900inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
4901{
4902    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4903    {
4904        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
4905    }
4906    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4907}
4908
4909template <
4910    typename BasicJsonType, typename StringType,
4911    enable_if_t <
4912        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
4913        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
4914        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
4915        && !is_json_ref<StringType>::value, int > = 0 >
4916inline void from_json(const BasicJsonType& j, StringType& s)
4917{
4918    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4919    {
4920        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
4921    }
4922
4923    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4924}
4925
4926template<typename BasicJsonType>
4927inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
4928{
4929    get_arithmetic_value(j, val);
4930}
4931
4932template<typename BasicJsonType>
4933inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
4934{
4935    get_arithmetic_value(j, val);
4936}
4937
4938template<typename BasicJsonType>
4939inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
4940{
4941    get_arithmetic_value(j, val);
4942}
4943
4944#if !JSON_DISABLE_ENUM_SERIALIZATION
4945template<typename BasicJsonType, typename EnumType,
4946         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
4947inline void from_json(const BasicJsonType& j, EnumType& e)
4948{
4949    typename std::underlying_type<EnumType>::type val;
4950    get_arithmetic_value(j, val);
4951    e = static_cast<EnumType>(val);
4952}
4953#endif  // JSON_DISABLE_ENUM_SERIALIZATION
4954
4955// forward_list doesn't have an insert method
4956template<typename BasicJsonType, typename T, typename Allocator,
4957         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
4958inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
4959{
4960    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4961    {
4962        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
4963    }
4964    l.clear();
4965    std::transform(j.rbegin(), j.rend(),
4966                   std::front_inserter(l), [](const BasicJsonType & i)
4967    {
4968        return i.template get<T>();
4969    });
4970}
4971
4972// valarray doesn't have an insert method
4973template<typename BasicJsonType, typename T,
4974         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
4975inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
4976{
4977    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4978    {
4979        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
4980    }
4981    l.resize(j.size());
4982    std::transform(j.begin(), j.end(), std::begin(l),
4983                   [](const BasicJsonType & elem)
4984    {
4985        return elem.template get<T>();
4986    });
4987}
4988
4989template<typename BasicJsonType, typename T, std::size_t N>
4990auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4991-> decltype(j.template get<T>(), void())
4992{
4993    for (std::size_t i = 0; i < N; ++i)
4994    {
4995        arr[i] = j.at(i).template get<T>();
4996    }
4997}
4998
4999template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2>
5000auto from_json(const BasicJsonType& j, T (&arr)[N1][N2])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5001-> decltype(j.template get<T>(), void())
5002{
5003    for (std::size_t i1 = 0; i1 < N1; ++i1)
5004    {
5005        for (std::size_t i2 = 0; i2 < N2; ++i2)
5006        {
5007            arr[i1][i2] = j.at(i1).at(i2).template get<T>();
5008        }
5009    }
5010}
5011
5012template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3>
5013auto from_json(const BasicJsonType& j, T (&arr)[N1][N2][N3])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5014-> decltype(j.template get<T>(), void())
5015{
5016    for (std::size_t i1 = 0; i1 < N1; ++i1)
5017    {
5018        for (std::size_t i2 = 0; i2 < N2; ++i2)
5019        {
5020            for (std::size_t i3 = 0; i3 < N3; ++i3)
5021            {
5022                arr[i1][i2][i3] = j.at(i1).at(i2).at(i3).template get<T>();
5023            }
5024        }
5025    }
5026}
5027
5028template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3, std::size_t N4>
5029auto from_json(const BasicJsonType& j, T (&arr)[N1][N2][N3][N4])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5030-> decltype(j.template get<T>(), void())
5031{
5032    for (std::size_t i1 = 0; i1 < N1; ++i1)
5033    {
5034        for (std::size_t i2 = 0; i2 < N2; ++i2)
5035        {
5036            for (std::size_t i3 = 0; i3 < N3; ++i3)
5037            {
5038                for (std::size_t i4 = 0; i4 < N4; ++i4)
5039                {
5040                    arr[i1][i2][i3][i4] = j.at(i1).at(i2).at(i3).at(i4).template get<T>();
5041                }
5042            }
5043        }
5044    }
5045}
5046
5047template<typename BasicJsonType>
5048inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
5049{
5050    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
5051}
5052
5053template<typename BasicJsonType, typename T, std::size_t N>
5054auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
5055                          priority_tag<2> /*unused*/)
5056-> decltype(j.template get<T>(), void())
5057{
5058    for (std::size_t i = 0; i < N; ++i)
5059    {
5060        arr[i] = j.at(i).template get<T>();
5061    }
5062}
5063
5064template<typename BasicJsonType, typename ConstructibleArrayType,
5065         enable_if_t<
5066             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
5067             int> = 0>
5068auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
5069-> decltype(
5070    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
5071    j.template get<typename ConstructibleArrayType::value_type>(),
5072    void())
5073{
5074    using std::end;
5075
5076    ConstructibleArrayType ret;
5077    ret.reserve(j.size());
5078    std::transform(j.begin(), j.end(),
5079                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
5080    {
5081        // get<BasicJsonType>() returns *this, this won't call a from_json
5082        // method when value_type is BasicJsonType
5083        return i.template get<typename ConstructibleArrayType::value_type>();
5084    });
5085    arr = std::move(ret);
5086}
5087
5088template<typename BasicJsonType, typename ConstructibleArrayType,
5089         enable_if_t<
5090             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
5091             int> = 0>
5092inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
5093                                 priority_tag<0> /*unused*/)
5094{
5095    using std::end;
5096
5097    ConstructibleArrayType ret;
5098    std::transform(
5099        j.begin(), j.end(), std::inserter(ret, end(ret)),
5100        [](const BasicJsonType & i)
5101    {
5102        // get<BasicJsonType>() returns *this, this won't call a from_json
5103        // method when value_type is BasicJsonType
5104        return i.template get<typename ConstructibleArrayType::value_type>();
5105    });
5106    arr = std::move(ret);
5107}
5108
5109template < typename BasicJsonType, typename ConstructibleArrayType,
5110           enable_if_t <
5111               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
5112               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
5113               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
5114               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
5115               !is_basic_json<ConstructibleArrayType>::value,
5116               int > = 0 >
5117auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
5118-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
5119j.template get<typename ConstructibleArrayType::value_type>(),
5120void())
5121{
5122    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5123    {
5124        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5125    }
5126
5127    from_json_array_impl(j, arr, priority_tag<3> {});
5128}
5129
5130template < typename BasicJsonType, typename T, std::size_t... Idx >
5131std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
5132                     identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
5133{
5134    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
5135}
5136
5137template < typename BasicJsonType, typename T, std::size_t N >
5138auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
5139-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
5140{
5141    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5142    {
5143        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5144    }
5145
5146    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
5147}
5148
5149template<typename BasicJsonType>
5150inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
5151{
5152    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
5153    {
5154        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
5155    }
5156
5157    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
5158}
5159
5160template<typename BasicJsonType, typename ConstructibleObjectType,
5161         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
5162inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
5163{
5164    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
5165    {
5166        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
5167    }
5168
5169    ConstructibleObjectType ret;
5170    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
5171    using value_type = typename ConstructibleObjectType::value_type;
5172    std::transform(
5173        inner_object->begin(), inner_object->end(),
5174        std::inserter(ret, ret.begin()),
5175        [](typename BasicJsonType::object_t::value_type const & p)
5176    {
5177        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
5178    });
5179    obj = std::move(ret);
5180}
5181
5182// overload for arithmetic types, not chosen for basic_json template arguments
5183// (BooleanType, etc..); note: Is it really necessary to provide explicit
5184// overloads for boolean_t etc. in case of a custom BooleanType which is not
5185// an arithmetic type?
5186template < typename BasicJsonType, typename ArithmeticType,
5187           enable_if_t <
5188               std::is_arithmetic<ArithmeticType>::value&&
5189               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
5190               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
5191               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
5192               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
5193               int > = 0 >
5194inline void from_json(const BasicJsonType& j, ArithmeticType& val)
5195{
5196    switch (static_cast<value_t>(j))
5197    {
5198        case value_t::number_unsigned:
5199        {
5200            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
5201            break;
5202        }
5203        case value_t::number_integer:
5204        {
5205            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
5206            break;
5207        }
5208        case value_t::number_float:
5209        {
5210            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
5211            break;
5212        }
5213        case value_t::boolean:
5214        {
5215            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
5216            break;
5217        }
5218
5219        case value_t::null:
5220        case value_t::object:
5221        case value_t::array:
5222        case value_t::string:
5223        case value_t::binary:
5224        case value_t::discarded:
5225        default:
5226            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
5227    }
5228}
5229
5230template<typename BasicJsonType, typename... Args, std::size_t... Idx>
5231std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
5232{
5233    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
5234}
5235
5236template<typename BasicJsonType>
5237std::tuple<> from_json_tuple_impl_base(BasicJsonType& /*unused*/, index_sequence<> /*unused*/)
5238{
5239    return {};
5240}
5241
5242template < typename BasicJsonType, class A1, class A2 >
5243std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
5244{
5245    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
5246            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
5247}
5248
5249template<typename BasicJsonType, typename A1, typename A2>
5250inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
5251{
5252    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
5253}
5254
5255template<typename BasicJsonType, typename... Args>
5256std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
5257{
5258    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
5259}
5260
5261template<typename BasicJsonType, typename... Args>
5262inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
5263{
5264    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
5265}
5266
5267template<typename BasicJsonType, typename TupleRelated>
5268auto from_json(BasicJsonType&& j, TupleRelated&& t)
5269-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
5270{
5271    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5272    {
5273        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5274    }
5275
5276    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
5277}
5278
5279template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
5280           typename = enable_if_t < !std::is_constructible <
5281                                        typename BasicJsonType::string_t, Key >::value >>
5282inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
5283{
5284    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5285    {
5286        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5287    }
5288    m.clear();
5289    for (const auto& p : j)
5290    {
5291        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
5292        {
5293            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
5294        }
5295        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
5296    }
5297}
5298
5299template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
5300           typename = enable_if_t < !std::is_constructible <
5301                                        typename BasicJsonType::string_t, Key >::value >>
5302inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
5303{
5304    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
5305    {
5306        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
5307    }
5308    m.clear();
5309    for (const auto& p : j)
5310    {
5311        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
5312        {
5313            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
5314        }
5315        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
5316    }
5317}
5318
5319#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
5320template<typename BasicJsonType>
5321inline void from_json(const BasicJsonType& j, std_fs::path& p)
5322{
5323    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
5324    {
5325        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
5326    }
5327    const auto& s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
5328#ifdef JSON_HAS_CPP_20
5329    p = std_fs::path(std::u8string_view(reinterpret_cast<const char8_t*>(s.data()), s.size()));
5330#else
5331    p = std_fs::u8path(s); // accepts UTF-8 encoded std::string in C++17, deprecated in C++20
5332#endif
5333}
5334#endif
5335
5336struct from_json_fn
5337{
5338    template<typename BasicJsonType, typename T>
5339    auto operator()(const BasicJsonType& j, T&& val) const
5340    noexcept(noexcept(from_json(j, std::forward<T>(val))))
5341    -> decltype(from_json(j, std::forward<T>(val)))
5342    {
5343        return from_json(j, std::forward<T>(val));
5344    }
5345};
5346
5347}  // namespace detail
5348
5349#ifndef JSON_HAS_CPP_17
5350/// namespace to hold default `from_json` function
5351/// to see why this is required:
5352/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
5353namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
5354{
5355#endif
5356JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
5357    detail::static_const<detail::from_json_fn>::value;
5358#ifndef JSON_HAS_CPP_17
5359}  // namespace
5360#endif
5361
5362NLOHMANN_JSON_NAMESPACE_END
5363
5364// #include <nlohmann/detail/conversions/to_json.hpp>
5365//     __ _____ _____ _____
5366//  __|  |   __|     |   | |  JSON for Modern C++
5367// |  |  |__   |  |  | | | |  version 3.12.0
5368// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
5369//
5370// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
5371// SPDX-License-Identifier: MIT
5372
5373
5374
5375// #include <nlohmann/detail/macro_scope.hpp>
5376// JSON_HAS_CPP_17
5377#ifdef JSON_HAS_CPP_17
5378    #include <optional> // optional
5379#endif
5380
5381#include <algorithm> // copy
5382#include <iterator> // begin, end
5383#include <string> // string
5384#include <tuple> // tuple, get
5385#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
5386#include <utility> // move, forward, declval, pair
5387#include <valarray> // valarray
5388#include <vector> // vector
5389
5390// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
5391//     __ _____ _____ _____
5392//  __|  |   __|     |   | |  JSON for Modern C++
5393// |  |  |__   |  |  | | | |  version 3.12.0
5394// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
5395//
5396// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
5397// SPDX-License-Identifier: MIT
5398
5399
5400
5401#include <cstddef> // size_t
5402#include <iterator> // forward_iterator_tag
5403#include <tuple> // tuple_size, get, tuple_element
5404#include <utility> // move
5405
5406#if JSON_HAS_RANGES
5407    #include <ranges> // enable_borrowed_range
5408#endif
5409
5410// #include <nlohmann/detail/abi_macros.hpp>
5411
5412// #include <nlohmann/detail/meta/type_traits.hpp>
5413
5414// #include <nlohmann/detail/string_utils.hpp>
5415//     __ _____ _____ _____
5416//  __|  |   __|     |   | |  JSON for Modern C++
5417// |  |  |__   |  |  | | | |  version 3.12.0
5418// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
5419//
5420// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
5421// SPDX-License-Identifier: MIT
5422
5423
5424
5425#include <cstddef> // size_t
5426#include <string> // string, to_string
5427
5428// #include <nlohmann/detail/abi_macros.hpp>
5429
5430
5431NLOHMANN_JSON_NAMESPACE_BEGIN
5432namespace detail
5433{
5434
5435template<typename StringType>
5436void int_to_string(StringType& target, std::size_t value)
5437{
5438    // For ADL
5439    using std::to_string;
5440    target = to_string(value);
5441}
5442
5443template<typename StringType>
5444StringType to_string(std::size_t value)
5445{
5446    StringType result;
5447    int_to_string(result, value);
5448    return result;
5449}
5450
5451}  // namespace detail
5452NLOHMANN_JSON_NAMESPACE_END
5453
5454// #include <nlohmann/detail/value_t.hpp>
5455
5456
5457NLOHMANN_JSON_NAMESPACE_BEGIN
5458namespace detail
5459{
5460
5461template<typename IteratorType> class iteration_proxy_value
5462{
5463  public:
5464    using difference_type = std::ptrdiff_t;
5465    using value_type = iteration_proxy_value;
5466    using pointer = value_type *;
5467    using reference = value_type &;
5468    using iterator_category = std::forward_iterator_tag;
5469    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
5470
5471  private:
5472    /// the iterator
5473    IteratorType anchor{};
5474    /// an index for arrays (used to create key names)
5475    std::size_t array_index = 0;
5476    /// last stringified array index
5477    mutable std::size_t array_index_last = 0;
5478    /// a string representation of the array index
5479    mutable string_type array_index_str = "0";
5480    /// an empty string (to return a reference for primitive values)
5481    string_type empty_str{};
5482
5483  public:
5484    explicit iteration_proxy_value() = default;
5485    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
5486    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
5487             && std::is_nothrow_default_constructible<string_type>::value)
5488        : anchor(std::move(it))
5489        , array_index(array_index_)
5490    {}
5491
5492    iteration_proxy_value(iteration_proxy_value const&) = default;
5493    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
5494    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
5495    iteration_proxy_value(iteration_proxy_value&&)
5496    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
5497             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
5498    iteration_proxy_value& operator=(iteration_proxy_value&&)
5499    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
5500             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
5501    ~iteration_proxy_value() = default;
5502
5503    /// dereference operator (needed for range-based for)
5504    const iteration_proxy_value& operator*() const
5505    {
5506        return *this;
5507    }
5508
5509    /// increment operator (needed for range-based for)
5510    iteration_proxy_value& operator++()
5511    {
5512        ++anchor;
5513        ++array_index;
5514
5515        return *this;
5516    }
5517
5518    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
5519    {
5520        auto tmp = iteration_proxy_value(anchor, array_index);
5521        ++anchor;
5522        ++array_index;
5523        return tmp;
5524    }
5525
5526    /// equality operator (needed for InputIterator)
5527    bool operator==(const iteration_proxy_value& o) const
5528    {
5529        return anchor == o.anchor;
5530    }
5531
5532    /// inequality operator (needed for range-based for)
5533    bool operator!=(const iteration_proxy_value& o) const
5534    {
5535        return anchor != o.anchor;
5536    }
5537
5538    /// return key of the iterator
5539    const string_type& key() const
5540    {
5541        JSON_ASSERT(anchor.m_object != nullptr);
5542
5543        switch (anchor.m_object->type())
5544        {
5545            // use integer array index as key
5546            case value_t::array:
5547            {
5548                if (array_index != array_index_last)
5549                {
5550                    int_to_string( array_index_str, array_index );
5551                    array_index_last = array_index;
5552                }
5553                return array_index_str;
5554            }
5555
5556            // use key from the object
5557            case value_t::object:
5558                return anchor.key();
5559
5560            // use an empty key for all primitive types
5561            case value_t::null:
5562            case value_t::string:
5563            case value_t::boolean:
5564            case value_t::number_integer:
5565            case value_t::number_unsigned:
5566            case value_t::number_float:
5567            case value_t::binary:
5568            case value_t::discarded:
5569            default:
5570                return empty_str;
5571        }
5572    }
5573
5574    /// return value of the iterator
5575    typename IteratorType::reference value() const
5576    {
5577        return anchor.value();
5578    }
5579};
5580
5581/// proxy class for the items() function
5582template<typename IteratorType> class iteration_proxy
5583{
5584  private:
5585    /// the container to iterate
5586    typename IteratorType::pointer container = nullptr;
5587
5588  public:
5589    explicit iteration_proxy() = default;
5590
5591    /// construct iteration proxy from a container
5592    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
5593        : container(&cont) {}
5594
5595    iteration_proxy(iteration_proxy const&) = default;
5596    iteration_proxy& operator=(iteration_proxy const&) = default;
5597    iteration_proxy(iteration_proxy&&) noexcept = default;
5598    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
5599    ~iteration_proxy() = default;
5600
5601    /// return iterator begin (needed for range-based for)
5602    iteration_proxy_value<IteratorType> begin() const noexcept
5603    {
5604        return iteration_proxy_value<IteratorType>(container->begin());
5605    }
5606
5607    /// return iterator end (needed for range-based for)
5608    iteration_proxy_value<IteratorType> end() const noexcept
5609    {
5610        return iteration_proxy_value<IteratorType>(container->end());
5611    }
5612};
5613
5614// Structured Bindings Support
5615// For further reference see https://blog.tartanllama.xyz/structured-bindings/
5616// And see https://github.com/nlohmann/json/pull/1391
5617template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
5618auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
5619{
5620    return i.key();
5621}
5622// Structured Bindings Support
5623// For further reference see https://blog.tartanllama.xyz/structured-bindings/
5624// And see https://github.com/nlohmann/json/pull/1391
5625template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
5626auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
5627{
5628    return i.value();
5629}
5630
5631}  // namespace detail
5632NLOHMANN_JSON_NAMESPACE_END
5633
5634// The Addition to the STD Namespace is required to add
5635// Structured Bindings Support to the iteration_proxy_value class
5636// For further reference see https://blog.tartanllama.xyz/structured-bindings/
5637// And see https://github.com/nlohmann/json/pull/1391
5638namespace std
5639{
5640
5641#if defined(__clang__)
5642    // Fix: https://github.com/nlohmann/json/issues/1401
5643    #pragma clang diagnostic push
5644    #pragma clang diagnostic ignored "-Wmismatched-tags"
5645#endif
5646template<typename IteratorType>
5647class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
5648    : public std::integral_constant<std::size_t, 2> {};
5649
5650template<std::size_t N, typename IteratorType>
5651class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
5652{
5653  public:
5654    using type = decltype(
5655                     get<N>(std::declval <
5656                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
5657};
5658#if defined(__clang__)
5659    #pragma clang diagnostic pop
5660#endif
5661
5662}  // namespace std
5663
5664#if JSON_HAS_RANGES
5665    template <typename IteratorType>
5666    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
5667#endif
5668
5669// #include <nlohmann/detail/meta/cpp_future.hpp>
5670
5671// #include <nlohmann/detail/meta/std_fs.hpp>
5672
5673// #include <nlohmann/detail/meta/type_traits.hpp>
5674
5675// #include <nlohmann/detail/value_t.hpp>
5676
5677
5678NLOHMANN_JSON_NAMESPACE_BEGIN
5679namespace detail
5680{
5681
5682//////////////////
5683// constructors //
5684//////////////////
5685
5686/*
5687 * Note all external_constructor<>::construct functions need to call
5688 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
5689 * allocated value (e.g., a string). See bug issue
5690 * https://github.com/nlohmann/json/issues/2865 for more information.
5691 */
5692
5693template<value_t> struct external_constructor;
5694
5695template<>
5696struct external_constructor<value_t::boolean>
5697{
5698    template<typename BasicJsonType>
5699    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
5700    {
5701        j.m_data.m_value.destroy(j.m_data.m_type);
5702        j.m_data.m_type = value_t::boolean;
5703        j.m_data.m_value = b;
5704        j.assert_invariant();
5705    }
5706};
5707
5708template<>
5709struct external_constructor<value_t::string>
5710{
5711    template<typename BasicJsonType>
5712    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
5713    {
5714        j.m_data.m_value.destroy(j.m_data.m_type);
5715        j.m_data.m_type = value_t::string;
5716        j.m_data.m_value = s;
5717        j.assert_invariant();
5718    }
5719
5720    template<typename BasicJsonType>
5721    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
5722    {
5723        j.m_data.m_value.destroy(j.m_data.m_type);
5724        j.m_data.m_type = value_t::string;
5725        j.m_data.m_value = std::move(s);
5726        j.assert_invariant();
5727    }
5728
5729    template < typename BasicJsonType, typename CompatibleStringType,
5730               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
5731                             int > = 0 >
5732    static void construct(BasicJsonType& j, const CompatibleStringType& str)
5733    {
5734        j.m_data.m_value.destroy(j.m_data.m_type);
5735        j.m_data.m_type = value_t::string;
5736        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
5737        j.assert_invariant();
5738    }
5739};
5740
5741template<>
5742struct external_constructor<value_t::binary>
5743{
5744    template<typename BasicJsonType>
5745    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
5746    {
5747        j.m_data.m_value.destroy(j.m_data.m_type);
5748        j.m_data.m_type = value_t::binary;
5749        j.m_data.m_value = typename BasicJsonType::binary_t(b);
5750        j.assert_invariant();
5751    }
5752
5753    template<typename BasicJsonType>
5754    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
5755    {
5756        j.m_data.m_value.destroy(j.m_data.m_type);
5757        j.m_data.m_type = value_t::binary;
5758        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
5759        j.assert_invariant();
5760    }
5761};
5762
5763template<>
5764struct external_constructor<value_t::number_float>
5765{
5766    template<typename BasicJsonType>
5767    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
5768    {
5769        j.m_data.m_value.destroy(j.m_data.m_type);
5770        j.m_data.m_type = value_t::number_float;
5771        j.m_data.m_value = val;
5772        j.assert_invariant();
5773    }
5774};
5775
5776template<>
5777struct external_constructor<value_t::number_unsigned>
5778{
5779    template<typename BasicJsonType>
5780    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
5781    {
5782        j.m_data.m_value.destroy(j.m_data.m_type);
5783        j.m_data.m_type = value_t::number_unsigned;
5784        j.m_data.m_value = val;
5785        j.assert_invariant();
5786    }
5787};
5788
5789template<>
5790struct external_constructor<value_t::number_integer>
5791{
5792    template<typename BasicJsonType>
5793    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
5794    {
5795        j.m_data.m_value.destroy(j.m_data.m_type);
5796        j.m_data.m_type = value_t::number_integer;
5797        j.m_data.m_value = val;
5798        j.assert_invariant();
5799    }
5800};
5801
5802template<>
5803struct external_constructor<value_t::array>
5804{
5805    template<typename BasicJsonType>
5806    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
5807    {
5808        j.m_data.m_value.destroy(j.m_data.m_type);
5809        j.m_data.m_type = value_t::array;
5810        j.m_data.m_value = arr;
5811        j.set_parents();
5812        j.assert_invariant();
5813    }
5814
5815    template<typename BasicJsonType>
5816    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
5817    {
5818        j.m_data.m_value.destroy(j.m_data.m_type);
5819        j.m_data.m_type = value_t::array;
5820        j.m_data.m_value = std::move(arr);
5821        j.set_parents();
5822        j.assert_invariant();
5823    }
5824
5825    template < typename BasicJsonType, typename CompatibleArrayType,
5826               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
5827                             int > = 0 >
5828    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
5829    {
5830        using std::begin;
5831        using std::end;
5832
5833        j.m_data.m_value.destroy(j.m_data.m_type);
5834        j.m_data.m_type = value_t::array;
5835        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
5836        j.set_parents();
5837        j.assert_invariant();
5838    }
5839
5840    template<typename BasicJsonType>
5841    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
5842    {
5843        j.m_data.m_value.destroy(j.m_data.m_type);
5844        j.m_data.m_type = value_t::array;
5845        j.m_data.m_value = value_t::array;
5846        j.m_data.m_value.array->reserve(arr.size());
5847        for (const bool x : arr)
5848        {
5849            j.m_data.m_value.array->push_back(x);
5850            j.set_parent(j.m_data.m_value.array->back());
5851        }
5852        j.assert_invariant();
5853    }
5854
5855    template<typename BasicJsonType, typename T,
5856             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
5857    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
5858    {
5859        j.m_data.m_value.destroy(j.m_data.m_type);
5860        j.m_data.m_type = value_t::array;
5861        j.m_data.m_value = value_t::array;
5862        j.m_data.m_value.array->resize(arr.size());
5863        if (arr.size() > 0)
5864        {
5865            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
5866        }
5867        j.set_parents();
5868        j.assert_invariant();
5869    }
5870};
5871
5872template<>
5873struct external_constructor<value_t::object>
5874{
5875    template<typename BasicJsonType>
5876    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
5877    {
5878        j.m_data.m_value.destroy(j.m_data.m_type);
5879        j.m_data.m_type = value_t::object;
5880        j.m_data.m_value = obj;
5881        j.set_parents();
5882        j.assert_invariant();
5883    }
5884
5885    template<typename BasicJsonType>
5886    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
5887    {
5888        j.m_data.m_value.destroy(j.m_data.m_type);
5889        j.m_data.m_type = value_t::object;
5890        j.m_data.m_value = std::move(obj);
5891        j.set_parents();
5892        j.assert_invariant();
5893    }
5894
5895    template < typename BasicJsonType, typename CompatibleObjectType,
5896               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
5897    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
5898    {
5899        using std::begin;
5900        using std::end;
5901
5902        j.m_data.m_value.destroy(j.m_data.m_type);
5903        j.m_data.m_type = value_t::object;
5904        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
5905        j.set_parents();
5906        j.assert_invariant();
5907    }
5908};
5909
5910/////////////
5911// to_json //
5912/////////////
5913
5914#ifdef JSON_HAS_CPP_17
5915template<typename BasicJsonType, typename T,
5916         enable_if_t<std::is_constructible<BasicJsonType, T>::value, int> = 0>
5917void to_json(BasicJsonType& j, const std::optional<T>& opt)
5918{
5919    if (opt.has_value())
5920    {
5921        j = *opt;
5922    }
5923    else
5924    {
5925        j = nullptr;
5926    }
5927}
5928#endif
5929
5930template<typename BasicJsonType, typename T,
5931         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
5932inline void to_json(BasicJsonType& j, T b) noexcept
5933{
5934    external_constructor<value_t::boolean>::construct(j, b);
5935}
5936
5937template < typename BasicJsonType, typename BoolRef,
5938           enable_if_t <
5939               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
5940                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
5941                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
5942                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
5943                                      typename BasicJsonType::boolean_t >::value))
5944               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
5945inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
5946{
5947    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
5948}
5949
5950template<typename BasicJsonType, typename CompatibleString,
5951         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
5952inline void to_json(BasicJsonType& j, const CompatibleString& s)
5953{
5954    external_constructor<value_t::string>::construct(j, s);
5955}
5956
5957template<typename BasicJsonType>
5958inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
5959{
5960    external_constructor<value_t::string>::construct(j, std::move(s));
5961}
5962
5963template<typename BasicJsonType, typename FloatType,
5964         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
5965inline void to_json(BasicJsonType& j, FloatType val) noexcept
5966{
5967    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
5968}
5969
5970template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
5971         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
5972inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
5973{
5974    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
5975}
5976
5977template<typename BasicJsonType, typename CompatibleNumberIntegerType,
5978         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
5979inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
5980{
5981    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
5982}
5983
5984#if !JSON_DISABLE_ENUM_SERIALIZATION
5985template<typename BasicJsonType, typename EnumType,
5986         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
5987inline void to_json(BasicJsonType& j, EnumType e) noexcept
5988{
5989    using underlying_type = typename std::underlying_type<EnumType>::type;
5990    static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
5991    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
5992}
5993#endif  // JSON_DISABLE_ENUM_SERIALIZATION
5994
5995template<typename BasicJsonType>
5996inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
5997{
5998    external_constructor<value_t::array>::construct(j, e);
5999}
6000
6001template < typename BasicJsonType, typename CompatibleArrayType,
6002           enable_if_t < is_compatible_array_type<BasicJsonType,
6003                         CompatibleArrayType>::value&&
6004                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
6005                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
6006                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
6007                         !is_basic_json<CompatibleArrayType>::value,
6008                         int > = 0 >
6009inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
6010{
6011    external_constructor<value_t::array>::construct(j, arr);
6012}
6013
6014template<typename BasicJsonType>
6015inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
6016{
6017    external_constructor<value_t::binary>::construct(j, bin);
6018}
6019
6020template<typename BasicJsonType, typename T,
6021         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
6022inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
6023{
6024    external_constructor<value_t::array>::construct(j, std::move(arr));
6025}
6026
6027template<typename BasicJsonType>
6028inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
6029{
6030    external_constructor<value_t::array>::construct(j, std::move(arr));
6031}
6032
6033template < typename BasicJsonType, typename CompatibleObjectType,
6034           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
6035inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
6036{
6037    external_constructor<value_t::object>::construct(j, obj);
6038}
6039
6040template<typename BasicJsonType>
6041inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
6042{
6043    external_constructor<value_t::object>::construct(j, std::move(obj));
6044}
6045
6046template <
6047    typename BasicJsonType, typename T, std::size_t N,
6048    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
6049                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
6050                  int > = 0 >
6051inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
6052{
6053    external_constructor<value_t::array>::construct(j, arr);
6054}
6055
6056template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
6057inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
6058{
6059    j = { p.first, p.second };
6060}
6061
6062// for https://github.com/nlohmann/json/pull/1134
6063template<typename BasicJsonType, typename T,
6064         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
6065inline void to_json(BasicJsonType& j, const T& b)
6066{
6067    j = { {b.key(), b.value()} };
6068}
6069
6070template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
6071inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
6072{
6073    j = { std::get<Idx>(t)... };
6074}
6075
6076template<typename BasicJsonType, typename Tuple>
6077inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& /*unused*/, index_sequence<> /*unused*/)
6078{
6079    using array_t = typename BasicJsonType::array_t;
6080    j = array_t();
6081}
6082
6083template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
6084inline void to_json(BasicJsonType& j, const T& t)
6085{
6086    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
6087}
6088
6089#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
6090template<typename BasicJsonType>
6091inline void to_json(BasicJsonType& j, const std_fs::path& p)
6092{
6093#ifdef JSON_HAS_CPP_20
6094    const std::u8string s = p.u8string();
6095    j = std::string(s.begin(), s.end());
6096#else
6097    j = p.u8string(); // returns std::string in C++17
6098#endif
6099}
6100#endif
6101
6102struct to_json_fn
6103{
6104    template<typename BasicJsonType, typename T>
6105    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
6106    -> decltype(to_json(j, std::forward<T>(val)), void())
6107    {
6108        return to_json(j, std::forward<T>(val));
6109    }
6110};
6111}  // namespace detail
6112
6113#ifndef JSON_HAS_CPP_17
6114/// namespace to hold default `to_json` function
6115/// to see why this is required:
6116/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
6117namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
6118{
6119#endif
6120JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
6121    detail::static_const<detail::to_json_fn>::value;
6122#ifndef JSON_HAS_CPP_17
6123}  // namespace
6124#endif
6125
6126NLOHMANN_JSON_NAMESPACE_END
6127
6128// #include <nlohmann/detail/meta/identity_tag.hpp>
6129
6130
6131NLOHMANN_JSON_NAMESPACE_BEGIN
6132
6133/// @sa https://json.nlohmann.me/api/adl_serializer/
6134template<typename ValueType, typename>
6135struct adl_serializer
6136{
6137    /// @brief convert a JSON value to any value type
6138    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
6139    template<typename BasicJsonType, typename TargetType = ValueType>
6140    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
6141        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
6142    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
6143    {
6144        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
6145    }
6146
6147    /// @brief convert a JSON value to any value type
6148    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
6149    template<typename BasicJsonType, typename TargetType = ValueType>
6150    static auto from_json(BasicJsonType && j) noexcept(
6151    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
6152    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
6153    {
6154        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
6155    }
6156
6157    /// @brief convert any value type to a JSON value
6158    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
6159    template<typename BasicJsonType, typename TargetType = ValueType>
6160    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
6161        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
6162    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
6163    {
6164        ::nlohmann::to_json(j, std::forward<TargetType>(val));
6165    }
6166};
6167
6168NLOHMANN_JSON_NAMESPACE_END
6169
6170// #include <nlohmann/byte_container_with_subtype.hpp>
6171//     __ _____ _____ _____
6172//  __|  |   __|     |   | |  JSON for Modern C++
6173// |  |  |__   |  |  | | | |  version 3.12.0
6174// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
6175//
6176// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
6177// SPDX-License-Identifier: MIT
6178
6179
6180
6181#include <cstdint> // uint8_t, uint64_t
6182#include <tuple> // tie
6183#include <utility> // move
6184
6185// #include <nlohmann/detail/abi_macros.hpp>
6186
6187
6188NLOHMANN_JSON_NAMESPACE_BEGIN
6189
6190/// @brief an internal type for a backed binary type
6191/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
6192template<typename BinaryType>
6193class byte_container_with_subtype : public BinaryType
6194{
6195  public:
6196    using container_type = BinaryType;
6197    using subtype_type = std::uint64_t;
6198
6199    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
6200    byte_container_with_subtype() noexcept(noexcept(container_type()))
6201        : container_type()
6202    {}
6203
6204    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
6205    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
6206        : container_type(b)
6207    {}
6208
6209    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
6210    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
6211        : container_type(std::move(b))
6212    {}
6213
6214    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
6215    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
6216        : container_type(b)
6217        , m_subtype(subtype_)
6218        , m_has_subtype(true)
6219    {}
6220
6221    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
6222    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
6223        : container_type(std::move(b))
6224        , m_subtype(subtype_)
6225        , m_has_subtype(true)
6226    {}
6227
6228    bool operator==(const byte_container_with_subtype& rhs) const
6229    {
6230        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
6231               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
6232    }
6233
6234    bool operator!=(const byte_container_with_subtype& rhs) const
6235    {
6236        return !(rhs == *this);
6237    }
6238
6239    /// @brief sets the binary subtype
6240    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
6241    void set_subtype(subtype_type subtype_) noexcept
6242    {
6243        m_subtype = subtype_;
6244        m_has_subtype = true;
6245    }
6246
6247    /// @brief return the binary subtype
6248    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
6249    constexpr subtype_type subtype() const noexcept
6250    {
6251        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
6252    }
6253
6254    /// @brief return whether the value has a subtype
6255    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
6256    constexpr bool has_subtype() const noexcept
6257    {
6258        return m_has_subtype;
6259    }
6260
6261    /// @brief clears the binary subtype
6262    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
6263    void clear_subtype() noexcept
6264    {
6265        m_subtype = 0;
6266        m_has_subtype = false;
6267    }
6268
6269  private:
6270    subtype_type m_subtype = 0;
6271    bool m_has_subtype = false;
6272};
6273
6274NLOHMANN_JSON_NAMESPACE_END
6275
6276// #include <nlohmann/detail/conversions/from_json.hpp>
6277
6278// #include <nlohmann/detail/conversions/to_json.hpp>
6279
6280// #include <nlohmann/detail/exceptions.hpp>
6281
6282// #include <nlohmann/detail/hash.hpp>
6283//     __ _____ _____ _____
6284//  __|  |   __|     |   | |  JSON for Modern C++
6285// |  |  |__   |  |  | | | |  version 3.12.0
6286// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
6287//
6288// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
6289// SPDX-License-Identifier: MIT
6290
6291
6292
6293#include <cstdint> // uint8_t
6294#include <cstddef> // size_t
6295#include <functional> // hash
6296
6297// #include <nlohmann/detail/abi_macros.hpp>
6298
6299// #include <nlohmann/detail/value_t.hpp>
6300
6301
6302NLOHMANN_JSON_NAMESPACE_BEGIN
6303namespace detail
6304{
6305
6306// boost::hash_combine
6307inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
6308{
6309    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
6310    return seed;
6311}
6312
6313/*!
6314@brief hash a JSON value
6315
6316The hash function tries to rely on std::hash where possible. Furthermore, the
6317type of the JSON value is taken into account to have different hash values for
6318null, 0, 0U, and false, etc.
6319
6320@tparam BasicJsonType basic_json specialization
6321@param j JSON value to hash
6322@return hash value of j
6323*/
6324template<typename BasicJsonType>
6325std::size_t hash(const BasicJsonType& j)
6326{
6327    using string_t = typename BasicJsonType::string_t;
6328    using number_integer_t = typename BasicJsonType::number_integer_t;
6329    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6330    using number_float_t = typename BasicJsonType::number_float_t;
6331
6332    const auto type = static_cast<std::size_t>(j.type());
6333    switch (j.type())
6334    {
6335        case BasicJsonType::value_t::null:
6336        case BasicJsonType::value_t::discarded:
6337        {
6338            return combine(type, 0);
6339        }
6340
6341        case BasicJsonType::value_t::object:
6342        {
6343            auto seed = combine(type, j.size());
6344            for (const auto& element : j.items())
6345            {
6346                const auto h = std::hash<string_t> {}(element.key());
6347                seed = combine(seed, h);
6348                seed = combine(seed, hash(element.value()));
6349            }
6350            return seed;
6351        }
6352
6353        case BasicJsonType::value_t::array:
6354        {
6355            auto seed = combine(type, j.size());
6356            for (const auto& element : j)
6357            {
6358                seed = combine(seed, hash(element));
6359            }
6360            return seed;
6361        }
6362
6363        case BasicJsonType::value_t::string:
6364        {
6365            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
6366            return combine(type, h);
6367        }
6368
6369        case BasicJsonType::value_t::boolean:
6370        {
6371            const auto h = std::hash<bool> {}(j.template get<bool>());
6372            return combine(type, h);
6373        }
6374
6375        case BasicJsonType::value_t::number_integer:
6376        {
6377            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
6378            return combine(type, h);
6379        }
6380
6381        case BasicJsonType::value_t::number_unsigned:
6382        {
6383            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
6384            return combine(type, h);
6385        }
6386
6387        case BasicJsonType::value_t::number_float:
6388        {
6389            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
6390            return combine(type, h);
6391        }
6392
6393        case BasicJsonType::value_t::binary:
6394        {
6395            auto seed = combine(type, j.get_binary().size());
6396            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
6397            seed = combine(seed, h);
6398            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
6399            for (const auto byte : j.get_binary())
6400            {
6401                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
6402            }
6403            return seed;
6404        }
6405
6406        default:                   // LCOV_EXCL_LINE
6407            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
6408            return 0;              // LCOV_EXCL_LINE
6409    }
6410}
6411
6412}  // namespace detail
6413NLOHMANN_JSON_NAMESPACE_END
6414
6415// #include <nlohmann/detail/input/binary_reader.hpp>
6416//     __ _____ _____ _____
6417//  __|  |   __|     |   | |  JSON for Modern C++
6418// |  |  |__   |  |  | | | |  version 3.12.0
6419// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
6420//
6421// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
6422// SPDX-License-Identifier: MIT
6423
6424
6425
6426#include <algorithm> // generate_n
6427#include <array> // array
6428#include <cmath> // ldexp
6429#include <cstddef> // size_t
6430#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
6431#include <cstdio> // snprintf
6432#include <cstring> // memcpy
6433#include <iterator> // back_inserter
6434#include <limits> // numeric_limits
6435#include <string> // char_traits, string
6436#include <utility> // make_pair, move
6437#include <vector> // vector
6438#ifdef __cpp_lib_byteswap
6439    #include <bit>  //byteswap
6440#endif
6441
6442// #include <nlohmann/detail/exceptions.hpp>
6443
6444// #include <nlohmann/detail/input/input_adapters.hpp>
6445//     __ _____ _____ _____
6446//  __|  |   __|     |   | |  JSON for Modern C++
6447// |  |  |__   |  |  | | | |  version 3.12.0
6448// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
6449//
6450// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
6451// SPDX-License-Identifier: MIT
6452
6453
6454
6455#include <array> // array
6456#include <cstddef> // size_t
6457#include <cstring> // strlen
6458#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
6459#include <memory> // shared_ptr, make_shared, addressof
6460#include <numeric> // accumulate
6461#include <string> // string, char_traits
6462#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
6463#include <utility> // pair, declval
6464
6465#ifndef JSON_NO_IO
6466    #include <cstdio>   // FILE *
6467    #include <istream>  // istream
6468#endif                  // JSON_NO_IO
6469
6470// #include <nlohmann/detail/exceptions.hpp>
6471
6472// #include <nlohmann/detail/iterators/iterator_traits.hpp>
6473
6474// #include <nlohmann/detail/macro_scope.hpp>
6475
6476// #include <nlohmann/detail/meta/type_traits.hpp>
6477
6478
6479NLOHMANN_JSON_NAMESPACE_BEGIN
6480namespace detail
6481{
6482
6483/// the supported input formats
6484enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
6485
6486////////////////////
6487// input adapters //
6488////////////////////
6489
6490#ifndef JSON_NO_IO
6491/*!
6492Input adapter for stdio file access. This adapter read only 1 byte and do not use any
6493 buffer. This adapter is a very low level adapter.
6494*/
6495class file_input_adapter
6496{
6497  public:
6498    using char_type = char;
6499
6500    JSON_HEDLEY_NON_NULL(2)
6501    explicit file_input_adapter(std::FILE* f) noexcept
6502        : m_file(f)
6503    {
6504        JSON_ASSERT(m_file != nullptr);
6505    }
6506
6507    // make class move-only
6508    file_input_adapter(const file_input_adapter&) = delete;
6509    file_input_adapter(file_input_adapter&&) noexcept = default;
6510    file_input_adapter& operator=(const file_input_adapter&) = delete;
6511    file_input_adapter& operator=(file_input_adapter&&) = delete;
6512    ~file_input_adapter() = default;
6513
6514    std::char_traits<char>::int_type get_character() noexcept
6515    {
6516        return std::fgetc(m_file);
6517    }
6518
6519    // returns the number of characters successfully read
6520    template<class T>
6521    std::size_t get_elements(T* dest, std::size_t count = 1)
6522    {
6523        return fread(dest, 1, sizeof(T) * count, m_file);
6524    }
6525
6526  private:
6527    /// the file pointer to read from
6528    std::FILE* m_file;
6529};
6530
6531/*!
6532Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
6533beginning of input. Does not support changing the underlying std::streambuf
6534in mid-input. Maintains underlying std::istream and std::streambuf to support
6535subsequent use of standard std::istream operations to process any input
6536characters following those used in parsing the JSON input.  Clears the
6537std::istream flags; any input errors (e.g., EOF) will be detected by the first
6538subsequent call for input from the std::istream.
6539*/
6540class input_stream_adapter
6541{
6542  public:
6543    using char_type = char;
6544
6545    ~input_stream_adapter()
6546    {
6547        // clear stream flags; we use underlying streambuf I/O, do not
6548        // maintain ifstream flags, except eof
6549        if (is != nullptr)
6550        {
6551            is->clear(is->rdstate() & std::ios::eofbit);
6552        }
6553    }
6554
6555    explicit input_stream_adapter(std::istream& i)
6556        : is(&i), sb(i.rdbuf())
6557    {}
6558
6559    // delete because of pointer members
6560    input_stream_adapter(const input_stream_adapter&) = delete;
6561    input_stream_adapter& operator=(input_stream_adapter&) = delete;
6562    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
6563
6564    input_stream_adapter(input_stream_adapter&& rhs) noexcept
6565        : is(rhs.is), sb(rhs.sb)
6566    {
6567        rhs.is = nullptr;
6568        rhs.sb = nullptr;
6569    }
6570
6571    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
6572    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
6573    // end up as the same value, e.g. 0xFFFFFFFF.
6574    std::char_traits<char>::int_type get_character()
6575    {
6576        auto res = sb->sbumpc();
6577        // set eof manually, as we don't use the istream interface.
6578        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
6579        {
6580            is->clear(is->rdstate() | std::ios::eofbit);
6581        }
6582        return res;
6583    }
6584
6585    template<class T>
6586    std::size_t get_elements(T* dest, std::size_t count = 1)
6587    {
6588        auto res = static_cast<std::size_t>(sb->sgetn(reinterpret_cast<char*>(dest), static_cast<std::streamsize>(count * sizeof(T))));
6589        if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T)))
6590        {
6591            is->clear(is->rdstate() | std::ios::eofbit);
6592        }
6593        return res;
6594    }
6595
6596  private:
6597    /// the associated input stream
6598    std::istream* is = nullptr;
6599    std::streambuf* sb = nullptr;
6600};
6601#endif  // JSON_NO_IO
6602
6603// General-purpose iterator-based adapter. It might not be as fast as
6604// theoretically possible for some containers, but it is extremely versatile.
6605template<typename IteratorType>
6606class iterator_input_adapter
6607{
6608  public:
6609    using char_type = typename std::iterator_traits<IteratorType>::value_type;
6610
6611    iterator_input_adapter(IteratorType first, IteratorType last)
6612        : current(std::move(first)), end(std::move(last))
6613    {}
6614
6615    typename char_traits<char_type>::int_type get_character()
6616    {
6617        if (JSON_HEDLEY_LIKELY(current != end))
6618        {
6619            auto result = char_traits<char_type>::to_int_type(*current);
6620            std::advance(current, 1);
6621            return result;
6622        }
6623
6624        return char_traits<char_type>::eof();
6625    }
6626
6627    // for general iterators, we cannot really do something better than falling back to processing the range one-by-one
6628    template<class T>
6629    std::size_t get_elements(T* dest, std::size_t count = 1)
6630    {
6631        auto* ptr = reinterpret_cast<char*>(dest);
6632        for (std::size_t read_index = 0; read_index < count * sizeof(T); ++read_index)
6633        {
6634            if (JSON_HEDLEY_LIKELY(current != end))
6635            {
6636                ptr[read_index] = static_cast<char>(*current);
6637                std::advance(current, 1);
6638            }
6639            else
6640            {
6641                return read_index;
6642            }
6643        }
6644        return count * sizeof(T);
6645    }
6646
6647  private:
6648    IteratorType current;
6649    IteratorType end;
6650
6651    template<typename BaseInputAdapter, size_t T>
6652    friend struct wide_string_input_helper;
6653
6654    bool empty() const
6655    {
6656        return current == end;
6657    }
6658};
6659
6660template<typename BaseInputAdapter, size_t T>
6661struct wide_string_input_helper;
6662
6663template<typename BaseInputAdapter>
6664struct wide_string_input_helper<BaseInputAdapter, 4>
6665{
6666    // UTF-32
6667    static void fill_buffer(BaseInputAdapter& input,
6668                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
6669                            size_t& utf8_bytes_index,
6670                            size_t& utf8_bytes_filled)
6671    {
6672        utf8_bytes_index = 0;
6673
6674        if (JSON_HEDLEY_UNLIKELY(input.empty()))
6675        {
6676            utf8_bytes[0] = std::char_traits<char>::eof();
6677            utf8_bytes_filled = 1;
6678        }
6679        else
6680        {
6681            // get the current character
6682            const auto wc = input.get_character();
6683
6684            // UTF-32 to UTF-8 encoding
6685            if (wc < 0x80)
6686            {
6687                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6688                utf8_bytes_filled = 1;
6689            }
6690            else if (wc <= 0x7FF)
6691            {
6692                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
6693                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6694                utf8_bytes_filled = 2;
6695            }
6696            else if (wc <= 0xFFFF)
6697            {
6698                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
6699                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6700                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6701                utf8_bytes_filled = 3;
6702            }
6703            else if (wc <= 0x10FFFF)
6704            {
6705                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
6706                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
6707                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6708                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6709                utf8_bytes_filled = 4;
6710            }
6711            else
6712            {
6713                // unknown character
6714                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6715                utf8_bytes_filled = 1;
6716            }
6717        }
6718    }
6719};
6720
6721template<typename BaseInputAdapter>
6722struct wide_string_input_helper<BaseInputAdapter, 2>
6723{
6724    // UTF-16
6725    static void fill_buffer(BaseInputAdapter& input,
6726                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
6727                            size_t& utf8_bytes_index,
6728                            size_t& utf8_bytes_filled)
6729    {
6730        utf8_bytes_index = 0;
6731
6732        if (JSON_HEDLEY_UNLIKELY(input.empty()))
6733        {
6734            utf8_bytes[0] = std::char_traits<char>::eof();
6735            utf8_bytes_filled = 1;
6736        }
6737        else
6738        {
6739            // get the current character
6740            const auto wc = input.get_character();
6741
6742            // UTF-16 to UTF-8 encoding
6743            if (wc < 0x80)
6744            {
6745                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6746                utf8_bytes_filled = 1;
6747            }
6748            else if (wc <= 0x7FF)
6749            {
6750                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
6751                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6752                utf8_bytes_filled = 2;
6753            }
6754            else if (0xD800 > wc || wc >= 0xE000)
6755            {
6756                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
6757                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6758                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6759                utf8_bytes_filled = 3;
6760            }
6761            else
6762            {
6763                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
6764                {
6765                    const auto wc2 = static_cast<unsigned int>(input.get_character());
6766                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
6767                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
6768                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
6769                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
6770                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
6771                    utf8_bytes_filled = 4;
6772                }
6773                else
6774                {
6775                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6776                    utf8_bytes_filled = 1;
6777                }
6778            }
6779        }
6780    }
6781};
6782
6783// Wraps another input adapter to convert wide character types into individual bytes.
6784template<typename BaseInputAdapter, typename WideCharType>
6785class wide_string_input_adapter
6786{
6787  public:
6788    using char_type = char;
6789
6790    wide_string_input_adapter(BaseInputAdapter base)
6791        : base_adapter(base) {}
6792
6793    typename std::char_traits<char>::int_type get_character() noexcept
6794    {
6795        // check if buffer needs to be filled
6796        if (utf8_bytes_index == utf8_bytes_filled)
6797        {
6798            fill_buffer<sizeof(WideCharType)>();
6799
6800            JSON_ASSERT(utf8_bytes_filled > 0);
6801            JSON_ASSERT(utf8_bytes_index == 0);
6802        }
6803
6804        // use buffer
6805        JSON_ASSERT(utf8_bytes_filled > 0);
6806        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
6807        return utf8_bytes[utf8_bytes_index++];
6808    }
6809
6810    // parsing binary with wchar doesn't make sense, but since the parsing mode can be runtime, we need something here
6811    template<class T>
6812    std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
6813    {
6814        JSON_THROW(parse_error::create(112, 1, "wide string type cannot be interpreted as binary data", nullptr));
6815    }
6816
6817  private:
6818    BaseInputAdapter base_adapter;
6819
6820    template<size_t T>
6821    void fill_buffer()
6822    {
6823        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
6824    }
6825
6826    /// a buffer for UTF-8 bytes
6827    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
6828
6829    /// index to the utf8_codes array for the next valid byte
6830    std::size_t utf8_bytes_index = 0;
6831    /// number of valid bytes in the utf8_codes array
6832    std::size_t utf8_bytes_filled = 0;
6833};
6834
6835template<typename IteratorType, typename Enable = void>
6836struct iterator_input_adapter_factory
6837{
6838    using iterator_type = IteratorType;
6839    using char_type = typename std::iterator_traits<iterator_type>::value_type;
6840    using adapter_type = iterator_input_adapter<iterator_type>;
6841
6842    static adapter_type create(IteratorType first, IteratorType last)
6843    {
6844        return adapter_type(std::move(first), std::move(last));
6845    }
6846};
6847
6848template<typename T>
6849struct is_iterator_of_multibyte
6850{
6851    using value_type = typename std::iterator_traits<T>::value_type;
6852    enum
6853    {
6854        value = sizeof(value_type) > 1
6855    };
6856};
6857
6858template<typename IteratorType>
6859struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
6860{
6861    using iterator_type = IteratorType;
6862    using char_type = typename std::iterator_traits<iterator_type>::value_type;
6863    using base_adapter_type = iterator_input_adapter<iterator_type>;
6864    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
6865
6866    static adapter_type create(IteratorType first, IteratorType last)
6867    {
6868        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
6869    }
6870};
6871
6872// General purpose iterator-based input
6873template<typename IteratorType>
6874typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
6875{
6876    using factory_type = iterator_input_adapter_factory<IteratorType>;
6877    return factory_type::create(first, last);
6878}
6879
6880// Convenience shorthand from container to iterator
6881// Enables ADL on begin(container) and end(container)
6882// Encloses the using declarations in namespace for not to leak them to outside scope
6883
6884namespace container_input_adapter_factory_impl
6885{
6886
6887using std::begin;
6888using std::end;
6889
6890template<typename ContainerType, typename Enable = void>
6891struct container_input_adapter_factory {};
6892
6893template<typename ContainerType>
6894struct container_input_adapter_factory< ContainerType,
6895       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
6896       {
6897           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
6898
6899           static adapter_type create(const ContainerType& container)
6900{
6901    return input_adapter(begin(container), end(container));
6902}
6903       };
6904
6905}  // namespace container_input_adapter_factory_impl
6906
6907template<typename ContainerType>
6908typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
6909{
6910    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
6911}
6912
6913// specialization for std::string
6914using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));
6915
6916#ifndef JSON_NO_IO
6917// Special cases with fast paths
6918inline file_input_adapter input_adapter(std::FILE* file)
6919{
6920    if (file == nullptr)
6921    {
6922        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
6923    }
6924    return file_input_adapter(file);
6925}
6926
6927inline input_stream_adapter input_adapter(std::istream& stream)
6928{
6929    return input_stream_adapter(stream);
6930}
6931
6932inline input_stream_adapter input_adapter(std::istream&& stream)
6933{
6934    return input_stream_adapter(stream);
6935}
6936#endif  // JSON_NO_IO
6937
6938using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
6939
6940// Null-delimited strings, and the like.
6941template < typename CharT,
6942           typename std::enable_if <
6943               std::is_pointer<CharT>::value&&
6944               !std::is_array<CharT>::value&&
6945               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
6946               sizeof(typename std::remove_pointer<CharT>::type) == 1,
6947               int >::type = 0 >
6948contiguous_bytes_input_adapter input_adapter(CharT b)
6949{
6950    if (b == nullptr)
6951    {
6952        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
6953    }
6954    auto length = std::strlen(reinterpret_cast<const char*>(b));
6955    const auto* ptr = reinterpret_cast<const char*>(b);
6956    return input_adapter(ptr, ptr + length); // cppcheck-suppress[nullPointerArithmeticRedundantCheck]
6957}
6958
6959template<typename T, std::size_t N>
6960auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
6961{
6962    return input_adapter(array, array + N);
6963}
6964
6965// This class only handles inputs of input_buffer_adapter type.
6966// It's required so that expressions like {ptr, len} can be implicitly cast
6967// to the correct adapter.
6968class span_input_adapter
6969{
6970  public:
6971    template < typename CharT,
6972               typename std::enable_if <
6973                   std::is_pointer<CharT>::value&&
6974                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
6975                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
6976                   int >::type = 0 >
6977    span_input_adapter(CharT b, std::size_t l)
6978        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
6979
6980    template<class IteratorType,
6981             typename std::enable_if<
6982                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
6983                 int>::type = 0>
6984    span_input_adapter(IteratorType first, IteratorType last)
6985        : ia(input_adapter(first, last)) {}
6986
6987    contiguous_bytes_input_adapter&& get()
6988    {
6989        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
6990    }
6991
6992  private:
6993    contiguous_bytes_input_adapter ia;
6994};
6995
6996}  // namespace detail
6997NLOHMANN_JSON_NAMESPACE_END
6998
6999// #include <nlohmann/detail/input/json_sax.hpp>
7000//     __ _____ _____ _____
7001//  __|  |   __|     |   | |  JSON for Modern C++
7002// |  |  |__   |  |  | | | |  version 3.12.0
7003// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
7004//
7005// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
7006// SPDX-License-Identifier: MIT
7007
7008
7009
7010#include <cstddef>
7011#include <string> // string
7012#include <type_traits> // enable_if_t
7013#include <utility> // move
7014#include <vector> // vector
7015
7016// #include <nlohmann/detail/exceptions.hpp>
7017
7018// #include <nlohmann/detail/input/lexer.hpp>
7019//     __ _____ _____ _____
7020//  __|  |   __|     |   | |  JSON for Modern C++
7021// |  |  |__   |  |  | | | |  version 3.12.0
7022// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
7023//
7024// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
7025// SPDX-License-Identifier: MIT
7026
7027
7028
7029#include <array> // array
7030#include <clocale> // localeconv
7031#include <cstddef> // size_t
7032#include <cstdio> // snprintf
7033#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
7034#include <initializer_list> // initializer_list
7035#include <string> // char_traits, string
7036#include <utility> // move
7037#include <vector> // vector
7038
7039// #include <nlohmann/detail/input/input_adapters.hpp>
7040
7041// #include <nlohmann/detail/input/position_t.hpp>
7042
7043// #include <nlohmann/detail/macro_scope.hpp>
7044
7045// #include <nlohmann/detail/meta/type_traits.hpp>
7046
7047
7048NLOHMANN_JSON_NAMESPACE_BEGIN
7049namespace detail
7050{
7051
7052///////////
7053// lexer //
7054///////////
7055
7056template<typename BasicJsonType>
7057class lexer_base
7058{
7059  public:
7060    /// token types for the parser
7061    enum class token_type
7062    {
7063        uninitialized,    ///< indicating the scanner is uninitialized
7064        literal_true,     ///< the `true` literal
7065        literal_false,    ///< the `false` literal
7066        literal_null,     ///< the `null` literal
7067        value_string,     ///< a string -- use get_string() for actual value
7068        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
7069        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
7070        value_float,      ///< an floating point number -- use get_number_float() for actual value
7071        begin_array,      ///< the character for array begin `[`
7072        begin_object,     ///< the character for object begin `{`
7073        end_array,        ///< the character for array end `]`
7074        end_object,       ///< the character for object end `}`
7075        name_separator,   ///< the name separator `:`
7076        value_separator,  ///< the value separator `,`
7077        parse_error,      ///< indicating a parse error
7078        end_of_input,     ///< indicating the end of the input buffer
7079        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
7080    };
7081
7082    /// return name of values of type token_type (only used for errors)
7083    JSON_HEDLEY_RETURNS_NON_NULL
7084    JSON_HEDLEY_CONST
7085    static const char* token_type_name(const token_type t) noexcept
7086    {
7087        switch (t)
7088        {
7089            case token_type::uninitialized:
7090                return "<uninitialized>";
7091            case token_type::literal_true:
7092                return "true literal";
7093            case token_type::literal_false:
7094                return "false literal";
7095            case token_type::literal_null:
7096                return "null literal";
7097            case token_type::value_string:
7098                return "string literal";
7099            case token_type::value_unsigned:
7100            case token_type::value_integer:
7101            case token_type::value_float:
7102                return "number literal";
7103            case token_type::begin_array:
7104                return "'['";
7105            case token_type::begin_object:
7106                return "'{'";
7107            case token_type::end_array:
7108                return "']'";
7109            case token_type::end_object:
7110                return "'}'";
7111            case token_type::name_separator:
7112                return "':'";
7113            case token_type::value_separator:
7114                return "','";
7115            case token_type::parse_error:
7116                return "<parse error>";
7117            case token_type::end_of_input:
7118                return "end of input";
7119            case token_type::literal_or_value:
7120                return "'[', '{', or a literal";
7121            // LCOV_EXCL_START
7122            default: // catch non-enum values
7123                return "unknown token";
7124                // LCOV_EXCL_STOP
7125        }
7126    }
7127};
7128/*!
7129@brief lexical analysis
7130
7131This class organizes the lexical analysis during JSON deserialization.
7132*/
7133template<typename BasicJsonType, typename InputAdapterType>
7134class lexer : public lexer_base<BasicJsonType>
7135{
7136    using number_integer_t = typename BasicJsonType::number_integer_t;
7137    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7138    using number_float_t = typename BasicJsonType::number_float_t;
7139    using string_t = typename BasicJsonType::string_t;
7140    using char_type = typename InputAdapterType::char_type;
7141    using char_int_type = typename char_traits<char_type>::int_type;
7142
7143  public:
7144    using token_type = typename lexer_base<BasicJsonType>::token_type;
7145
7146    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
7147        : ia(std::move(adapter))
7148        , ignore_comments(ignore_comments_)
7149        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
7150    {}
7151
7152    // delete because of pointer members
7153    lexer(const lexer&) = delete;
7154    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
7155    lexer& operator=(lexer&) = delete;
7156    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
7157    ~lexer() = default;
7158
7159  private:
7160    /////////////////////
7161    // locales
7162    /////////////////////
7163
7164    /// return the locale-dependent decimal point
7165    JSON_HEDLEY_PURE
7166    static char get_decimal_point() noexcept
7167    {
7168        const auto* loc = localeconv();
7169        JSON_ASSERT(loc != nullptr);
7170        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
7171    }
7172
7173    /////////////////////
7174    // scan functions
7175    /////////////////////
7176
7177    /*!
7178    @brief get codepoint from 4 hex characters following `\u`
7179
7180    For input "\u c1 c2 c3 c4" the codepoint is:
7181      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
7182    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
7183
7184    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
7185    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
7186    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
7187    between the ASCII value of the character and the desired integer value.
7188
7189    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
7190            non-hex character)
7191    */
7192    int get_codepoint()
7193    {
7194        // this function only makes sense after reading `\u`
7195        JSON_ASSERT(current == 'u');
7196        int codepoint = 0;
7197
7198        const auto factors = { 12u, 8u, 4u, 0u };
7199        for (const auto factor : factors)
7200        {
7201            get();
7202
7203            if (current >= '0' && current <= '9')
7204            {
7205                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
7206            }
7207            else if (current >= 'A' && current <= 'F')
7208            {
7209                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
7210            }
7211            else if (current >= 'a' && current <= 'f')
7212            {
7213                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
7214            }
7215            else
7216            {
7217                return -1;
7218            }
7219        }
7220
7221        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
7222        return codepoint;
7223    }
7224
7225    /*!
7226    @brief check if the next byte(s) are inside a given range
7227
7228    Adds the current byte and, for each passed range, reads a new byte and
7229    checks if it is inside the range. If a violation was detected, set up an
7230    error message and return false. Otherwise, return true.
7231
7232    @param[in] ranges  list of integers; interpreted as list of pairs of
7233                       inclusive lower and upper bound, respectively
7234
7235    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
7236         1, 2, or 3 pairs. This precondition is enforced by an assertion.
7237
7238    @return true if and only if no range violation was detected
7239    */
7240    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
7241    {
7242        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
7243        add(current);
7244
7245        for (auto range = ranges.begin(); range != ranges.end(); ++range)
7246        {
7247            get();
7248            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
7249            {
7250                add(current);
7251            }
7252            else
7253            {
7254                error_message = "invalid string: ill-formed UTF-8 byte";
7255                return false;
7256            }
7257        }
7258
7259        return true;
7260    }
7261
7262    /*!
7263    @brief scan a string literal
7264
7265    This function scans a string according to Sect. 7 of RFC 8259. While
7266    scanning, bytes are escaped and copied into buffer token_buffer. Then the
7267    function returns successfully, token_buffer is *not* null-terminated (as it
7268    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
7269    string.
7270
7271    @return token_type::value_string if string could be successfully scanned,
7272            token_type::parse_error otherwise
7273
7274    @note In case of errors, variable error_message contains a textual
7275          description.
7276    */
7277    token_type scan_string()
7278    {
7279        // reset token_buffer (ignore opening quote)
7280        reset();
7281
7282        // we entered the function by reading an open quote
7283        JSON_ASSERT(current == '\"');
7284
7285        while (true)
7286        {
7287            // get next character
7288            switch (get())
7289            {
7290                // end of file while parsing string
7291                case char_traits<char_type>::eof():
7292                {
7293                    error_message = "invalid string: missing closing quote";
7294                    return token_type::parse_error;
7295                }
7296
7297                // closing quote
7298                case '\"':
7299                {
7300                    return token_type::value_string;
7301                }
7302
7303                // escapes
7304                case '\\':
7305                {
7306                    switch (get())
7307                    {
7308                        // quotation mark
7309                        case '\"':
7310                            add('\"');
7311                            break;
7312                        // reverse solidus
7313                        case '\\':
7314                            add('\\');
7315                            break;
7316                        // solidus
7317                        case '/':
7318                            add('/');
7319                            break;
7320                        // backspace
7321                        case 'b':
7322                            add('\b');
7323                            break;
7324                        // form feed
7325                        case 'f':
7326                            add('\f');
7327                            break;
7328                        // line feed
7329                        case 'n':
7330                            add('\n');
7331                            break;
7332                        // carriage return
7333                        case 'r':
7334                            add('\r');
7335                            break;
7336                        // tab
7337                        case 't':
7338                            add('\t');
7339                            break;
7340
7341                        // unicode escapes
7342                        case 'u':
7343                        {
7344                            const int codepoint1 = get_codepoint();
7345                            int codepoint = codepoint1; // start with codepoint1
7346
7347                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
7348                            {
7349                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
7350                                return token_type::parse_error;
7351                            }
7352
7353                            // check if code point is a high surrogate
7354                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
7355                            {
7356                                // expect next \uxxxx entry
7357                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
7358                                {
7359                                    const int codepoint2 = get_codepoint();
7360
7361                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
7362                                    {
7363                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
7364                                        return token_type::parse_error;
7365                                    }
7366
7367                                    // check if codepoint2 is a low surrogate
7368                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
7369                                    {
7370                                        // overwrite codepoint
7371                                        codepoint = static_cast<int>(
7372                                                        // high surrogate occupies the most significant 22 bits
7373                                                        (static_cast<unsigned int>(codepoint1) << 10u)
7374                                                        // low surrogate occupies the least significant 15 bits
7375                                                        + static_cast<unsigned int>(codepoint2)
7376                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
7377                                                        // in the result, so we have to subtract with:
7378                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
7379                                                        - 0x35FDC00u);
7380                                    }
7381                                    else
7382                                    {
7383                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
7384                                        return token_type::parse_error;
7385                                    }
7386                                }
7387                                else
7388                                {
7389                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
7390                                    return token_type::parse_error;
7391                                }
7392                            }
7393                            else
7394                            {
7395                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
7396                                {
7397                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
7398                                    return token_type::parse_error;
7399                                }
7400                            }
7401
7402                            // result of the above calculation yields a proper codepoint
7403                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
7404
7405                            // translate codepoint into bytes
7406                            if (codepoint < 0x80)
7407                            {
7408                                // 1-byte characters: 0xxxxxxx (ASCII)
7409                                add(static_cast<char_int_type>(codepoint));
7410                            }
7411                            else if (codepoint <= 0x7FF)
7412                            {
7413                                // 2-byte characters: 110xxxxx 10xxxxxx
7414                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
7415                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7416                            }
7417                            else if (codepoint <= 0xFFFF)
7418                            {
7419                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
7420                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
7421                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7422                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7423                            }
7424                            else
7425                            {
7426                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
7427                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
7428                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
7429                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7430                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7431                            }
7432
7433                            break;
7434                        }
7435
7436                        // other characters after escape
7437                        default:
7438                            error_message = "invalid string: forbidden character after backslash";
7439                            return token_type::parse_error;
7440                    }
7441
7442                    break;
7443                }
7444
7445                // invalid control characters
7446                case 0x00:
7447                {
7448                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
7449                    return token_type::parse_error;
7450                }
7451
7452                case 0x01:
7453                {
7454                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
7455                    return token_type::parse_error;
7456                }
7457
7458                case 0x02:
7459                {
7460                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
7461                    return token_type::parse_error;
7462                }
7463
7464                case 0x03:
7465                {
7466                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
7467                    return token_type::parse_error;
7468                }
7469
7470                case 0x04:
7471                {
7472                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
7473                    return token_type::parse_error;
7474                }
7475
7476                case 0x05:
7477                {
7478                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
7479                    return token_type::parse_error;
7480                }
7481
7482                case 0x06:
7483                {
7484                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
7485                    return token_type::parse_error;
7486                }
7487
7488                case 0x07:
7489                {
7490                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
7491                    return token_type::parse_error;
7492                }
7493
7494                case 0x08:
7495                {
7496                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
7497                    return token_type::parse_error;
7498                }
7499
7500                case 0x09:
7501                {
7502                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
7503                    return token_type::parse_error;
7504                }
7505
7506                case 0x0A:
7507                {
7508                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
7509                    return token_type::parse_error;
7510                }
7511
7512                case 0x0B:
7513                {
7514                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
7515                    return token_type::parse_error;
7516                }
7517
7518                case 0x0C:
7519                {
7520                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
7521                    return token_type::parse_error;
7522                }
7523
7524                case 0x0D:
7525                {
7526                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
7527                    return token_type::parse_error;
7528                }
7529
7530                case 0x0E:
7531                {
7532                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
7533                    return token_type::parse_error;
7534                }
7535
7536                case 0x0F:
7537                {
7538                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
7539                    return token_type::parse_error;
7540                }
7541
7542                case 0x10:
7543                {
7544                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
7545                    return token_type::parse_error;
7546                }
7547
7548                case 0x11:
7549                {
7550                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
7551                    return token_type::parse_error;
7552                }
7553
7554                case 0x12:
7555                {
7556                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
7557                    return token_type::parse_error;
7558                }
7559
7560                case 0x13:
7561                {
7562                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
7563                    return token_type::parse_error;
7564                }
7565
7566                case 0x14:
7567                {
7568                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
7569                    return token_type::parse_error;
7570                }
7571
7572                case 0x15:
7573                {
7574                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7575                    return token_type::parse_error;
7576                }
7577
7578                case 0x16:
7579                {
7580                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7581                    return token_type::parse_error;
7582                }
7583
7584                case 0x17:
7585                {
7586                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7587                    return token_type::parse_error;
7588                }
7589
7590                case 0x18:
7591                {
7592                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7593                    return token_type::parse_error;
7594                }
7595
7596                case 0x19:
7597                {
7598                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7599                    return token_type::parse_error;
7600                }
7601
7602                case 0x1A:
7603                {
7604                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7605                    return token_type::parse_error;
7606                }
7607
7608                case 0x1B:
7609                {
7610                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7611                    return token_type::parse_error;
7612                }
7613
7614                case 0x1C:
7615                {
7616                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
7617                    return token_type::parse_error;
7618                }
7619
7620                case 0x1D:
7621                {
7622                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
7623                    return token_type::parse_error;
7624                }
7625
7626                case 0x1E:
7627                {
7628                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
7629                    return token_type::parse_error;
7630                }
7631
7632                case 0x1F:
7633                {
7634                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
7635                    return token_type::parse_error;
7636                }
7637
7638                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
7639                case 0x20:
7640                case 0x21:
7641                case 0x23:
7642                case 0x24:
7643                case 0x25:
7644                case 0x26:
7645                case 0x27:
7646                case 0x28:
7647                case 0x29:
7648                case 0x2A:
7649                case 0x2B:
7650                case 0x2C:
7651                case 0x2D:
7652                case 0x2E:
7653                case 0x2F:
7654                case 0x30:
7655                case 0x31:
7656                case 0x32:
7657                case 0x33:
7658                case 0x34:
7659                case 0x35:
7660                case 0x36:
7661                case 0x37:
7662                case 0x38:
7663                case 0x39:
7664                case 0x3A:
7665                case 0x3B:
7666                case 0x3C:
7667                case 0x3D:
7668                case 0x3E:
7669                case 0x3F:
7670                case 0x40:
7671                case 0x41:
7672                case 0x42:
7673                case 0x43:
7674                case 0x44:
7675                case 0x45:
7676                case 0x46:
7677                case 0x47:
7678                case 0x48:
7679                case 0x49:
7680                case 0x4A:
7681                case 0x4B:
7682                case 0x4C:
7683                case 0x4D:
7684                case 0x4E:
7685                case 0x4F:
7686                case 0x50:
7687                case 0x51:
7688                case 0x52:
7689                case 0x53:
7690                case 0x54:
7691                case 0x55:
7692                case 0x56:
7693                case 0x57:
7694                case 0x58:
7695                case 0x59:
7696                case 0x5A:
7697                case 0x5B:
7698                case 0x5D:
7699                case 0x5E:
7700                case 0x5F:
7701                case 0x60:
7702                case 0x61:
7703                case 0x62:
7704                case 0x63:
7705                case 0x64:
7706                case 0x65:
7707                case 0x66:
7708                case 0x67:
7709                case 0x68:
7710                case 0x69:
7711                case 0x6A:
7712                case 0x6B:
7713                case 0x6C:
7714                case 0x6D:
7715                case 0x6E:
7716                case 0x6F:
7717                case 0x70:
7718                case 0x71:
7719                case 0x72:
7720                case 0x73:
7721                case 0x74:
7722                case 0x75:
7723                case 0x76:
7724                case 0x77:
7725                case 0x78:
7726                case 0x79:
7727                case 0x7A:
7728                case 0x7B:
7729                case 0x7C:
7730                case 0x7D:
7731                case 0x7E:
7732                case 0x7F:
7733                {
7734                    add(current);
7735                    break;
7736                }
7737
7738                // U+0080..U+07FF: bytes C2..DF 80..BF
7739                case 0xC2:
7740                case 0xC3:
7741                case 0xC4:
7742                case 0xC5:
7743                case 0xC6:
7744                case 0xC7:
7745                case 0xC8:
7746                case 0xC9:
7747                case 0xCA:
7748                case 0xCB:
7749                case 0xCC:
7750                case 0xCD:
7751                case 0xCE:
7752                case 0xCF:
7753                case 0xD0:
7754                case 0xD1:
7755                case 0xD2:
7756                case 0xD3:
7757                case 0xD4:
7758                case 0xD5:
7759                case 0xD6:
7760                case 0xD7:
7761                case 0xD8:
7762                case 0xD9:
7763                case 0xDA:
7764                case 0xDB:
7765                case 0xDC:
7766                case 0xDD:
7767                case 0xDE:
7768                case 0xDF:
7769                {
7770                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
7771                    {
7772                        return token_type::parse_error;
7773                    }
7774                    break;
7775                }
7776
7777                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
7778                case 0xE0:
7779                {
7780                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7781                    {
7782                        return token_type::parse_error;
7783                    }
7784                    break;
7785                }
7786
7787                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
7788                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
7789                case 0xE1:
7790                case 0xE2:
7791                case 0xE3:
7792                case 0xE4:
7793                case 0xE5:
7794                case 0xE6:
7795                case 0xE7:
7796                case 0xE8:
7797                case 0xE9:
7798                case 0xEA:
7799                case 0xEB:
7800                case 0xEC:
7801                case 0xEE:
7802                case 0xEF:
7803                {
7804                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7805                    {
7806                        return token_type::parse_error;
7807                    }
7808                    break;
7809                }
7810
7811                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
7812                case 0xED:
7813                {
7814                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7815                    {
7816                        return token_type::parse_error;
7817                    }
7818                    break;
7819                }
7820
7821                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
7822                case 0xF0:
7823                {
7824                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7825                    {
7826                        return token_type::parse_error;
7827                    }
7828                    break;
7829                }
7830
7831                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
7832                case 0xF1:
7833                case 0xF2:
7834                case 0xF3:
7835                {
7836                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7837                    {
7838                        return token_type::parse_error;
7839                    }
7840                    break;
7841                }
7842
7843                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
7844                case 0xF4:
7845                {
7846                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7847                    {
7848                        return token_type::parse_error;
7849                    }
7850                    break;
7851                }
7852
7853                // remaining bytes (80..C1 and F5..FF) are ill-formed
7854                default:
7855                {
7856                    error_message = "invalid string: ill-formed UTF-8 byte";
7857                    return token_type::parse_error;
7858                }
7859            }
7860        }
7861    }
7862
7863    /*!
7864     * @brief scan a comment
7865     * @return whether comment could be scanned successfully
7866     */
7867    bool scan_comment()
7868    {
7869        switch (get())
7870        {
7871            // single-line comments skip input until a newline or EOF is read
7872            case '/':
7873            {
7874                while (true)
7875                {
7876                    switch (get())
7877                    {
7878                        case '\n':
7879                        case '\r':
7880                        case char_traits<char_type>::eof():
7881                        case '\0':
7882                            return true;
7883
7884                        default:
7885                            break;
7886                    }
7887                }
7888            }
7889
7890            // multi-line comments skip input until */ is read
7891            case '*':
7892            {
7893                while (true)
7894                {
7895                    switch (get())
7896                    {
7897                        case char_traits<char_type>::eof():
7898                        case '\0':
7899                        {
7900                            error_message = "invalid comment; missing closing '*/'";
7901                            return false;
7902                        }
7903
7904                        case '*':
7905                        {
7906                            switch (get())
7907                            {
7908                                case '/':
7909                                    return true;
7910
7911                                default:
7912                                {
7913                                    unget();
7914                                    continue;
7915                                }
7916                            }
7917                        }
7918
7919                        default:
7920                            continue;
7921                    }
7922                }
7923            }
7924
7925            // unexpected character after reading '/'
7926            default:
7927            {
7928                error_message = "invalid comment; expecting '/' or '*' after '/'";
7929                return false;
7930            }
7931        }
7932    }
7933
7934    JSON_HEDLEY_NON_NULL(2)
7935    static void strtof(float& f, const char* str, char** endptr) noexcept
7936    {
7937        f = std::strtof(str, endptr);
7938    }
7939
7940    JSON_HEDLEY_NON_NULL(2)
7941    static void strtof(double& f, const char* str, char** endptr) noexcept
7942    {
7943        f = std::strtod(str, endptr);
7944    }
7945
7946    JSON_HEDLEY_NON_NULL(2)
7947    static void strtof(long double& f, const char* str, char** endptr) noexcept
7948    {
7949        f = std::strtold(str, endptr);
7950    }
7951
7952    /*!
7953    @brief scan a number literal
7954
7955    This function scans a string according to Sect. 6 of RFC 8259.
7956
7957    The function is realized with a deterministic finite state machine derived
7958    from the grammar described in RFC 8259. Starting in state "init", the
7959    input is read and used to determined the next state. Only state "done"
7960    accepts the number. State "error" is a trap state to model errors. In the
7961    table below, "anything" means any character but the ones listed before.
7962
7963    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
7964    ---------|----------|----------|----------|---------|---------|----------|-----------
7965    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
7966    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
7967    zero     | done     | done     | exponent | done    | done    | decimal1 | done
7968    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
7969    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
7970    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
7971    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
7972    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
7973    any2     | any2     | any2     | done     | done    | done    | done     | done
7974
7975    The state machine is realized with one label per state (prefixed with
7976    "scan_number_") and `goto` statements between them. The state machine
7977    contains cycles, but any cycle can be left when EOF is read. Therefore,
7978    the function is guaranteed to terminate.
7979
7980    During scanning, the read bytes are stored in token_buffer. This string is
7981    then converted to a signed integer, an unsigned integer, or a
7982    floating-point number.
7983
7984    @return token_type::value_unsigned, token_type::value_integer, or
7985            token_type::value_float if number could be successfully scanned,
7986            token_type::parse_error otherwise
7987
7988    @note The scanner is independent of the current locale. Internally, the
7989          locale's decimal point is used instead of `.` to work with the
7990          locale-dependent converters.
7991    */
7992    token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
7993    {
7994        // reset token_buffer to store the number's bytes
7995        reset();
7996
7997        // the type of the parsed number; initially set to unsigned; will be
7998        // changed if minus sign, decimal point or exponent is read
7999        token_type number_type = token_type::value_unsigned;
8000
8001        // state (init): we just found out we need to scan a number
8002        switch (current)
8003        {
8004            case '-':
8005            {
8006                add(current);
8007                goto scan_number_minus;
8008            }
8009
8010            case '0':
8011            {
8012                add(current);
8013                goto scan_number_zero;
8014            }
8015
8016            case '1':
8017            case '2':
8018            case '3':
8019            case '4':
8020            case '5':
8021            case '6':
8022            case '7':
8023            case '8':
8024            case '9':
8025            {
8026                add(current);
8027                goto scan_number_any1;
8028            }
8029
8030            // all other characters are rejected outside scan_number()
8031            default:            // LCOV_EXCL_LINE
8032                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
8033        }
8034
8035scan_number_minus:
8036        // state: we just parsed a leading minus sign
8037        number_type = token_type::value_integer;
8038        switch (get())
8039        {
8040            case '0':
8041            {
8042                add(current);
8043                goto scan_number_zero;
8044            }
8045
8046            case '1':
8047            case '2':
8048            case '3':
8049            case '4':
8050            case '5':
8051            case '6':
8052            case '7':
8053            case '8':
8054            case '9':
8055            {
8056                add(current);
8057                goto scan_number_any1;
8058            }
8059
8060            default:
8061            {
8062                error_message = "invalid number; expected digit after '-'";
8063                return token_type::parse_error;
8064            }
8065        }
8066
8067scan_number_zero:
8068        // state: we just parse a zero (maybe with a leading minus sign)
8069        switch (get())
8070        {
8071            case '.':
8072            {
8073                add(decimal_point_char);
8074                decimal_point_position = token_buffer.size() - 1;
8075                goto scan_number_decimal1;
8076            }
8077
8078            case 'e':
8079            case 'E':
8080            {
8081                add(current);
8082                goto scan_number_exponent;
8083            }
8084
8085            default:
8086                goto scan_number_done;
8087        }
8088
8089scan_number_any1:
8090        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
8091        switch (get())
8092        {
8093            case '0':
8094            case '1':
8095            case '2':
8096            case '3':
8097            case '4':
8098            case '5':
8099            case '6':
8100            case '7':
8101            case '8':
8102            case '9':
8103            {
8104                add(current);
8105                goto scan_number_any1;
8106            }
8107
8108            case '.':
8109            {
8110                add(decimal_point_char);
8111                decimal_point_position = token_buffer.size() - 1;
8112                goto scan_number_decimal1;
8113            }
8114
8115            case 'e':
8116            case 'E':
8117            {
8118                add(current);
8119                goto scan_number_exponent;
8120            }
8121
8122            default:
8123                goto scan_number_done;
8124        }
8125
8126scan_number_decimal1:
8127        // state: we just parsed a decimal point
8128        number_type = token_type::value_float;
8129        switch (get())
8130        {
8131            case '0':
8132            case '1':
8133            case '2':
8134            case '3':
8135            case '4':
8136            case '5':
8137            case '6':
8138            case '7':
8139            case '8':
8140            case '9':
8141            {
8142                add(current);
8143                goto scan_number_decimal2;
8144            }
8145
8146            default:
8147            {
8148                error_message = "invalid number; expected digit after '.'";
8149                return token_type::parse_error;
8150            }
8151        }
8152
8153scan_number_decimal2:
8154        // we just parsed at least one number after a decimal point
8155        switch (get())
8156        {
8157            case '0':
8158            case '1':
8159            case '2':
8160            case '3':
8161            case '4':
8162            case '5':
8163            case '6':
8164            case '7':
8165            case '8':
8166            case '9':
8167            {
8168                add(current);
8169                goto scan_number_decimal2;
8170            }
8171
8172            case 'e':
8173            case 'E':
8174            {
8175                add(current);
8176                goto scan_number_exponent;
8177            }
8178
8179            default:
8180                goto scan_number_done;
8181        }
8182
8183scan_number_exponent:
8184        // we just parsed an exponent
8185        number_type = token_type::value_float;
8186        switch (get())
8187        {
8188            case '+':
8189            case '-':
8190            {
8191                add(current);
8192                goto scan_number_sign;
8193            }
8194
8195            case '0':
8196            case '1':
8197            case '2':
8198            case '3':
8199            case '4':
8200            case '5':
8201            case '6':
8202            case '7':
8203            case '8':
8204            case '9':
8205            {
8206                add(current);
8207                goto scan_number_any2;
8208            }
8209
8210            default:
8211            {
8212                error_message =
8213                    "invalid number; expected '+', '-', or digit after exponent";
8214                return token_type::parse_error;
8215            }
8216        }
8217
8218scan_number_sign:
8219        // we just parsed an exponent sign
8220        switch (get())
8221        {
8222            case '0':
8223            case '1':
8224            case '2':
8225            case '3':
8226            case '4':
8227            case '5':
8228            case '6':
8229            case '7':
8230            case '8':
8231            case '9':
8232            {
8233                add(current);
8234                goto scan_number_any2;
8235            }
8236
8237            default:
8238            {
8239                error_message = "invalid number; expected digit after exponent sign";
8240                return token_type::parse_error;
8241            }
8242        }
8243
8244scan_number_any2:
8245        // we just parsed a number after the exponent or exponent sign
8246        switch (get())
8247        {
8248            case '0':
8249            case '1':
8250            case '2':
8251            case '3':
8252            case '4':
8253            case '5':
8254            case '6':
8255            case '7':
8256            case '8':
8257            case '9':
8258            {
8259                add(current);
8260                goto scan_number_any2;
8261            }
8262
8263            default:
8264                goto scan_number_done;
8265        }
8266
8267scan_number_done:
8268        // unget the character after the number (we only read it to know that
8269        // we are done scanning a number)
8270        unget();
8271
8272        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8273        errno = 0;
8274
8275        // try to parse integers first and fall back to floats
8276        if (number_type == token_type::value_unsigned)
8277        {
8278            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
8279
8280            // we checked the number format before
8281            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
8282
8283            if (errno != ERANGE)
8284            {
8285                value_unsigned = static_cast<number_unsigned_t>(x);
8286                if (value_unsigned == x)
8287                {
8288                    return token_type::value_unsigned;
8289                }
8290            }
8291        }
8292        else if (number_type == token_type::value_integer)
8293        {
8294            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
8295
8296            // we checked the number format before
8297            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
8298
8299            if (errno != ERANGE)
8300            {
8301                value_integer = static_cast<number_integer_t>(x);
8302                if (value_integer == x)
8303                {
8304                    return token_type::value_integer;
8305                }
8306            }
8307        }
8308
8309        // this code is reached if we parse a floating-point number or if an
8310        // integer conversion above failed
8311        strtof(value_float, token_buffer.data(), &endptr);
8312
8313        // we checked the number format before
8314        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
8315
8316        return token_type::value_float;
8317    }
8318
8319    /*!
8320    @param[in] literal_text  the literal text to expect
8321    @param[in] length        the length of the passed literal text
8322    @param[in] return_type   the token type to return on success
8323    */
8324    JSON_HEDLEY_NON_NULL(2)
8325    token_type scan_literal(const char_type* literal_text, const std::size_t length,
8326                            token_type return_type)
8327    {
8328        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
8329        for (std::size_t i = 1; i < length; ++i)
8330        {
8331            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
8332            {
8333                error_message = "invalid literal";
8334                return token_type::parse_error;
8335            }
8336        }
8337        return return_type;
8338    }
8339
8340    /////////////////////
8341    // input management
8342    /////////////////////
8343
8344    /// reset token_buffer; current character is beginning of token
8345    void reset() noexcept
8346    {
8347        token_buffer.clear();
8348        token_string.clear();
8349        decimal_point_position = std::string::npos;
8350        token_string.push_back(char_traits<char_type>::to_char_type(current));
8351    }
8352
8353    /*
8354    @brief get next character from the input
8355
8356    This function provides the interface to the used input adapter. It does
8357    not throw in case the input reached EOF, but returns a
8358    `char_traits<char>::eof()` in that case.  Stores the scanned characters
8359    for use in error messages.
8360
8361    @return character read from the input
8362    */
8363    char_int_type get()
8364    {
8365        ++position.chars_read_total;
8366        ++position.chars_read_current_line;
8367
8368        if (next_unget)
8369        {
8370            // just reset the next_unget variable and work with current
8371            next_unget = false;
8372        }
8373        else
8374        {
8375            current = ia.get_character();
8376        }
8377
8378        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
8379        {
8380            token_string.push_back(char_traits<char_type>::to_char_type(current));
8381        }
8382
8383        if (current == '\n')
8384        {
8385            ++position.lines_read;
8386            position.chars_read_current_line = 0;
8387        }
8388
8389        return current;
8390    }
8391
8392    /*!
8393    @brief unget current character (read it again on next get)
8394
8395    We implement unget by setting variable next_unget to true. The input is not
8396    changed - we just simulate ungetting by modifying chars_read_total,
8397    chars_read_current_line, and token_string. The next call to get() will
8398    behave as if the unget character is read again.
8399    */
8400    void unget()
8401    {
8402        next_unget = true;
8403
8404        --position.chars_read_total;
8405
8406        // in case we "unget" a newline, we have to also decrement the lines_read
8407        if (position.chars_read_current_line == 0)
8408        {
8409            if (position.lines_read > 0)
8410            {
8411                --position.lines_read;
8412            }
8413        }
8414        else
8415        {
8416            --position.chars_read_current_line;
8417        }
8418
8419        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
8420        {
8421            JSON_ASSERT(!token_string.empty());
8422            token_string.pop_back();
8423        }
8424    }
8425
8426    /// add a character to token_buffer
8427    void add(char_int_type c)
8428    {
8429        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
8430    }
8431
8432  public:
8433    /////////////////////
8434    // value getters
8435    /////////////////////
8436
8437    /// return integer value
8438    constexpr number_integer_t get_number_integer() const noexcept
8439    {
8440        return value_integer;
8441    }
8442
8443    /// return unsigned integer value
8444    constexpr number_unsigned_t get_number_unsigned() const noexcept
8445    {
8446        return value_unsigned;
8447    }
8448
8449    /// return floating-point value
8450    constexpr number_float_t get_number_float() const noexcept
8451    {
8452        return value_float;
8453    }
8454
8455    /// return current string value (implicitly resets the token; useful only once)
8456    string_t& get_string()
8457    {
8458        // translate decimal points from locale back to '.' (#4084)
8459        if (decimal_point_char != '.' && decimal_point_position != std::string::npos)
8460        {
8461            token_buffer[decimal_point_position] = '.';
8462        }
8463        return token_buffer;
8464    }
8465
8466    /////////////////////
8467    // diagnostics
8468    /////////////////////
8469
8470    /// return position of last read token
8471    constexpr position_t get_position() const noexcept
8472    {
8473        return position;
8474    }
8475
8476    /// return the last read token (for errors only).  Will never contain EOF
8477    /// (an arbitrary value that is not a valid char value, often -1), because
8478    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
8479    std::string get_token_string() const
8480    {
8481        // escape control characters
8482        std::string result;
8483        for (const auto c : token_string)
8484        {
8485            if (static_cast<unsigned char>(c) <= '\x1F')
8486            {
8487                // escape control characters
8488                std::array<char, 9> cs{{}};
8489                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8490                result += cs.data();
8491            }
8492            else
8493            {
8494                // add character as is
8495                result.push_back(static_cast<std::string::value_type>(c));
8496            }
8497        }
8498
8499        return result;
8500    }
8501
8502    /// return syntax error message
8503    JSON_HEDLEY_RETURNS_NON_NULL
8504    constexpr const char* get_error_message() const noexcept
8505    {
8506        return error_message;
8507    }
8508
8509    /////////////////////
8510    // actual scanner
8511    /////////////////////
8512
8513    /*!
8514    @brief skip the UTF-8 byte order mark
8515    @return true iff there is no BOM or the correct BOM has been skipped
8516    */
8517    bool skip_bom()
8518    {
8519        if (get() == 0xEF)
8520        {
8521            // check if we completely parse the BOM
8522            return get() == 0xBB && get() == 0xBF;
8523        }
8524
8525        // the first character is not the beginning of the BOM; unget it to
8526        // process is later
8527        unget();
8528        return true;
8529    }
8530
8531    void skip_whitespace()
8532    {
8533        do
8534        {
8535            get();
8536        }
8537        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
8538    }
8539
8540    token_type scan()
8541    {
8542        // initially, skip the BOM
8543        if (position.chars_read_total == 0 && !skip_bom())
8544        {
8545            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
8546            return token_type::parse_error;
8547        }
8548
8549        // read next character and ignore whitespace
8550        skip_whitespace();
8551
8552        // ignore comments
8553        while (ignore_comments && current == '/')
8554        {
8555            if (!scan_comment())
8556            {
8557                return token_type::parse_error;
8558            }
8559
8560            // skip following whitespace
8561            skip_whitespace();
8562        }
8563
8564        switch (current)
8565        {
8566            // structural characters
8567            case '[':
8568                return token_type::begin_array;
8569            case ']':
8570                return token_type::end_array;
8571            case '{':
8572                return token_type::begin_object;
8573            case '}':
8574                return token_type::end_object;
8575            case ':':
8576                return token_type::name_separator;
8577            case ',':
8578                return token_type::value_separator;
8579
8580            // literals
8581            case 't':
8582            {
8583                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')}};
8584                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
8585            }
8586            case 'f':
8587            {
8588                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')}};
8589                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
8590            }
8591            case 'n':
8592            {
8593                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')}};
8594                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
8595            }
8596
8597            // string
8598            case '\"':
8599                return scan_string();
8600
8601            // number
8602            case '-':
8603            case '0':
8604            case '1':
8605            case '2':
8606            case '3':
8607            case '4':
8608            case '5':
8609            case '6':
8610            case '7':
8611            case '8':
8612            case '9':
8613                return scan_number();
8614
8615            // end of input (the null byte is needed when parsing from
8616            // string literals)
8617            case '\0':
8618            case char_traits<char_type>::eof():
8619                return token_type::end_of_input;
8620
8621            // error
8622            default:
8623                error_message = "invalid literal";
8624                return token_type::parse_error;
8625        }
8626    }
8627
8628  private:
8629    /// input adapter
8630    InputAdapterType ia;
8631
8632    /// whether comments should be ignored (true) or signaled as errors (false)
8633    const bool ignore_comments = false;
8634
8635    /// the current character
8636    char_int_type current = char_traits<char_type>::eof();
8637
8638    /// whether the next get() call should just return current
8639    bool next_unget = false;
8640
8641    /// the start position of the current token
8642    position_t position {};
8643
8644    /// raw input token string (for error messages)
8645    std::vector<char_type> token_string {};
8646
8647    /// buffer for variable-length tokens (numbers, strings)
8648    string_t token_buffer {};
8649
8650    /// a description of occurred lexer errors
8651    const char* error_message = "";
8652
8653    // number values
8654    number_integer_t value_integer = 0;
8655    number_unsigned_t value_unsigned = 0;
8656    number_float_t value_float = 0;
8657
8658    /// the decimal point
8659    const char_int_type decimal_point_char = '.';
8660    /// the position of the decimal point in the input
8661    std::size_t decimal_point_position = std::string::npos;
8662};
8663
8664}  // namespace detail
8665NLOHMANN_JSON_NAMESPACE_END
8666
8667// #include <nlohmann/detail/macro_scope.hpp>
8668
8669// #include <nlohmann/detail/string_concat.hpp>
8670
8671NLOHMANN_JSON_NAMESPACE_BEGIN
8672
8673/*!
8674@brief SAX interface
8675
8676This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
8677Each function is called in different situations while the input is parsed. The
8678boolean return value informs the parser whether to continue processing the
8679input.
8680*/
8681template<typename BasicJsonType>
8682struct json_sax
8683{
8684    using number_integer_t = typename BasicJsonType::number_integer_t;
8685    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8686    using number_float_t = typename BasicJsonType::number_float_t;
8687    using string_t = typename BasicJsonType::string_t;
8688    using binary_t = typename BasicJsonType::binary_t;
8689
8690    /*!
8691    @brief a null value was read
8692    @return whether parsing should proceed
8693    */
8694    virtual bool null() = 0;
8695
8696    /*!
8697    @brief a boolean value was read
8698    @param[in] val  boolean value
8699    @return whether parsing should proceed
8700    */
8701    virtual bool boolean(bool val) = 0;
8702
8703    /*!
8704    @brief an integer number was read
8705    @param[in] val  integer value
8706    @return whether parsing should proceed
8707    */
8708    virtual bool number_integer(number_integer_t val) = 0;
8709
8710    /*!
8711    @brief an unsigned integer number was read
8712    @param[in] val  unsigned integer value
8713    @return whether parsing should proceed
8714    */
8715    virtual bool number_unsigned(number_unsigned_t val) = 0;
8716
8717    /*!
8718    @brief a floating-point number was read
8719    @param[in] val  floating-point value
8720    @param[in] s    raw token value
8721    @return whether parsing should proceed
8722    */
8723    virtual bool number_float(number_float_t val, const string_t& s) = 0;
8724
8725    /*!
8726    @brief a string value was read
8727    @param[in] val  string value
8728    @return whether parsing should proceed
8729    @note It is safe to move the passed string value.
8730    */
8731    virtual bool string(string_t& val) = 0;
8732
8733    /*!
8734    @brief a binary value was read
8735    @param[in] val  binary value
8736    @return whether parsing should proceed
8737    @note It is safe to move the passed binary value.
8738    */
8739    virtual bool binary(binary_t& val) = 0;
8740
8741    /*!
8742    @brief the beginning of an object was read
8743    @param[in] elements  number of object elements or -1 if unknown
8744    @return whether parsing should proceed
8745    @note binary formats may report the number of elements
8746    */
8747    virtual bool start_object(std::size_t elements) = 0;
8748
8749    /*!
8750    @brief an object key was read
8751    @param[in] val  object key
8752    @return whether parsing should proceed
8753    @note It is safe to move the passed string.
8754    */
8755    virtual bool key(string_t& val) = 0;
8756
8757    /*!
8758    @brief the end of an object was read
8759    @return whether parsing should proceed
8760    */
8761    virtual bool end_object() = 0;
8762
8763    /*!
8764    @brief the beginning of an array was read
8765    @param[in] elements  number of array elements or -1 if unknown
8766    @return whether parsing should proceed
8767    @note binary formats may report the number of elements
8768    */
8769    virtual bool start_array(std::size_t elements) = 0;
8770
8771    /*!
8772    @brief the end of an array was read
8773    @return whether parsing should proceed
8774    */
8775    virtual bool end_array() = 0;
8776
8777    /*!
8778    @brief a parse error occurred
8779    @param[in] position    the position in the input where the error occurs
8780    @param[in] last_token  the last read token
8781    @param[in] ex          an exception object describing the error
8782    @return whether parsing should proceed (must return false)
8783    */
8784    virtual bool parse_error(std::size_t position,
8785                             const std::string& last_token,
8786                             const detail::exception& ex) = 0;
8787
8788    json_sax() = default;
8789    json_sax(const json_sax&) = default;
8790    json_sax(json_sax&&) noexcept = default;
8791    json_sax& operator=(const json_sax&) = default;
8792    json_sax& operator=(json_sax&&) noexcept = default;
8793    virtual ~json_sax() = default;
8794};
8795
8796namespace detail
8797{
8798constexpr std::size_t unknown_size()
8799{
8800    return (std::numeric_limits<std::size_t>::max)();
8801}
8802
8803/*!
8804@brief SAX implementation to create a JSON value from SAX events
8805
8806This class implements the @ref json_sax interface and processes the SAX events
8807to create a JSON value which makes it basically a DOM parser. The structure or
8808hierarchy of the JSON value is managed by the stack `ref_stack` which contains
8809a pointer to the respective array or object for each recursion depth.
8810
8811After successful parsing, the value that is passed by reference to the
8812constructor contains the parsed value.
8813
8814@tparam BasicJsonType  the JSON type
8815*/
8816template<typename BasicJsonType, typename InputAdapterType>
8817class json_sax_dom_parser
8818{
8819  public:
8820    using number_integer_t = typename BasicJsonType::number_integer_t;
8821    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8822    using number_float_t = typename BasicJsonType::number_float_t;
8823    using string_t = typename BasicJsonType::string_t;
8824    using binary_t = typename BasicJsonType::binary_t;
8825    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
8826
8827    /*!
8828    @param[in,out] r  reference to a JSON value that is manipulated while
8829                       parsing
8830    @param[in] allow_exceptions_  whether parse errors yield exceptions
8831    */
8832    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true, lexer_t* lexer_ = nullptr)
8833        : root(r), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)
8834    {}
8835
8836    // make class move-only
8837    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
8838    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
8839    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
8840    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
8841    ~json_sax_dom_parser() = default;
8842
8843    bool null()
8844    {
8845        handle_value(nullptr);
8846        return true;
8847    }
8848
8849    bool boolean(bool val)
8850    {
8851        handle_value(val);
8852        return true;
8853    }
8854
8855    bool number_integer(number_integer_t val)
8856    {
8857        handle_value(val);
8858        return true;
8859    }
8860
8861    bool number_unsigned(number_unsigned_t val)
8862    {
8863        handle_value(val);
8864        return true;
8865    }
8866
8867    bool number_float(number_float_t val, const string_t& /*unused*/)
8868    {
8869        handle_value(val);
8870        return true;
8871    }
8872
8873    bool string(string_t& val)
8874    {
8875        handle_value(val);
8876        return true;
8877    }
8878
8879    bool binary(binary_t& val)
8880    {
8881        handle_value(std::move(val));
8882        return true;
8883    }
8884
8885    bool start_object(std::size_t len)
8886    {
8887        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
8888
8889#if JSON_DIAGNOSTIC_POSITIONS
8890        // Manually set the start position of the object here.
8891        // Ensure this is after the call to handle_value to ensure correct start position.
8892        if (m_lexer_ref)
8893        {
8894            // Lexer has read the first character of the object, so
8895            // subtract 1 from the position to get the correct start position.
8896            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
8897        }
8898#endif
8899
8900        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
8901        {
8902            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
8903        }
8904
8905        return true;
8906    }
8907
8908    bool key(string_t& val)
8909    {
8910        JSON_ASSERT(!ref_stack.empty());
8911        JSON_ASSERT(ref_stack.back()->is_object());
8912
8913        // add null at given key and store the reference for later
8914        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
8915        return true;
8916    }
8917
8918    bool end_object()
8919    {
8920        JSON_ASSERT(!ref_stack.empty());
8921        JSON_ASSERT(ref_stack.back()->is_object());
8922
8923#if JSON_DIAGNOSTIC_POSITIONS
8924        if (m_lexer_ref)
8925        {
8926            // Lexer's position is past the closing brace, so set that as the end position.
8927            ref_stack.back()->end_position = m_lexer_ref->get_position();
8928        }
8929#endif
8930
8931        ref_stack.back()->set_parents();
8932        ref_stack.pop_back();
8933        return true;
8934    }
8935
8936    bool start_array(std::size_t len)
8937    {
8938        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
8939
8940#if JSON_DIAGNOSTIC_POSITIONS
8941        // Manually set the start position of the array here.
8942        // Ensure this is after the call to handle_value to ensure correct start position.
8943        if (m_lexer_ref)
8944        {
8945            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
8946        }
8947#endif
8948
8949        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
8950        {
8951            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
8952        }
8953
8954        return true;
8955    }
8956
8957    bool end_array()
8958    {
8959        JSON_ASSERT(!ref_stack.empty());
8960        JSON_ASSERT(ref_stack.back()->is_array());
8961
8962#if JSON_DIAGNOSTIC_POSITIONS
8963        if (m_lexer_ref)
8964        {
8965            // Lexer's position is past the closing bracket, so set that as the end position.
8966            ref_stack.back()->end_position = m_lexer_ref->get_position();
8967        }
8968#endif
8969
8970        ref_stack.back()->set_parents();
8971        ref_stack.pop_back();
8972        return true;
8973    }
8974
8975    template<class Exception>
8976    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
8977                     const Exception& ex)
8978    {
8979        errored = true;
8980        static_cast<void>(ex);
8981        if (allow_exceptions)
8982        {
8983            JSON_THROW(ex);
8984        }
8985        return false;
8986    }
8987
8988    constexpr bool is_errored() const
8989    {
8990        return errored;
8991    }
8992
8993  private:
8994
8995#if JSON_DIAGNOSTIC_POSITIONS
8996    void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
8997    {
8998        if (m_lexer_ref)
8999        {
9000            // Lexer has read past the current field value, so set the end position to the current position.
9001            // The start position will be set below based on the length of the string representation
9002            // of the value.
9003            v.end_position = m_lexer_ref->get_position();
9004
9005            switch (v.type())
9006            {
9007                case value_t::boolean:
9008                {
9009                    // 4 and 5 are the string length of "true" and "false"
9010                    v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);
9011                    break;
9012                }
9013
9014                case value_t::null:
9015                {
9016                    // 4 is the string length of "null"
9017                    v.start_position = v.end_position - 4;
9018                    break;
9019                }
9020
9021                case value_t::string:
9022                {
9023                    // include the length of the quotes, which is 2
9024                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
9025                    break;
9026                }
9027
9028                // As we handle the start and end positions for values created during parsing,
9029                // we do not expect the following value type to be called. Regardless, set the positions
9030                // in case this is created manually or through a different constructor. Exclude from lcov
9031                // since the exact condition of this switch is esoteric.
9032                // LCOV_EXCL_START
9033                case value_t::discarded:
9034                {
9035                    v.end_position = std::string::npos;
9036                    v.start_position = v.end_position;
9037                    break;
9038                }
9039                // LCOV_EXCL_STOP
9040                case value_t::binary:
9041                case value_t::number_integer:
9042                case value_t::number_unsigned:
9043                case value_t::number_float:
9044                {
9045                    v.start_position = v.end_position - m_lexer_ref->get_string().size();
9046                    break;
9047                }
9048                case value_t::object:
9049                case value_t::array:
9050                {
9051                    // object and array are handled in start_object() and start_array() handlers
9052                    // skip setting the values here.
9053                    break;
9054                }
9055                default: // LCOV_EXCL_LINE
9056                    // Handle all possible types discretely, default handler should never be reached.
9057                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert,-warnings-as-errors) LCOV_EXCL_LINE
9058            }
9059        }
9060    }
9061#endif
9062
9063    /*!
9064    @invariant If the ref stack is empty, then the passed value will be the new
9065               root.
9066    @invariant If the ref stack contains a value, then it is an array or an
9067               object to which we can add elements
9068    */
9069    template<typename Value>
9070    JSON_HEDLEY_RETURNS_NON_NULL
9071    BasicJsonType* handle_value(Value&& v)
9072    {
9073        if (ref_stack.empty())
9074        {
9075            root = BasicJsonType(std::forward<Value>(v));
9076
9077#if JSON_DIAGNOSTIC_POSITIONS
9078            handle_diagnostic_positions_for_json_value(root);
9079#endif
9080
9081            return &root;
9082        }
9083
9084        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
9085
9086        if (ref_stack.back()->is_array())
9087        {
9088            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
9089
9090#if JSON_DIAGNOSTIC_POSITIONS
9091            handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back());
9092#endif
9093
9094            return &(ref_stack.back()->m_data.m_value.array->back());
9095        }
9096
9097        JSON_ASSERT(ref_stack.back()->is_object());
9098        JSON_ASSERT(object_element);
9099        *object_element = BasicJsonType(std::forward<Value>(v));
9100
9101#if JSON_DIAGNOSTIC_POSITIONS
9102        handle_diagnostic_positions_for_json_value(*object_element);
9103#endif
9104
9105        return object_element;
9106    }
9107
9108    /// the parsed JSON value
9109    BasicJsonType& root;
9110    /// stack to model hierarchy of values
9111    std::vector<BasicJsonType*> ref_stack {};
9112    /// helper to hold the reference for the next object element
9113    BasicJsonType* object_element = nullptr;
9114    /// whether a syntax error occurred
9115    bool errored = false;
9116    /// whether to throw exceptions in case of errors
9117    const bool allow_exceptions = true;
9118    /// the lexer reference to obtain the current position
9119    lexer_t* m_lexer_ref = nullptr;
9120};
9121
9122template<typename BasicJsonType, typename InputAdapterType>
9123class json_sax_dom_callback_parser
9124{
9125  public:
9126    using number_integer_t = typename BasicJsonType::number_integer_t;
9127    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9128    using number_float_t = typename BasicJsonType::number_float_t;
9129    using string_t = typename BasicJsonType::string_t;
9130    using binary_t = typename BasicJsonType::binary_t;
9131    using parser_callback_t = typename BasicJsonType::parser_callback_t;
9132    using parse_event_t = typename BasicJsonType::parse_event_t;
9133    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
9134
9135    json_sax_dom_callback_parser(BasicJsonType& r,
9136                                 parser_callback_t cb,
9137                                 const bool allow_exceptions_ = true,
9138                                 lexer_t* lexer_ = nullptr)
9139        : root(r), callback(std::move(cb)), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)
9140    {
9141        keep_stack.push_back(true);
9142    }
9143
9144    // make class move-only
9145    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
9146    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
9147    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
9148    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
9149    ~json_sax_dom_callback_parser() = default;
9150
9151    bool null()
9152    {
9153        handle_value(nullptr);
9154        return true;
9155    }
9156
9157    bool boolean(bool val)
9158    {
9159        handle_value(val);
9160        return true;
9161    }
9162
9163    bool number_integer(number_integer_t val)
9164    {
9165        handle_value(val);
9166        return true;
9167    }
9168
9169    bool number_unsigned(number_unsigned_t val)
9170    {
9171        handle_value(val);
9172        return true;
9173    }
9174
9175    bool number_float(number_float_t val, const string_t& /*unused*/)
9176    {
9177        handle_value(val);
9178        return true;
9179    }
9180
9181    bool string(string_t& val)
9182    {
9183        handle_value(val);
9184        return true;
9185    }
9186
9187    bool binary(binary_t& val)
9188    {
9189        handle_value(std::move(val));
9190        return true;
9191    }
9192
9193    bool start_object(std::size_t len)
9194    {
9195        // check callback for object start
9196        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
9197        keep_stack.push_back(keep);
9198
9199        auto val = handle_value(BasicJsonType::value_t::object, true);
9200        ref_stack.push_back(val.second);
9201
9202        if (ref_stack.back())
9203        {
9204
9205#if JSON_DIAGNOSTIC_POSITIONS
9206            // Manually set the start position of the object here.
9207            // Ensure this is after the call to handle_value to ensure correct start position.
9208            if (m_lexer_ref)
9209            {
9210                // Lexer has read the first character of the object, so
9211                // subtract 1 from the position to get the correct start position.
9212                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
9213            }
9214#endif
9215
9216            // check object limit
9217            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
9218            {
9219                JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
9220            }
9221        }
9222        return true;
9223    }
9224
9225    bool key(string_t& val)
9226    {
9227        BasicJsonType k = BasicJsonType(val);
9228
9229        // check callback for key
9230        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
9231        key_keep_stack.push_back(keep);
9232
9233        // add discarded value at given key and store the reference for later
9234        if (keep && ref_stack.back())
9235        {
9236            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
9237        }
9238
9239        return true;
9240    }
9241
9242    bool end_object()
9243    {
9244        if (ref_stack.back())
9245        {
9246            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
9247            {
9248                // discard object
9249                *ref_stack.back() = discarded;
9250
9251#if JSON_DIAGNOSTIC_POSITIONS
9252                // Set start/end positions for discarded object.
9253                handle_diagnostic_positions_for_json_value(*ref_stack.back());
9254#endif
9255            }
9256            else
9257            {
9258
9259#if JSON_DIAGNOSTIC_POSITIONS
9260                if (m_lexer_ref)
9261                {
9262                    // Lexer's position is past the closing brace, so set that as the end position.
9263                    ref_stack.back()->end_position = m_lexer_ref->get_position();
9264                }
9265#endif
9266
9267                ref_stack.back()->set_parents();
9268            }
9269        }
9270
9271        JSON_ASSERT(!ref_stack.empty());
9272        JSON_ASSERT(!keep_stack.empty());
9273        ref_stack.pop_back();
9274        keep_stack.pop_back();
9275
9276        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
9277        {
9278            // remove discarded value
9279            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
9280            {
9281                if (it->is_discarded())
9282                {
9283                    ref_stack.back()->erase(it);
9284                    break;
9285                }
9286            }
9287        }
9288
9289        return true;
9290    }
9291
9292    bool start_array(std::size_t len)
9293    {
9294        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
9295        keep_stack.push_back(keep);
9296
9297        auto val = handle_value(BasicJsonType::value_t::array, true);
9298        ref_stack.push_back(val.second);
9299
9300        if (ref_stack.back())
9301        {
9302
9303#if JSON_DIAGNOSTIC_POSITIONS
9304            // Manually set the start position of the array here.
9305            // Ensure this is after the call to handle_value to ensure correct start position.
9306            if (m_lexer_ref)
9307            {
9308                // Lexer has read the first character of the array, so
9309                // subtract 1 from the position to get the correct start position.
9310                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
9311            }
9312#endif
9313
9314            // check array limit
9315            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
9316            {
9317                JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
9318            }
9319        }
9320
9321        return true;
9322    }
9323
9324    bool end_array()
9325    {
9326        bool keep = true;
9327
9328        if (ref_stack.back())
9329        {
9330            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
9331            if (keep)
9332            {
9333
9334#if JSON_DIAGNOSTIC_POSITIONS
9335                if (m_lexer_ref)
9336                {
9337                    // Lexer's position is past the closing bracket, so set that as the end position.
9338                    ref_stack.back()->end_position = m_lexer_ref->get_position();
9339                }
9340#endif
9341
9342                ref_stack.back()->set_parents();
9343            }
9344            else
9345            {
9346                // discard array
9347                *ref_stack.back() = discarded;
9348
9349#if JSON_DIAGNOSTIC_POSITIONS
9350                // Set start/end positions for discarded array.
9351                handle_diagnostic_positions_for_json_value(*ref_stack.back());
9352#endif
9353            }
9354        }
9355
9356        JSON_ASSERT(!ref_stack.empty());
9357        JSON_ASSERT(!keep_stack.empty());
9358        ref_stack.pop_back();
9359        keep_stack.pop_back();
9360
9361        // remove discarded value
9362        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
9363        {
9364            ref_stack.back()->m_data.m_value.array->pop_back();
9365        }
9366
9367        return true;
9368    }
9369
9370    template<class Exception>
9371    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
9372                     const Exception& ex)
9373    {
9374        errored = true;
9375        static_cast<void>(ex);
9376        if (allow_exceptions)
9377        {
9378            JSON_THROW(ex);
9379        }
9380        return false;
9381    }
9382
9383    constexpr bool is_errored() const
9384    {
9385        return errored;
9386    }
9387
9388  private:
9389
9390#if JSON_DIAGNOSTIC_POSITIONS
9391    void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
9392    {
9393        if (m_lexer_ref)
9394        {
9395            // Lexer has read past the current field value, so set the end position to the current position.
9396            // The start position will be set below based on the length of the string representation
9397            // of the value.
9398            v.end_position = m_lexer_ref->get_position();
9399
9400            switch (v.type())
9401            {
9402                case value_t::boolean:
9403                {
9404                    // 4 and 5 are the string length of "true" and "false"
9405                    v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);
9406                    break;
9407                }
9408
9409                case value_t::null:
9410                {
9411                    // 4 is the string length of "null"
9412                    v.start_position = v.end_position - 4;
9413                    break;
9414                }
9415
9416                case value_t::string:
9417                {
9418                    // include the length of the quotes, which is 2
9419                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
9420                    break;
9421                }
9422
9423                case value_t::discarded:
9424                {
9425                    v.end_position = std::string::npos;
9426                    v.start_position = v.end_position;
9427                    break;
9428                }
9429
9430                case value_t::binary:
9431                case value_t::number_integer:
9432                case value_t::number_unsigned:
9433                case value_t::number_float:
9434                {
9435                    v.start_position = v.end_position - m_lexer_ref->get_string().size();
9436                    break;
9437                }
9438
9439                case value_t::object:
9440                case value_t::array:
9441                {
9442                    // object and array are handled in start_object() and start_array() handlers
9443                    // skip setting the values here.
9444                    break;
9445                }
9446                default: // LCOV_EXCL_LINE
9447                    // Handle all possible types discretely, default handler should never be reached.
9448                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert,-warnings-as-errors) LCOV_EXCL_LINE
9449            }
9450        }
9451    }
9452#endif
9453
9454    /*!
9455    @param[in] v  value to add to the JSON value we build during parsing
9456    @param[in] skip_callback  whether we should skip calling the callback
9457               function; this is required after start_array() and
9458               start_object() SAX events, because otherwise we would call the
9459               callback function with an empty array or object, respectively.
9460
9461    @invariant If the ref stack is empty, then the passed value will be the new
9462               root.
9463    @invariant If the ref stack contains a value, then it is an array or an
9464               object to which we can add elements
9465
9466    @return pair of boolean (whether value should be kept) and pointer (to the
9467            passed value in the ref_stack hierarchy; nullptr if not kept)
9468    */
9469    template<typename Value>
9470    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
9471    {
9472        JSON_ASSERT(!keep_stack.empty());
9473
9474        // do not handle this value if we know it would be added to a discarded
9475        // container
9476        if (!keep_stack.back())
9477        {
9478            return {false, nullptr};
9479        }
9480
9481        // create value
9482        auto value = BasicJsonType(std::forward<Value>(v));
9483
9484#if JSON_DIAGNOSTIC_POSITIONS
9485        handle_diagnostic_positions_for_json_value(value);
9486#endif
9487
9488        // check callback
9489        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
9490
9491        // do not handle this value if we just learnt it shall be discarded
9492        if (!keep)
9493        {
9494            return {false, nullptr};
9495        }
9496
9497        if (ref_stack.empty())
9498        {
9499            root = std::move(value);
9500            return {true, & root};
9501        }
9502
9503        // skip this value if we already decided to skip the parent
9504        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
9505        if (!ref_stack.back())
9506        {
9507            return {false, nullptr};
9508        }
9509
9510        // we now only expect arrays and objects
9511        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
9512
9513        // array
9514        if (ref_stack.back()->is_array())
9515        {
9516            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
9517            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
9518        }
9519
9520        // object
9521        JSON_ASSERT(ref_stack.back()->is_object());
9522        // check if we should store an element for the current key
9523        JSON_ASSERT(!key_keep_stack.empty());
9524        const bool store_element = key_keep_stack.back();
9525        key_keep_stack.pop_back();
9526
9527        if (!store_element)
9528        {
9529            return {false, nullptr};
9530        }
9531
9532        JSON_ASSERT(object_element);
9533        *object_element = std::move(value);
9534        return {true, object_element};
9535    }
9536
9537    /// the parsed JSON value
9538    BasicJsonType& root;
9539    /// stack to model hierarchy of values
9540    std::vector<BasicJsonType*> ref_stack {};
9541    /// stack to manage which values to keep
9542    std::vector<bool> keep_stack {}; // NOLINT(readability-redundant-member-init)
9543    /// stack to manage which object keys to keep
9544    std::vector<bool> key_keep_stack {}; // NOLINT(readability-redundant-member-init)
9545    /// helper to hold the reference for the next object element
9546    BasicJsonType* object_element = nullptr;
9547    /// whether a syntax error occurred
9548    bool errored = false;
9549    /// callback function
9550    const parser_callback_t callback = nullptr;
9551    /// whether to throw exceptions in case of errors
9552    const bool allow_exceptions = true;
9553    /// a discarded value for the callback
9554    BasicJsonType discarded = BasicJsonType::value_t::discarded;
9555    /// the lexer reference to obtain the current position
9556    lexer_t* m_lexer_ref = nullptr;
9557};
9558
9559template<typename BasicJsonType>
9560class json_sax_acceptor
9561{
9562  public:
9563    using number_integer_t = typename BasicJsonType::number_integer_t;
9564    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9565    using number_float_t = typename BasicJsonType::number_float_t;
9566    using string_t = typename BasicJsonType::string_t;
9567    using binary_t = typename BasicJsonType::binary_t;
9568
9569    bool null()
9570    {
9571        return true;
9572    }
9573
9574    bool boolean(bool /*unused*/)
9575    {
9576        return true;
9577    }
9578
9579    bool number_integer(number_integer_t /*unused*/)
9580    {
9581        return true;
9582    }
9583
9584    bool number_unsigned(number_unsigned_t /*unused*/)
9585    {
9586        return true;
9587    }
9588
9589    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
9590    {
9591        return true;
9592    }
9593
9594    bool string(string_t& /*unused*/)
9595    {
9596        return true;
9597    }
9598
9599    bool binary(binary_t& /*unused*/)
9600    {
9601        return true;
9602    }
9603
9604    bool start_object(std::size_t /*unused*/ = detail::unknown_size())
9605    {
9606        return true;
9607    }
9608
9609    bool key(string_t& /*unused*/)
9610    {
9611        return true;
9612    }
9613
9614    bool end_object()
9615    {
9616        return true;
9617    }
9618
9619    bool start_array(std::size_t /*unused*/ = detail::unknown_size())
9620    {
9621        return true;
9622    }
9623
9624    bool end_array()
9625    {
9626        return true;
9627    }
9628
9629    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
9630    {
9631        return false;
9632    }
9633};
9634
9635}  // namespace detail
9636NLOHMANN_JSON_NAMESPACE_END
9637
9638// #include <nlohmann/detail/input/lexer.hpp>
9639
9640// #include <nlohmann/detail/macro_scope.hpp>
9641
9642// #include <nlohmann/detail/meta/is_sax.hpp>
9643//     __ _____ _____ _____
9644//  __|  |   __|     |   | |  JSON for Modern C++
9645// |  |  |__   |  |  | | | |  version 3.12.0
9646// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
9647//
9648// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
9649// SPDX-License-Identifier: MIT
9650
9651
9652
9653#include <cstdint> // size_t
9654#include <utility> // declval
9655#include <string> // string
9656
9657// #include <nlohmann/detail/abi_macros.hpp>
9658
9659// #include <nlohmann/detail/meta/detected.hpp>
9660
9661// #include <nlohmann/detail/meta/type_traits.hpp>
9662
9663
9664NLOHMANN_JSON_NAMESPACE_BEGIN
9665namespace detail
9666{
9667
9668template<typename T>
9669using null_function_t = decltype(std::declval<T&>().null());
9670
9671template<typename T>
9672using boolean_function_t =
9673    decltype(std::declval<T&>().boolean(std::declval<bool>()));
9674
9675template<typename T, typename Integer>
9676using number_integer_function_t =
9677    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
9678
9679template<typename T, typename Unsigned>
9680using number_unsigned_function_t =
9681    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
9682
9683template<typename T, typename Float, typename String>
9684using number_float_function_t = decltype(std::declval<T&>().number_float(
9685                                    std::declval<Float>(), std::declval<const String&>()));
9686
9687template<typename T, typename String>
9688using string_function_t =
9689    decltype(std::declval<T&>().string(std::declval<String&>()));
9690
9691template<typename T, typename Binary>
9692using binary_function_t =
9693    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
9694
9695template<typename T>
9696using start_object_function_t =
9697    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
9698
9699template<typename T, typename String>
9700using key_function_t =
9701    decltype(std::declval<T&>().key(std::declval<String&>()));
9702
9703template<typename T>
9704using end_object_function_t = decltype(std::declval<T&>().end_object());
9705
9706template<typename T>
9707using start_array_function_t =
9708    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
9709
9710template<typename T>
9711using end_array_function_t = decltype(std::declval<T&>().end_array());
9712
9713template<typename T, typename Exception>
9714using parse_error_function_t = decltype(std::declval<T&>().parse_error(
9715        std::declval<std::size_t>(), std::declval<const std::string&>(),
9716        std::declval<const Exception&>()));
9717
9718template<typename SAX, typename BasicJsonType>
9719struct is_sax
9720{
9721  private:
9722    static_assert(is_basic_json<BasicJsonType>::value,
9723                  "BasicJsonType must be of type basic_json<...>");
9724
9725    using number_integer_t = typename BasicJsonType::number_integer_t;
9726    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9727    using number_float_t = typename BasicJsonType::number_float_t;
9728    using string_t = typename BasicJsonType::string_t;
9729    using binary_t = typename BasicJsonType::binary_t;
9730    using exception_t = typename BasicJsonType::exception;
9731
9732  public:
9733    static constexpr bool value =
9734        is_detected_exact<bool, null_function_t, SAX>::value &&
9735        is_detected_exact<bool, boolean_function_t, SAX>::value &&
9736        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
9737        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
9738        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
9739        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
9740        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
9741        is_detected_exact<bool, start_object_function_t, SAX>::value &&
9742        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
9743        is_detected_exact<bool, end_object_function_t, SAX>::value &&
9744        is_detected_exact<bool, start_array_function_t, SAX>::value &&
9745        is_detected_exact<bool, end_array_function_t, SAX>::value &&
9746        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
9747};
9748
9749template<typename SAX, typename BasicJsonType>
9750struct is_sax_static_asserts
9751{
9752  private:
9753    static_assert(is_basic_json<BasicJsonType>::value,
9754                  "BasicJsonType must be of type basic_json<...>");
9755
9756    using number_integer_t = typename BasicJsonType::number_integer_t;
9757    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9758    using number_float_t = typename BasicJsonType::number_float_t;
9759    using string_t = typename BasicJsonType::string_t;
9760    using binary_t = typename BasicJsonType::binary_t;
9761    using exception_t = typename BasicJsonType::exception;
9762
9763  public:
9764    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
9765                  "Missing/invalid function: bool null()");
9766    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
9767                  "Missing/invalid function: bool boolean(bool)");
9768    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
9769                  "Missing/invalid function: bool boolean(bool)");
9770    static_assert(
9771        is_detected_exact<bool, number_integer_function_t, SAX,
9772        number_integer_t>::value,
9773        "Missing/invalid function: bool number_integer(number_integer_t)");
9774    static_assert(
9775        is_detected_exact<bool, number_unsigned_function_t, SAX,
9776        number_unsigned_t>::value,
9777        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
9778    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
9779                  number_float_t, string_t>::value,
9780                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
9781    static_assert(
9782        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
9783        "Missing/invalid function: bool string(string_t&)");
9784    static_assert(
9785        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
9786        "Missing/invalid function: bool binary(binary_t&)");
9787    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
9788                  "Missing/invalid function: bool start_object(std::size_t)");
9789    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
9790                  "Missing/invalid function: bool key(string_t&)");
9791    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
9792                  "Missing/invalid function: bool end_object()");
9793    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
9794                  "Missing/invalid function: bool start_array(std::size_t)");
9795    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
9796                  "Missing/invalid function: bool end_array()");
9797    static_assert(
9798        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
9799        "Missing/invalid function: bool parse_error(std::size_t, const "
9800        "std::string&, const exception&)");
9801};
9802
9803}  // namespace detail
9804NLOHMANN_JSON_NAMESPACE_END
9805
9806// #include <nlohmann/detail/meta/type_traits.hpp>
9807
9808// #include <nlohmann/detail/string_concat.hpp>
9809
9810// #include <nlohmann/detail/value_t.hpp>
9811
9812
9813NLOHMANN_JSON_NAMESPACE_BEGIN
9814namespace detail
9815{
9816
9817/// how to treat CBOR tags
9818enum class cbor_tag_handler_t
9819{
9820    error,   ///< throw a parse_error exception in case of a tag
9821    ignore,  ///< ignore tags
9822    store    ///< store tags as binary type
9823};
9824
9825/*!
9826@brief determine system byte order
9827
9828@return true if and only if system's byte order is little endian
9829
9830@note from https://stackoverflow.com/a/1001328/266378
9831*/
9832static inline bool little_endianness(int num = 1) noexcept
9833{
9834    return *reinterpret_cast<char*>(&num) == 1;
9835}
9836
9837///////////////////
9838// binary reader //
9839///////////////////
9840
9841/*!
9842@brief deserialization of CBOR, MessagePack, and UBJSON values
9843*/
9844template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType, InputAdapterType>>
9845class binary_reader
9846{
9847    using number_integer_t = typename BasicJsonType::number_integer_t;
9848    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
9849    using number_float_t = typename BasicJsonType::number_float_t;
9850    using string_t = typename BasicJsonType::string_t;
9851    using binary_t = typename BasicJsonType::binary_t;
9852    using json_sax_t = SAX;
9853    using char_type = typename InputAdapterType::char_type;
9854    using char_int_type = typename char_traits<char_type>::int_type;
9855
9856  public:
9857    /*!
9858    @brief create a binary reader
9859
9860    @param[in] adapter  input adapter to read from
9861    */
9862    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
9863    {
9864        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
9865    }
9866
9867    // make class move-only
9868    binary_reader(const binary_reader&) = delete;
9869    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
9870    binary_reader& operator=(const binary_reader&) = delete;
9871    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
9872    ~binary_reader() = default;
9873
9874    /*!
9875    @param[in] format  the binary format to parse
9876    @param[in] sax_    a SAX event processor
9877    @param[in] strict  whether to expect the input to be consumed completed
9878    @param[in] tag_handler  how to treat CBOR tags
9879
9880    @return whether parsing was successful
9881    */
9882    JSON_HEDLEY_NON_NULL(3)
9883    bool sax_parse(const input_format_t format,
9884                   json_sax_t* sax_,
9885                   const bool strict = true,
9886                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
9887    {
9888        sax = sax_;
9889        bool result = false;
9890
9891        switch (format)
9892        {
9893            case input_format_t::bson:
9894                result = parse_bson_internal();
9895                break;
9896
9897            case input_format_t::cbor:
9898                result = parse_cbor_internal(true, tag_handler);
9899                break;
9900
9901            case input_format_t::msgpack:
9902                result = parse_msgpack_internal();
9903                break;
9904
9905            case input_format_t::ubjson:
9906            case input_format_t::bjdata:
9907                result = parse_ubjson_internal();
9908                break;
9909
9910            case input_format_t::json: // LCOV_EXCL_LINE
9911            default:            // LCOV_EXCL_LINE
9912                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
9913        }
9914
9915        // strict mode: next byte must be EOF
9916        if (result && strict)
9917        {
9918            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
9919            {
9920                get_ignore_noop();
9921            }
9922            else
9923            {
9924                get();
9925            }
9926
9927            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
9928            {
9929                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
9930                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
9931            }
9932        }
9933
9934        return result;
9935    }
9936
9937  private:
9938    //////////
9939    // BSON //
9940    //////////
9941
9942    /*!
9943    @brief Reads in a BSON-object and passes it to the SAX-parser.
9944    @return whether a valid BSON-value was passed to the SAX parser
9945    */
9946    bool parse_bson_internal()
9947    {
9948        std::int32_t document_size{};
9949        get_number<std::int32_t, true>(input_format_t::bson, document_size);
9950
9951        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
9952        {
9953            return false;
9954        }
9955
9956        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
9957        {
9958            return false;
9959        }
9960
9961        return sax->end_object();
9962    }
9963
9964    /*!
9965    @brief Parses a C-style string from the BSON input.
9966    @param[in,out] result  A reference to the string variable where the read
9967                            string is to be stored.
9968    @return `true` if the \x00-byte indicating the end of the string was
9969             encountered before the EOF; false` indicates an unexpected EOF.
9970    */
9971    bool get_bson_cstr(string_t& result)
9972    {
9973        auto out = std::back_inserter(result);
9974        while (true)
9975        {
9976            get();
9977            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
9978            {
9979                return false;
9980            }
9981            if (current == 0x00)
9982            {
9983                return true;
9984            }
9985            *out++ = static_cast<typename string_t::value_type>(current);
9986        }
9987    }
9988
9989    /*!
9990    @brief Parses a zero-terminated string of length @a len from the BSON
9991           input.
9992    @param[in] len  The length (including the zero-byte at the end) of the
9993                    string to be read.
9994    @param[in,out] result  A reference to the string variable where the read
9995                            string is to be stored.
9996    @tparam NumberType The type of the length @a len
9997    @pre len >= 1
9998    @return `true` if the string was successfully parsed
9999    */
10000    template<typename NumberType>
10001    bool get_bson_string(const NumberType len, string_t& result)
10002    {
10003        if (JSON_HEDLEY_UNLIKELY(len < 1))
10004        {
10005            auto last_token = get_token_string();
10006            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
10007                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
10008        }
10009
10010        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
10011    }
10012
10013    /*!
10014    @brief Parses a byte array input of length @a len from the BSON input.
10015    @param[in] len  The length of the byte array to be read.
10016    @param[in,out] result  A reference to the binary variable where the read
10017                            array is to be stored.
10018    @tparam NumberType The type of the length @a len
10019    @pre len >= 0
10020    @return `true` if the byte array was successfully parsed
10021    */
10022    template<typename NumberType>
10023    bool get_bson_binary(const NumberType len, binary_t& result)
10024    {
10025        if (JSON_HEDLEY_UNLIKELY(len < 0))
10026        {
10027            auto last_token = get_token_string();
10028            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
10029                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
10030        }
10031
10032        // All BSON binary values have a subtype
10033        std::uint8_t subtype{};
10034        get_number<std::uint8_t>(input_format_t::bson, subtype);
10035        result.set_subtype(subtype);
10036
10037        return get_binary(input_format_t::bson, len, result);
10038    }
10039
10040    /*!
10041    @brief Read a BSON document element of the given @a element_type.
10042    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
10043    @param[in] element_type_parse_position The position in the input stream,
10044               where the `element_type` was read.
10045    @warning Not all BSON element types are supported yet. An unsupported
10046             @a element_type will give rise to a parse_error.114:
10047             Unsupported BSON record type 0x...
10048    @return whether a valid BSON-object/array was passed to the SAX parser
10049    */
10050    bool parse_bson_element_internal(const char_int_type element_type,
10051                                     const std::size_t element_type_parse_position)
10052    {
10053        switch (element_type)
10054        {
10055            case 0x01: // double
10056            {
10057                double number{};
10058                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
10059            }
10060
10061            case 0x02: // string
10062            {
10063                std::int32_t len{};
10064                string_t value;
10065                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
10066            }
10067
10068            case 0x03: // object
10069            {
10070                return parse_bson_internal();
10071            }
10072
10073            case 0x04: // array
10074            {
10075                return parse_bson_array();
10076            }
10077
10078            case 0x05: // binary
10079            {
10080                std::int32_t len{};
10081                binary_t value;
10082                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
10083            }
10084
10085            case 0x08: // boolean
10086            {
10087                return sax->boolean(get() != 0);
10088            }
10089
10090            case 0x0A: // null
10091            {
10092                return sax->null();
10093            }
10094
10095            case 0x10: // int32
10096            {
10097                std::int32_t value{};
10098                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
10099            }
10100
10101            case 0x12: // int64
10102            {
10103                std::int64_t value{};
10104                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
10105            }
10106
10107            case 0x11: // uint64
10108            {
10109                std::uint64_t value{};
10110                return get_number<std::uint64_t, true>(input_format_t::bson, value) && sax->number_unsigned(value);
10111            }
10112
10113            default: // anything else not supported (yet)
10114            {
10115                std::array<char, 3> cr{{}};
10116                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
10117                const std::string cr_str{cr.data()};
10118                return sax->parse_error(element_type_parse_position, cr_str,
10119                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
10120            }
10121        }
10122    }
10123
10124    /*!
10125    @brief Read a BSON element list (as specified in the BSON-spec)
10126
10127    The same binary layout is used for objects and arrays, hence it must be
10128    indicated with the argument @a is_array which one is expected
10129    (true --> array, false --> object).
10130
10131    @param[in] is_array Determines if the element list being read is to be
10132                        treated as an object (@a is_array == false), or as an
10133                        array (@a is_array == true).
10134    @return whether a valid BSON-object/array was passed to the SAX parser
10135    */
10136    bool parse_bson_element_list(const bool is_array)
10137    {
10138        string_t key;
10139
10140        while (auto element_type = get())
10141        {
10142            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
10143            {
10144                return false;
10145            }
10146
10147            const std::size_t element_type_parse_position = chars_read;
10148            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
10149            {
10150                return false;
10151            }
10152
10153            if (!is_array && !sax->key(key))
10154            {
10155                return false;
10156            }
10157
10158            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
10159            {
10160                return false;
10161            }
10162
10163            // get_bson_cstr only appends
10164            key.clear();
10165        }
10166
10167        return true;
10168    }
10169
10170    /*!
10171    @brief Reads an array from the BSON input and passes it to the SAX-parser.
10172    @return whether a valid BSON-array was passed to the SAX parser
10173    */
10174    bool parse_bson_array()
10175    {
10176        std::int32_t document_size{};
10177        get_number<std::int32_t, true>(input_format_t::bson, document_size);
10178
10179        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
10180        {
10181            return false;
10182        }
10183
10184        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
10185        {
10186            return false;
10187        }
10188
10189        return sax->end_array();
10190    }
10191
10192    //////////
10193    // CBOR //
10194    //////////
10195
10196    /*!
10197    @param[in] get_char  whether a new character should be retrieved from the
10198                         input (true) or whether the last read character should
10199                         be considered instead (false)
10200    @param[in] tag_handler how CBOR tags should be treated
10201
10202    @return whether a valid CBOR value was passed to the SAX parser
10203    */
10204    bool parse_cbor_internal(const bool get_char,
10205                             const cbor_tag_handler_t tag_handler)
10206    {
10207        switch (get_char ? get() : current)
10208        {
10209            // EOF
10210            case char_traits<char_type>::eof():
10211                return unexpect_eof(input_format_t::cbor, "value");
10212
10213            // Integer 0x00..0x17 (0..23)
10214            case 0x00:
10215            case 0x01:
10216            case 0x02:
10217            case 0x03:
10218            case 0x04:
10219            case 0x05:
10220            case 0x06:
10221            case 0x07:
10222            case 0x08:
10223            case 0x09:
10224            case 0x0A:
10225            case 0x0B:
10226            case 0x0C:
10227            case 0x0D:
10228            case 0x0E:
10229            case 0x0F:
10230            case 0x10:
10231            case 0x11:
10232            case 0x12:
10233            case 0x13:
10234            case 0x14:
10235            case 0x15:
10236            case 0x16:
10237            case 0x17:
10238                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
10239
10240            case 0x18: // Unsigned integer (one-byte uint8_t follows)
10241            {
10242                std::uint8_t number{};
10243                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
10244            }
10245
10246            case 0x19: // Unsigned integer (two-byte uint16_t follows)
10247            {
10248                std::uint16_t number{};
10249                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
10250            }
10251
10252            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
10253            {
10254                std::uint32_t number{};
10255                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
10256            }
10257
10258            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
10259            {
10260                std::uint64_t number{};
10261                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
10262            }
10263
10264            // Negative integer -1-0x00..-1-0x17 (-1..-24)
10265            case 0x20:
10266            case 0x21:
10267            case 0x22:
10268            case 0x23:
10269            case 0x24:
10270            case 0x25:
10271            case 0x26:
10272            case 0x27:
10273            case 0x28:
10274            case 0x29:
10275            case 0x2A:
10276            case 0x2B:
10277            case 0x2C:
10278            case 0x2D:
10279            case 0x2E:
10280            case 0x2F:
10281            case 0x30:
10282            case 0x31:
10283            case 0x32:
10284            case 0x33:
10285            case 0x34:
10286            case 0x35:
10287            case 0x36:
10288            case 0x37:
10289                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
10290
10291            case 0x38: // Negative integer (one-byte uint8_t follows)
10292            {
10293                std::uint8_t number{};
10294                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
10295            }
10296
10297            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
10298            {
10299                std::uint16_t number{};
10300                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
10301            }
10302
10303            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
10304            {
10305                std::uint32_t number{};
10306                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
10307            }
10308
10309            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
10310            {
10311                std::uint64_t number{};
10312                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
10313                        - static_cast<number_integer_t>(number));
10314            }
10315
10316            // Binary data (0x00..0x17 bytes follow)
10317            case 0x40:
10318            case 0x41:
10319            case 0x42:
10320            case 0x43:
10321            case 0x44:
10322            case 0x45:
10323            case 0x46:
10324            case 0x47:
10325            case 0x48:
10326            case 0x49:
10327            case 0x4A:
10328            case 0x4B:
10329            case 0x4C:
10330            case 0x4D:
10331            case 0x4E:
10332            case 0x4F:
10333            case 0x50:
10334            case 0x51:
10335            case 0x52:
10336            case 0x53:
10337            case 0x54:
10338            case 0x55:
10339            case 0x56:
10340            case 0x57:
10341            case 0x58: // Binary data (one-byte uint8_t for n follows)
10342            case 0x59: // Binary data (two-byte uint16_t for n follow)
10343            case 0x5A: // Binary data (four-byte uint32_t for n follow)
10344            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
10345            case 0x5F: // Binary data (indefinite length)
10346            {
10347                binary_t b;
10348                return get_cbor_binary(b) && sax->binary(b);
10349            }
10350
10351            // UTF-8 string (0x00..0x17 bytes follow)
10352            case 0x60:
10353            case 0x61:
10354            case 0x62:
10355            case 0x63:
10356            case 0x64:
10357            case 0x65:
10358            case 0x66:
10359            case 0x67:
10360            case 0x68:
10361            case 0x69:
10362            case 0x6A:
10363            case 0x6B:
10364            case 0x6C:
10365            case 0x6D:
10366            case 0x6E:
10367            case 0x6F:
10368            case 0x70:
10369            case 0x71:
10370            case 0x72:
10371            case 0x73:
10372            case 0x74:
10373            case 0x75:
10374            case 0x76:
10375            case 0x77:
10376            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
10377            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
10378            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
10379            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
10380            case 0x7F: // UTF-8 string (indefinite length)
10381            {
10382                string_t s;
10383                return get_cbor_string(s) && sax->string(s);
10384            }
10385
10386            // array (0x00..0x17 data items follow)
10387            case 0x80:
10388            case 0x81:
10389            case 0x82:
10390            case 0x83:
10391            case 0x84:
10392            case 0x85:
10393            case 0x86:
10394            case 0x87:
10395            case 0x88:
10396            case 0x89:
10397            case 0x8A:
10398            case 0x8B:
10399            case 0x8C:
10400            case 0x8D:
10401            case 0x8E:
10402            case 0x8F:
10403            case 0x90:
10404            case 0x91:
10405            case 0x92:
10406            case 0x93:
10407            case 0x94:
10408            case 0x95:
10409            case 0x96:
10410            case 0x97:
10411                return get_cbor_array(
10412                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
10413
10414            case 0x98: // array (one-byte uint8_t for n follows)
10415            {
10416                std::uint8_t len{};
10417                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
10418            }
10419
10420            case 0x99: // array (two-byte uint16_t for n follow)
10421            {
10422                std::uint16_t len{};
10423                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
10424            }
10425
10426            case 0x9A: // array (four-byte uint32_t for n follow)
10427            {
10428                std::uint32_t len{};
10429                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
10430            }
10431
10432            case 0x9B: // array (eight-byte uint64_t for n follow)
10433            {
10434                std::uint64_t len{};
10435                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
10436            }
10437
10438            case 0x9F: // array (indefinite length)
10439                return get_cbor_array(detail::unknown_size(), tag_handler);
10440
10441            // map (0x00..0x17 pairs of data items follow)
10442            case 0xA0:
10443            case 0xA1:
10444            case 0xA2:
10445            case 0xA3:
10446            case 0xA4:
10447            case 0xA5:
10448            case 0xA6:
10449            case 0xA7:
10450            case 0xA8:
10451            case 0xA9:
10452            case 0xAA:
10453            case 0xAB:
10454            case 0xAC:
10455            case 0xAD:
10456            case 0xAE:
10457            case 0xAF:
10458            case 0xB0:
10459            case 0xB1:
10460            case 0xB2:
10461            case 0xB3:
10462            case 0xB4:
10463            case 0xB5:
10464            case 0xB6:
10465            case 0xB7:
10466                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
10467
10468            case 0xB8: // map (one-byte uint8_t for n follows)
10469            {
10470                std::uint8_t len{};
10471                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
10472            }
10473
10474            case 0xB9: // map (two-byte uint16_t for n follow)
10475            {
10476                std::uint16_t len{};
10477                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
10478            }
10479
10480            case 0xBA: // map (four-byte uint32_t for n follow)
10481            {
10482                std::uint32_t len{};
10483                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
10484            }
10485
10486            case 0xBB: // map (eight-byte uint64_t for n follow)
10487            {
10488                std::uint64_t len{};
10489                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
10490            }
10491
10492            case 0xBF: // map (indefinite length)
10493                return get_cbor_object(detail::unknown_size(), tag_handler);
10494
10495            case 0xC6: // tagged item
10496            case 0xC7:
10497            case 0xC8:
10498            case 0xC9:
10499            case 0xCA:
10500            case 0xCB:
10501            case 0xCC:
10502            case 0xCD:
10503            case 0xCE:
10504            case 0xCF:
10505            case 0xD0:
10506            case 0xD1:
10507            case 0xD2:
10508            case 0xD3:
10509            case 0xD4:
10510            case 0xD8: // tagged item (1 bytes follow)
10511            case 0xD9: // tagged item (2 bytes follow)
10512            case 0xDA: // tagged item (4 bytes follow)
10513            case 0xDB: // tagged item (8 bytes follow)
10514            {
10515                switch (tag_handler)
10516                {
10517                    case cbor_tag_handler_t::error:
10518                    {
10519                        auto last_token = get_token_string();
10520                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
10521                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
10522                    }
10523
10524                    case cbor_tag_handler_t::ignore:
10525                    {
10526                        // ignore binary subtype
10527                        switch (current)
10528                        {
10529                            case 0xD8:
10530                            {
10531                                std::uint8_t subtype_to_ignore{};
10532                                get_number(input_format_t::cbor, subtype_to_ignore);
10533                                break;
10534                            }
10535                            case 0xD9:
10536                            {
10537                                std::uint16_t subtype_to_ignore{};
10538                                get_number(input_format_t::cbor, subtype_to_ignore);
10539                                break;
10540                            }
10541                            case 0xDA:
10542                            {
10543                                std::uint32_t subtype_to_ignore{};
10544                                get_number(input_format_t::cbor, subtype_to_ignore);
10545                                break;
10546                            }
10547                            case 0xDB:
10548                            {
10549                                std::uint64_t subtype_to_ignore{};
10550                                get_number(input_format_t::cbor, subtype_to_ignore);
10551                                break;
10552                            }
10553                            default:
10554                                break;
10555                        }
10556                        return parse_cbor_internal(true, tag_handler);
10557                    }
10558
10559                    case cbor_tag_handler_t::store:
10560                    {
10561                        binary_t b;
10562                        // use binary subtype and store in binary container
10563                        switch (current)
10564                        {
10565                            case 0xD8:
10566                            {
10567                                std::uint8_t subtype{};
10568                                get_number(input_format_t::cbor, subtype);
10569                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
10570                                break;
10571                            }
10572                            case 0xD9:
10573                            {
10574                                std::uint16_t subtype{};
10575                                get_number(input_format_t::cbor, subtype);
10576                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
10577                                break;
10578                            }
10579                            case 0xDA:
10580                            {
10581                                std::uint32_t subtype{};
10582                                get_number(input_format_t::cbor, subtype);
10583                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
10584                                break;
10585                            }
10586                            case 0xDB:
10587                            {
10588                                std::uint64_t subtype{};
10589                                get_number(input_format_t::cbor, subtype);
10590                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
10591                                break;
10592                            }
10593                            default:
10594                                return parse_cbor_internal(true, tag_handler);
10595                        }
10596                        get();
10597                        return get_cbor_binary(b) && sax->binary(b);
10598                    }
10599
10600                    default:                 // LCOV_EXCL_LINE
10601                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
10602                        return false;        // LCOV_EXCL_LINE
10603                }
10604            }
10605
10606            case 0xF4: // false
10607                return sax->boolean(false);
10608
10609            case 0xF5: // true
10610                return sax->boolean(true);
10611
10612            case 0xF6: // null
10613                return sax->null();
10614
10615            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
10616            {
10617                const auto byte1_raw = get();
10618                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
10619                {
10620                    return false;
10621                }
10622                const auto byte2_raw = get();
10623                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
10624                {
10625                    return false;
10626                }
10627
10628                const auto byte1 = static_cast<unsigned char>(byte1_raw);
10629                const auto byte2 = static_cast<unsigned char>(byte2_raw);
10630
10631                // code from RFC 7049, Appendix D, Figure 3:
10632                // As half-precision floating-point numbers were only added
10633                // to IEEE 754 in 2008, today's programming platforms often
10634                // still only have limited support for them. It is very
10635                // easy to include at least decoding support for them even
10636                // without such support. An example of a small decoder for
10637                // half-precision floating-point numbers in the C language
10638                // is shown in Fig. 3.
10639                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
10640                const double val = [&half]
10641                {
10642                    const int exp = (half >> 10u) & 0x1Fu;
10643                    const unsigned int mant = half & 0x3FFu;
10644                    JSON_ASSERT(0 <= exp&& exp <= 32);
10645                    JSON_ASSERT(mant <= 1024);
10646                    switch (exp)
10647                    {
10648                        case 0:
10649                            return std::ldexp(mant, -24);
10650                        case 31:
10651                            return (mant == 0)
10652                            ? std::numeric_limits<double>::infinity()
10653                            : std::numeric_limits<double>::quiet_NaN();
10654                        default:
10655                            return std::ldexp(mant + 1024, exp - 25);
10656                    }
10657                }();
10658                return sax->number_float((half & 0x8000u) != 0
10659                                         ? static_cast<number_float_t>(-val)
10660                                         : static_cast<number_float_t>(val), "");
10661            }
10662
10663            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
10664            {
10665                float number{};
10666                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
10667            }
10668
10669            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
10670            {
10671                double number{};
10672                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
10673            }
10674
10675            default: // anything else (0xFF is handled inside the other types)
10676            {
10677                auto last_token = get_token_string();
10678                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
10679                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
10680            }
10681        }
10682    }
10683
10684    /*!
10685    @brief reads a CBOR string
10686
10687    This function first reads starting bytes to determine the expected
10688    string length and then copies this number of bytes into a string.
10689    Additionally, CBOR's strings with indefinite lengths are supported.
10690
10691    @param[out] result  created string
10692
10693    @return whether string creation completed
10694    */
10695    bool get_cbor_string(string_t& result)
10696    {
10697        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
10698        {
10699            return false;
10700        }
10701
10702        switch (current)
10703        {
10704            // UTF-8 string (0x00..0x17 bytes follow)
10705            case 0x60:
10706            case 0x61:
10707            case 0x62:
10708            case 0x63:
10709            case 0x64:
10710            case 0x65:
10711            case 0x66:
10712            case 0x67:
10713            case 0x68:
10714            case 0x69:
10715            case 0x6A:
10716            case 0x6B:
10717            case 0x6C:
10718            case 0x6D:
10719            case 0x6E:
10720            case 0x6F:
10721            case 0x70:
10722            case 0x71:
10723            case 0x72:
10724            case 0x73:
10725            case 0x74:
10726            case 0x75:
10727            case 0x76:
10728            case 0x77:
10729            {
10730                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
10731            }
10732
10733            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
10734            {
10735                std::uint8_t len{};
10736                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10737            }
10738
10739            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
10740            {
10741                std::uint16_t len{};
10742                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10743            }
10744
10745            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
10746            {
10747                std::uint32_t len{};
10748                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10749            }
10750
10751            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
10752            {
10753                std::uint64_t len{};
10754                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10755            }
10756
10757            case 0x7F: // UTF-8 string (indefinite length)
10758            {
10759                while (get() != 0xFF)
10760                {
10761                    string_t chunk;
10762                    if (!get_cbor_string(chunk))
10763                    {
10764                        return false;
10765                    }
10766                    result.append(chunk);
10767                }
10768                return true;
10769            }
10770
10771            default:
10772            {
10773                auto last_token = get_token_string();
10774                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
10775                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
10776            }
10777        }
10778    }
10779
10780    /*!
10781    @brief reads a CBOR byte array
10782
10783    This function first reads starting bytes to determine the expected
10784    byte array length and then copies this number of bytes into the byte array.
10785    Additionally, CBOR's byte arrays with indefinite lengths are supported.
10786
10787    @param[out] result  created byte array
10788
10789    @return whether byte array creation completed
10790    */
10791    bool get_cbor_binary(binary_t& result)
10792    {
10793        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
10794        {
10795            return false;
10796        }
10797
10798        switch (current)
10799        {
10800            // Binary data (0x00..0x17 bytes follow)
10801            case 0x40:
10802            case 0x41:
10803            case 0x42:
10804            case 0x43:
10805            case 0x44:
10806            case 0x45:
10807            case 0x46:
10808            case 0x47:
10809            case 0x48:
10810            case 0x49:
10811            case 0x4A:
10812            case 0x4B:
10813            case 0x4C:
10814            case 0x4D:
10815            case 0x4E:
10816            case 0x4F:
10817            case 0x50:
10818            case 0x51:
10819            case 0x52:
10820            case 0x53:
10821            case 0x54:
10822            case 0x55:
10823            case 0x56:
10824            case 0x57:
10825            {
10826                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
10827            }
10828
10829            case 0x58: // Binary data (one-byte uint8_t for n follows)
10830            {
10831                std::uint8_t len{};
10832                return get_number(input_format_t::cbor, len) &&
10833                       get_binary(input_format_t::cbor, len, result);
10834            }
10835
10836            case 0x59: // Binary data (two-byte uint16_t for n follow)
10837            {
10838                std::uint16_t len{};
10839                return get_number(input_format_t::cbor, len) &&
10840                       get_binary(input_format_t::cbor, len, result);
10841            }
10842
10843            case 0x5A: // Binary data (four-byte uint32_t for n follow)
10844            {
10845                std::uint32_t len{};
10846                return get_number(input_format_t::cbor, len) &&
10847                       get_binary(input_format_t::cbor, len, result);
10848            }
10849
10850            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
10851            {
10852                std::uint64_t len{};
10853                return get_number(input_format_t::cbor, len) &&
10854                       get_binary(input_format_t::cbor, len, result);
10855            }
10856
10857            case 0x5F: // Binary data (indefinite length)
10858            {
10859                while (get() != 0xFF)
10860                {
10861                    binary_t chunk;
10862                    if (!get_cbor_binary(chunk))
10863                    {
10864                        return false;
10865                    }
10866                    result.insert(result.end(), chunk.begin(), chunk.end());
10867                }
10868                return true;
10869            }
10870
10871            default:
10872            {
10873                auto last_token = get_token_string();
10874                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
10875                                        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));
10876            }
10877        }
10878    }
10879
10880    /*!
10881    @param[in] len  the length of the array or detail::unknown_size() for an
10882                    array of indefinite size
10883    @param[in] tag_handler how CBOR tags should be treated
10884    @return whether array creation completed
10885    */
10886    bool get_cbor_array(const std::size_t len,
10887                        const cbor_tag_handler_t tag_handler)
10888    {
10889        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
10890        {
10891            return false;
10892        }
10893
10894        if (len != detail::unknown_size())
10895        {
10896            for (std::size_t i = 0; i < len; ++i)
10897            {
10898                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
10899                {
10900                    return false;
10901                }
10902            }
10903        }
10904        else
10905        {
10906            while (get() != 0xFF)
10907            {
10908                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
10909                {
10910                    return false;
10911                }
10912            }
10913        }
10914
10915        return sax->end_array();
10916    }
10917
10918    /*!
10919    @param[in] len  the length of the object or detail::unknown_size() for an
10920                    object of indefinite size
10921    @param[in] tag_handler how CBOR tags should be treated
10922    @return whether object creation completed
10923    */
10924    bool get_cbor_object(const std::size_t len,
10925                         const cbor_tag_handler_t tag_handler)
10926    {
10927        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
10928        {
10929            return false;
10930        }
10931
10932        if (len != 0)
10933        {
10934            string_t key;
10935            if (len != detail::unknown_size())
10936            {
10937                for (std::size_t i = 0; i < len; ++i)
10938                {
10939                    get();
10940                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
10941                    {
10942                        return false;
10943                    }
10944
10945                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
10946                    {
10947                        return false;
10948                    }
10949                    key.clear();
10950                }
10951            }
10952            else
10953            {
10954                while (get() != 0xFF)
10955                {
10956                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
10957                    {
10958                        return false;
10959                    }
10960
10961                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
10962                    {
10963                        return false;
10964                    }
10965                    key.clear();
10966                }
10967            }
10968        }
10969
10970        return sax->end_object();
10971    }
10972
10973    /////////////
10974    // MsgPack //
10975    /////////////
10976
10977    /*!
10978    @return whether a valid MessagePack value was passed to the SAX parser
10979    */
10980    bool parse_msgpack_internal()
10981    {
10982        switch (get())
10983        {
10984            // EOF
10985            case char_traits<char_type>::eof():
10986                return unexpect_eof(input_format_t::msgpack, "value");
10987
10988            // positive fixint
10989            case 0x00:
10990            case 0x01:
10991            case 0x02:
10992            case 0x03:
10993            case 0x04:
10994            case 0x05:
10995            case 0x06:
10996            case 0x07:
10997            case 0x08:
10998            case 0x09:
10999            case 0x0A:
11000            case 0x0B:
11001            case 0x0C:
11002            case 0x0D:
11003            case 0x0E:
11004            case 0x0F:
11005            case 0x10:
11006            case 0x11:
11007            case 0x12:
11008            case 0x13:
11009            case 0x14:
11010            case 0x15:
11011            case 0x16:
11012            case 0x17:
11013            case 0x18:
11014            case 0x19:
11015            case 0x1A:
11016            case 0x1B:
11017            case 0x1C:
11018            case 0x1D:
11019            case 0x1E:
11020            case 0x1F:
11021            case 0x20:
11022            case 0x21:
11023            case 0x22:
11024            case 0x23:
11025            case 0x24:
11026            case 0x25:
11027            case 0x26:
11028            case 0x27:
11029            case 0x28:
11030            case 0x29:
11031            case 0x2A:
11032            case 0x2B:
11033            case 0x2C:
11034            case 0x2D:
11035            case 0x2E:
11036            case 0x2F:
11037            case 0x30:
11038            case 0x31:
11039            case 0x32:
11040            case 0x33:
11041            case 0x34:
11042            case 0x35:
11043            case 0x36:
11044            case 0x37:
11045            case 0x38:
11046            case 0x39:
11047            case 0x3A:
11048            case 0x3B:
11049            case 0x3C:
11050            case 0x3D:
11051            case 0x3E:
11052            case 0x3F:
11053            case 0x40:
11054            case 0x41:
11055            case 0x42:
11056            case 0x43:
11057            case 0x44:
11058            case 0x45:
11059            case 0x46:
11060            case 0x47:
11061            case 0x48:
11062            case 0x49:
11063            case 0x4A:
11064            case 0x4B:
11065            case 0x4C:
11066            case 0x4D:
11067            case 0x4E:
11068            case 0x4F:
11069            case 0x50:
11070            case 0x51:
11071            case 0x52:
11072            case 0x53:
11073            case 0x54:
11074            case 0x55:
11075            case 0x56:
11076            case 0x57:
11077            case 0x58:
11078            case 0x59:
11079            case 0x5A:
11080            case 0x5B:
11081            case 0x5C:
11082            case 0x5D:
11083            case 0x5E:
11084            case 0x5F:
11085            case 0x60:
11086            case 0x61:
11087            case 0x62:
11088            case 0x63:
11089            case 0x64:
11090            case 0x65:
11091            case 0x66:
11092            case 0x67:
11093            case 0x68:
11094            case 0x69:
11095            case 0x6A:
11096            case 0x6B:
11097            case 0x6C:
11098            case 0x6D:
11099            case 0x6E:
11100            case 0x6F:
11101            case 0x70:
11102            case 0x71:
11103            case 0x72:
11104            case 0x73:
11105            case 0x74:
11106            case 0x75:
11107            case 0x76:
11108            case 0x77:
11109            case 0x78:
11110            case 0x79:
11111            case 0x7A:
11112            case 0x7B:
11113            case 0x7C:
11114            case 0x7D:
11115            case 0x7E:
11116            case 0x7F:
11117                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
11118
11119            // fixmap
11120            case 0x80:
11121            case 0x81:
11122            case 0x82:
11123            case 0x83:
11124            case 0x84:
11125            case 0x85:
11126            case 0x86:
11127            case 0x87:
11128            case 0x88:
11129            case 0x89:
11130            case 0x8A:
11131            case 0x8B:
11132            case 0x8C:
11133            case 0x8D:
11134            case 0x8E:
11135            case 0x8F:
11136                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
11137
11138            // fixarray
11139            case 0x90:
11140            case 0x91:
11141            case 0x92:
11142            case 0x93:
11143            case 0x94:
11144            case 0x95:
11145            case 0x96:
11146            case 0x97:
11147            case 0x98:
11148            case 0x99:
11149            case 0x9A:
11150            case 0x9B:
11151            case 0x9C:
11152            case 0x9D:
11153            case 0x9E:
11154            case 0x9F:
11155                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
11156
11157            // fixstr
11158            case 0xA0:
11159            case 0xA1:
11160            case 0xA2:
11161            case 0xA3:
11162            case 0xA4:
11163            case 0xA5:
11164            case 0xA6:
11165            case 0xA7:
11166            case 0xA8:
11167            case 0xA9:
11168            case 0xAA:
11169            case 0xAB:
11170            case 0xAC:
11171            case 0xAD:
11172            case 0xAE:
11173            case 0xAF:
11174            case 0xB0:
11175            case 0xB1:
11176            case 0xB2:
11177            case 0xB3:
11178            case 0xB4:
11179            case 0xB5:
11180            case 0xB6:
11181            case 0xB7:
11182            case 0xB8:
11183            case 0xB9:
11184            case 0xBA:
11185            case 0xBB:
11186            case 0xBC:
11187            case 0xBD:
11188            case 0xBE:
11189            case 0xBF:
11190            case 0xD9: // str 8
11191            case 0xDA: // str 16
11192            case 0xDB: // str 32
11193            {
11194                string_t s;
11195                return get_msgpack_string(s) && sax->string(s);
11196            }
11197
11198            case 0xC0: // nil
11199                return sax->null();
11200
11201            case 0xC2: // false
11202                return sax->boolean(false);
11203
11204            case 0xC3: // true
11205                return sax->boolean(true);
11206
11207            case 0xC4: // bin 8
11208            case 0xC5: // bin 16
11209            case 0xC6: // bin 32
11210            case 0xC7: // ext 8
11211            case 0xC8: // ext 16
11212            case 0xC9: // ext 32
11213            case 0xD4: // fixext 1
11214            case 0xD5: // fixext 2
11215            case 0xD6: // fixext 4
11216            case 0xD7: // fixext 8
11217            case 0xD8: // fixext 16
11218            {
11219                binary_t b;
11220                return get_msgpack_binary(b) && sax->binary(b);
11221            }
11222
11223            case 0xCA: // float 32
11224            {
11225                float number{};
11226                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
11227            }
11228
11229            case 0xCB: // float 64
11230            {
11231                double number{};
11232                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
11233            }
11234
11235            case 0xCC: // uint 8
11236            {
11237                std::uint8_t number{};
11238                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
11239            }
11240
11241            case 0xCD: // uint 16
11242            {
11243                std::uint16_t number{};
11244                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
11245            }
11246
11247            case 0xCE: // uint 32
11248            {
11249                std::uint32_t number{};
11250                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
11251            }
11252
11253            case 0xCF: // uint 64
11254            {
11255                std::uint64_t number{};
11256                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
11257            }
11258
11259            case 0xD0: // int 8
11260            {
11261                std::int8_t number{};
11262                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
11263            }
11264
11265            case 0xD1: // int 16
11266            {
11267                std::int16_t number{};
11268                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
11269            }
11270
11271            case 0xD2: // int 32
11272            {
11273                std::int32_t number{};
11274                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
11275            }
11276
11277            case 0xD3: // int 64
11278            {
11279                std::int64_t number{};
11280                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
11281            }
11282
11283            case 0xDC: // array 16
11284            {
11285                std::uint16_t len{};
11286                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
11287            }
11288
11289            case 0xDD: // array 32
11290            {
11291                std::uint32_t len{};
11292                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
11293            }
11294
11295            case 0xDE: // map 16
11296            {
11297                std::uint16_t len{};
11298                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
11299            }
11300
11301            case 0xDF: // map 32
11302            {
11303                std::uint32_t len{};
11304                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
11305            }
11306
11307            // negative fixint
11308            case 0xE0:
11309            case 0xE1:
11310            case 0xE2:
11311            case 0xE3:
11312            case 0xE4:
11313            case 0xE5:
11314            case 0xE6:
11315            case 0xE7:
11316            case 0xE8:
11317            case 0xE9:
11318            case 0xEA:
11319            case 0xEB:
11320            case 0xEC:
11321            case 0xED:
11322            case 0xEE:
11323            case 0xEF:
11324            case 0xF0:
11325            case 0xF1:
11326            case 0xF2:
11327            case 0xF3:
11328            case 0xF4:
11329            case 0xF5:
11330            case 0xF6:
11331            case 0xF7:
11332            case 0xF8:
11333            case 0xF9:
11334            case 0xFA:
11335            case 0xFB:
11336            case 0xFC:
11337            case 0xFD:
11338            case 0xFE:
11339            case 0xFF:
11340                return sax->number_integer(static_cast<std::int8_t>(current));
11341
11342            default: // anything else
11343            {
11344                auto last_token = get_token_string();
11345                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
11346                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
11347            }
11348        }
11349    }
11350
11351    /*!
11352    @brief reads a MessagePack string
11353
11354    This function first reads starting bytes to determine the expected
11355    string length and then copies this number of bytes into a string.
11356
11357    @param[out] result  created string
11358
11359    @return whether string creation completed
11360    */
11361    bool get_msgpack_string(string_t& result)
11362    {
11363        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
11364        {
11365            return false;
11366        }
11367
11368        switch (current)
11369        {
11370            // fixstr
11371            case 0xA0:
11372            case 0xA1:
11373            case 0xA2:
11374            case 0xA3:
11375            case 0xA4:
11376            case 0xA5:
11377            case 0xA6:
11378            case 0xA7:
11379            case 0xA8:
11380            case 0xA9:
11381            case 0xAA:
11382            case 0xAB:
11383            case 0xAC:
11384            case 0xAD:
11385            case 0xAE:
11386            case 0xAF:
11387            case 0xB0:
11388            case 0xB1:
11389            case 0xB2:
11390            case 0xB3:
11391            case 0xB4:
11392            case 0xB5:
11393            case 0xB6:
11394            case 0xB7:
11395            case 0xB8:
11396            case 0xB9:
11397            case 0xBA:
11398            case 0xBB:
11399            case 0xBC:
11400            case 0xBD:
11401            case 0xBE:
11402            case 0xBF:
11403            {
11404                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
11405            }
11406
11407            case 0xD9: // str 8
11408            {
11409                std::uint8_t len{};
11410                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
11411            }
11412
11413            case 0xDA: // str 16
11414            {
11415                std::uint16_t len{};
11416                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
11417            }
11418
11419            case 0xDB: // str 32
11420            {
11421                std::uint32_t len{};
11422                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
11423            }
11424
11425            default:
11426            {
11427                auto last_token = get_token_string();
11428                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
11429                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
11430            }
11431        }
11432    }
11433
11434    /*!
11435    @brief reads a MessagePack byte array
11436
11437    This function first reads starting bytes to determine the expected
11438    byte array length and then copies this number of bytes into a byte array.
11439
11440    @param[out] result  created byte array
11441
11442    @return whether byte array creation completed
11443    */
11444    bool get_msgpack_binary(binary_t& result)
11445    {
11446        // helper function to set the subtype
11447        auto assign_and_return_true = [&result](std::int8_t subtype)
11448        {
11449            result.set_subtype(static_cast<std::uint8_t>(subtype));
11450            return true;
11451        };
11452
11453        switch (current)
11454        {
11455            case 0xC4: // bin 8
11456            {
11457                std::uint8_t len{};
11458                return get_number(input_format_t::msgpack, len) &&
11459                       get_binary(input_format_t::msgpack, len, result);
11460            }
11461
11462            case 0xC5: // bin 16
11463            {
11464                std::uint16_t len{};
11465                return get_number(input_format_t::msgpack, len) &&
11466                       get_binary(input_format_t::msgpack, len, result);
11467            }
11468
11469            case 0xC6: // bin 32
11470            {
11471                std::uint32_t len{};
11472                return get_number(input_format_t::msgpack, len) &&
11473                       get_binary(input_format_t::msgpack, len, result);
11474            }
11475
11476            case 0xC7: // ext 8
11477            {
11478                std::uint8_t len{};
11479                std::int8_t subtype{};
11480                return get_number(input_format_t::msgpack, len) &&
11481                       get_number(input_format_t::msgpack, subtype) &&
11482                       get_binary(input_format_t::msgpack, len, result) &&
11483                       assign_and_return_true(subtype);
11484            }
11485
11486            case 0xC8: // ext 16
11487            {
11488                std::uint16_t len{};
11489                std::int8_t subtype{};
11490                return get_number(input_format_t::msgpack, len) &&
11491                       get_number(input_format_t::msgpack, subtype) &&
11492                       get_binary(input_format_t::msgpack, len, result) &&
11493                       assign_and_return_true(subtype);
11494            }
11495
11496            case 0xC9: // ext 32
11497            {
11498                std::uint32_t len{};
11499                std::int8_t subtype{};
11500                return get_number(input_format_t::msgpack, len) &&
11501                       get_number(input_format_t::msgpack, subtype) &&
11502                       get_binary(input_format_t::msgpack, len, result) &&
11503                       assign_and_return_true(subtype);
11504            }
11505
11506            case 0xD4: // fixext 1
11507            {
11508                std::int8_t subtype{};
11509                return get_number(input_format_t::msgpack, subtype) &&
11510                       get_binary(input_format_t::msgpack, 1, result) &&
11511                       assign_and_return_true(subtype);
11512            }
11513
11514            case 0xD5: // fixext 2
11515            {
11516                std::int8_t subtype{};
11517                return get_number(input_format_t::msgpack, subtype) &&
11518                       get_binary(input_format_t::msgpack, 2, result) &&
11519                       assign_and_return_true(subtype);
11520            }
11521
11522            case 0xD6: // fixext 4
11523            {
11524                std::int8_t subtype{};
11525                return get_number(input_format_t::msgpack, subtype) &&
11526                       get_binary(input_format_t::msgpack, 4, result) &&
11527                       assign_and_return_true(subtype);
11528            }
11529
11530            case 0xD7: // fixext 8
11531            {
11532                std::int8_t subtype{};
11533                return get_number(input_format_t::msgpack, subtype) &&
11534                       get_binary(input_format_t::msgpack, 8, result) &&
11535                       assign_and_return_true(subtype);
11536            }
11537
11538            case 0xD8: // fixext 16
11539            {
11540                std::int8_t subtype{};
11541                return get_number(input_format_t::msgpack, subtype) &&
11542                       get_binary(input_format_t::msgpack, 16, result) &&
11543                       assign_and_return_true(subtype);
11544            }
11545
11546            default:           // LCOV_EXCL_LINE
11547                return false;  // LCOV_EXCL_LINE
11548        }
11549    }
11550
11551    /*!
11552    @param[in] len  the length of the array
11553    @return whether array creation completed
11554    */
11555    bool get_msgpack_array(const std::size_t len)
11556    {
11557        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
11558        {
11559            return false;
11560        }
11561
11562        for (std::size_t i = 0; i < len; ++i)
11563        {
11564            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
11565            {
11566                return false;
11567            }
11568        }
11569
11570        return sax->end_array();
11571    }
11572
11573    /*!
11574    @param[in] len  the length of the object
11575    @return whether object creation completed
11576    */
11577    bool get_msgpack_object(const std::size_t len)
11578    {
11579        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
11580        {
11581            return false;
11582        }
11583
11584        string_t key;
11585        for (std::size_t i = 0; i < len; ++i)
11586        {
11587            get();
11588            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
11589            {
11590                return false;
11591            }
11592
11593            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
11594            {
11595                return false;
11596            }
11597            key.clear();
11598        }
11599
11600        return sax->end_object();
11601    }
11602
11603    ////////////
11604    // UBJSON //
11605    ////////////
11606
11607    /*!
11608    @param[in] get_char  whether a new character should be retrieved from the
11609                         input (true, default) or whether the last read
11610                         character should be considered instead
11611
11612    @return whether a valid UBJSON value was passed to the SAX parser
11613    */
11614    bool parse_ubjson_internal(const bool get_char = true)
11615    {
11616        return get_ubjson_value(get_char ? get_ignore_noop() : current);
11617    }
11618
11619    /*!
11620    @brief reads a UBJSON string
11621
11622    This function is either called after reading the 'S' byte explicitly
11623    indicating a string, or in case of an object key where the 'S' byte can be
11624    left out.
11625
11626    @param[out] result   created string
11627    @param[in] get_char  whether a new character should be retrieved from the
11628                         input (true, default) or whether the last read
11629                         character should be considered instead
11630
11631    @return whether string creation completed
11632    */
11633    bool get_ubjson_string(string_t& result, const bool get_char = true)
11634    {
11635        if (get_char)
11636        {
11637            get();  // TODO(niels): may we ignore N here?
11638        }
11639
11640        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
11641        {
11642            return false;
11643        }
11644
11645        switch (current)
11646        {
11647            case 'U':
11648            {
11649                std::uint8_t len{};
11650                return get_number(input_format, len) && get_string(input_format, len, result);
11651            }
11652
11653            case 'i':
11654            {
11655                std::int8_t len{};
11656                return get_number(input_format, len) && get_string(input_format, len, result);
11657            }
11658
11659            case 'I':
11660            {
11661                std::int16_t len{};
11662                return get_number(input_format, len) && get_string(input_format, len, result);
11663            }
11664
11665            case 'l':
11666            {
11667                std::int32_t len{};
11668                return get_number(input_format, len) && get_string(input_format, len, result);
11669            }
11670
11671            case 'L':
11672            {
11673                std::int64_t len{};
11674                return get_number(input_format, len) && get_string(input_format, len, result);
11675            }
11676
11677            case 'u':
11678            {
11679                if (input_format != input_format_t::bjdata)
11680                {
11681                    break;
11682                }
11683                std::uint16_t len{};
11684                return get_number(input_format, len) && get_string(input_format, len, result);
11685            }
11686
11687            case 'm':
11688            {
11689                if (input_format != input_format_t::bjdata)
11690                {
11691                    break;
11692                }
11693                std::uint32_t len{};
11694                return get_number(input_format, len) && get_string(input_format, len, result);
11695            }
11696
11697            case 'M':
11698            {
11699                if (input_format != input_format_t::bjdata)
11700                {
11701                    break;
11702                }
11703                std::uint64_t len{};
11704                return get_number(input_format, len) && get_string(input_format, len, result);
11705            }
11706
11707            default:
11708                break;
11709        }
11710        auto last_token = get_token_string();
11711        std::string message;
11712
11713        if (input_format != input_format_t::bjdata)
11714        {
11715            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
11716        }
11717        else
11718        {
11719            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
11720        }
11721        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
11722    }
11723
11724    /*!
11725    @param[out] dim  an integer vector storing the ND array dimensions
11726    @return whether reading ND array size vector is successful
11727    */
11728    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
11729    {
11730        std::pair<std::size_t, char_int_type> size_and_type;
11731        size_t dimlen = 0;
11732        bool no_ndarray = true;
11733
11734        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
11735        {
11736            return false;
11737        }
11738
11739        if (size_and_type.first != npos)
11740        {
11741            if (size_and_type.second != 0)
11742            {
11743                if (size_and_type.second != 'N')
11744                {
11745                    for (std::size_t i = 0; i < size_and_type.first; ++i)
11746                    {
11747                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
11748                        {
11749                            return false;
11750                        }
11751                        dim.push_back(dimlen);
11752                    }
11753                }
11754            }
11755            else
11756            {
11757                for (std::size_t i = 0; i < size_and_type.first; ++i)
11758                {
11759                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
11760                    {
11761                        return false;
11762                    }
11763                    dim.push_back(dimlen);
11764                }
11765            }
11766        }
11767        else
11768        {
11769            while (current != ']')
11770            {
11771                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
11772                {
11773                    return false;
11774                }
11775                dim.push_back(dimlen);
11776                get_ignore_noop();
11777            }
11778        }
11779        return true;
11780    }
11781
11782    /*!
11783    @param[out] result  determined size
11784    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
11785                               or ndarray dimension is not allowed; `false` means ndarray
11786                               is allowed; for output, `true` means an ndarray is found;
11787                               is_ndarray can only return `true` when its initial value
11788                               is `false`
11789    @param[in] prefix  type marker if already read, otherwise set to 0
11790
11791    @return whether size determination completed
11792    */
11793    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
11794    {
11795        if (prefix == 0)
11796        {
11797            prefix = get_ignore_noop();
11798        }
11799
11800        switch (prefix)
11801        {
11802            case 'U':
11803            {
11804                std::uint8_t number{};
11805                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11806                {
11807                    return false;
11808                }
11809                result = static_cast<std::size_t>(number);
11810                return true;
11811            }
11812
11813            case 'i':
11814            {
11815                std::int8_t number{};
11816                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11817                {
11818                    return false;
11819                }
11820                if (number < 0)
11821                {
11822                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11823                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11824                }
11825                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
11826                return true;
11827            }
11828
11829            case 'I':
11830            {
11831                std::int16_t number{};
11832                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11833                {
11834                    return false;
11835                }
11836                if (number < 0)
11837                {
11838                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11839                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11840                }
11841                result = static_cast<std::size_t>(number);
11842                return true;
11843            }
11844
11845            case 'l':
11846            {
11847                std::int32_t number{};
11848                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11849                {
11850                    return false;
11851                }
11852                if (number < 0)
11853                {
11854                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11855                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11856                }
11857                result = static_cast<std::size_t>(number);
11858                return true;
11859            }
11860
11861            case 'L':
11862            {
11863                std::int64_t number{};
11864                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11865                {
11866                    return false;
11867                }
11868                if (number < 0)
11869                {
11870                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
11871                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
11872                }
11873                if (!value_in_range_of<std::size_t>(number))
11874                {
11875                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
11876                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
11877                }
11878                result = static_cast<std::size_t>(number);
11879                return true;
11880            }
11881
11882            case 'u':
11883            {
11884                if (input_format != input_format_t::bjdata)
11885                {
11886                    break;
11887                }
11888                std::uint16_t number{};
11889                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11890                {
11891                    return false;
11892                }
11893                result = static_cast<std::size_t>(number);
11894                return true;
11895            }
11896
11897            case 'm':
11898            {
11899                if (input_format != input_format_t::bjdata)
11900                {
11901                    break;
11902                }
11903                std::uint32_t number{};
11904                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11905                {
11906                    return false;
11907                }
11908                result = conditional_static_cast<std::size_t>(number);
11909                return true;
11910            }
11911
11912            case 'M':
11913            {
11914                if (input_format != input_format_t::bjdata)
11915                {
11916                    break;
11917                }
11918                std::uint64_t number{};
11919                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
11920                {
11921                    return false;
11922                }
11923                if (!value_in_range_of<std::size_t>(number))
11924                {
11925                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
11926                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
11927                }
11928                result = detail::conditional_static_cast<std::size_t>(number);
11929                return true;
11930            }
11931
11932            case '[':
11933            {
11934                if (input_format != input_format_t::bjdata)
11935                {
11936                    break;
11937                }
11938                if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array
11939                {
11940                    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));
11941                }
11942                std::vector<size_t> dim;
11943                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
11944                {
11945                    return false;
11946                }
11947                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
11948                {
11949                    result = dim.at(dim.size() - 1);
11950                    return true;
11951                }
11952                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
11953                {
11954                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
11955                    {
11956                        if ( i == 0 )
11957                        {
11958                            result = 0;
11959                            return true;
11960                        }
11961                    }
11962
11963                    string_t key = "_ArraySize_";
11964                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
11965                    {
11966                        return false;
11967                    }
11968                    result = 1;
11969                    for (auto i : dim)
11970                    {
11971                        result *= i;
11972                        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()
11973                        {
11974                            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));
11975                        }
11976                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
11977                        {
11978                            return false;
11979                        }
11980                    }
11981                    is_ndarray = true;
11982                    return sax->end_array();
11983                }
11984                result = 0;
11985                return true;
11986            }
11987
11988            default:
11989                break;
11990        }
11991        auto last_token = get_token_string();
11992        std::string message;
11993
11994        if (input_format != input_format_t::bjdata)
11995        {
11996            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
11997        }
11998        else
11999        {
12000            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
12001        }
12002        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
12003    }
12004
12005    /*!
12006    @brief determine the type and size for a container
12007
12008    In the optimized UBJSON format, a type and a size can be provided to allow
12009    for a more compact representation.
12010
12011    @param[out] result  pair of the size and the type
12012    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector
12013
12014    @return whether pair creation completed
12015    */
12016    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
12017    {
12018        result.first = npos; // size
12019        result.second = 0; // type
12020        bool is_ndarray = false;
12021
12022        get_ignore_noop();
12023
12024        if (current == '$')
12025        {
12026            result.second = get();  // must not ignore 'N', because 'N' maybe the type
12027            if (input_format == input_format_t::bjdata
12028                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
12029            {
12030                auto last_token = get_token_string();
12031                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
12032                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
12033            }
12034
12035            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
12036            {
12037                return false;
12038            }
12039
12040            get_ignore_noop();
12041            if (JSON_HEDLEY_UNLIKELY(current != '#'))
12042            {
12043                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
12044                {
12045                    return false;
12046                }
12047                auto last_token = get_token_string();
12048                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
12049                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
12050            }
12051
12052            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
12053            if (input_format == input_format_t::bjdata && is_ndarray)
12054            {
12055                if (inside_ndarray)
12056                {
12057                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
12058                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
12059                }
12060                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
12061            }
12062            return is_error;
12063        }
12064
12065        if (current == '#')
12066        {
12067            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
12068            if (input_format == input_format_t::bjdata && is_ndarray)
12069            {
12070                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
12071                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
12072            }
12073            return is_error;
12074        }
12075
12076        return true;
12077    }
12078
12079    /*!
12080    @param prefix  the previously read or set type prefix
12081    @return whether value creation completed
12082    */
12083    bool get_ubjson_value(const char_int_type prefix)
12084    {
12085        switch (prefix)
12086        {
12087            case char_traits<char_type>::eof():  // EOF
12088                return unexpect_eof(input_format, "value");
12089
12090            case 'T':  // true
12091                return sax->boolean(true);
12092            case 'F':  // false
12093                return sax->boolean(false);
12094
12095            case 'Z':  // null
12096                return sax->null();
12097
12098            case 'B':  // byte
12099            {
12100                if (input_format != input_format_t::bjdata)
12101                {
12102                    break;
12103                }
12104                std::uint8_t number{};
12105                return get_number(input_format, number) && sax->number_unsigned(number);
12106            }
12107
12108            case 'U':
12109            {
12110                std::uint8_t number{};
12111                return get_number(input_format, number) && sax->number_unsigned(number);
12112            }
12113
12114            case 'i':
12115            {
12116                std::int8_t number{};
12117                return get_number(input_format, number) && sax->number_integer(number);
12118            }
12119
12120            case 'I':
12121            {
12122                std::int16_t number{};
12123                return get_number(input_format, number) && sax->number_integer(number);
12124            }
12125
12126            case 'l':
12127            {
12128                std::int32_t number{};
12129                return get_number(input_format, number) && sax->number_integer(number);
12130            }
12131
12132            case 'L':
12133            {
12134                std::int64_t number{};
12135                return get_number(input_format, number) && sax->number_integer(number);
12136            }
12137
12138            case 'u':
12139            {
12140                if (input_format != input_format_t::bjdata)
12141                {
12142                    break;
12143                }
12144                std::uint16_t number{};
12145                return get_number(input_format, number) && sax->number_unsigned(number);
12146            }
12147
12148            case 'm':
12149            {
12150                if (input_format != input_format_t::bjdata)
12151                {
12152                    break;
12153                }
12154                std::uint32_t number{};
12155                return get_number(input_format, number) && sax->number_unsigned(number);
12156            }
12157
12158            case 'M':
12159            {
12160                if (input_format != input_format_t::bjdata)
12161                {
12162                    break;
12163                }
12164                std::uint64_t number{};
12165                return get_number(input_format, number) && sax->number_unsigned(number);
12166            }
12167
12168            case 'h':
12169            {
12170                if (input_format != input_format_t::bjdata)
12171                {
12172                    break;
12173                }
12174                const auto byte1_raw = get();
12175                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
12176                {
12177                    return false;
12178                }
12179                const auto byte2_raw = get();
12180                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
12181                {
12182                    return false;
12183                }
12184
12185                const auto byte1 = static_cast<unsigned char>(byte1_raw);
12186                const auto byte2 = static_cast<unsigned char>(byte2_raw);
12187
12188                // code from RFC 7049, Appendix D, Figure 3:
12189                // As half-precision floating-point numbers were only added
12190                // to IEEE 754 in 2008, today's programming platforms often
12191                // still only have limited support for them. It is very
12192                // easy to include at least decoding support for them even
12193                // without such support. An example of a small decoder for
12194                // half-precision floating-point numbers in the C language
12195                // is shown in Fig. 3.
12196                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
12197                const double val = [&half]
12198                {
12199                    const int exp = (half >> 10u) & 0x1Fu;
12200                    const unsigned int mant = half & 0x3FFu;
12201                    JSON_ASSERT(0 <= exp&& exp <= 32);
12202                    JSON_ASSERT(mant <= 1024);
12203                    switch (exp)
12204                    {
12205                        case 0:
12206                            return std::ldexp(mant, -24);
12207                        case 31:
12208                            return (mant == 0)
12209                            ? std::numeric_limits<double>::infinity()
12210                            : std::numeric_limits<double>::quiet_NaN();
12211                        default:
12212                            return std::ldexp(mant + 1024, exp - 25);
12213                    }
12214                }();
12215                return sax->number_float((half & 0x8000u) != 0
12216                                         ? static_cast<number_float_t>(-val)
12217                                         : static_cast<number_float_t>(val), "");
12218            }
12219
12220            case 'd':
12221            {
12222                float number{};
12223                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
12224            }
12225
12226            case 'D':
12227            {
12228                double number{};
12229                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
12230            }
12231
12232            case 'H':
12233            {
12234                return get_ubjson_high_precision_number();
12235            }
12236
12237            case 'C':  // char
12238            {
12239                get();
12240                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
12241                {
12242                    return false;
12243                }
12244                if (JSON_HEDLEY_UNLIKELY(current > 127))
12245                {
12246                    auto last_token = get_token_string();
12247                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
12248                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
12249                }
12250                string_t s(1, static_cast<typename string_t::value_type>(current));
12251                return sax->string(s);
12252            }
12253
12254            case 'S':  // string
12255            {
12256                string_t s;
12257                return get_ubjson_string(s) && sax->string(s);
12258            }
12259
12260            case '[':  // array
12261                return get_ubjson_array();
12262
12263            case '{':  // object
12264                return get_ubjson_object();
12265
12266            default: // anything else
12267                break;
12268        }
12269        auto last_token = get_token_string();
12270        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));
12271    }
12272
12273    /*!
12274    @return whether array creation completed
12275    */
12276    bool get_ubjson_array()
12277    {
12278        std::pair<std::size_t, char_int_type> size_and_type;
12279        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
12280        {
12281            return false;
12282        }
12283
12284        // 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):
12285        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
12286
12287        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
12288        {
12289            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
12290            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)
12291            {
12292                return p.first < t;
12293            });
12294            string_t key = "_ArrayType_";
12295            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
12296            {
12297                auto last_token = get_token_string();
12298                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
12299                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
12300            }
12301
12302            string_t type = it->second; // sax->string() takes a reference
12303            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
12304            {
12305                return false;
12306            }
12307
12308            if (size_and_type.second == 'C' || size_and_type.second == 'B')
12309            {
12310                size_and_type.second = 'U';
12311            }
12312
12313            key = "_ArrayData_";
12314            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
12315            {
12316                return false;
12317            }
12318
12319            for (std::size_t i = 0; i < size_and_type.first; ++i)
12320            {
12321                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
12322                {
12323                    return false;
12324                }
12325            }
12326
12327            return (sax->end_array() && sax->end_object());
12328        }
12329
12330        // If BJData type marker is 'B' decode as binary
12331        if (input_format == input_format_t::bjdata && size_and_type.first != npos && size_and_type.second == 'B')
12332        {
12333            binary_t result;
12334            return get_binary(input_format, size_and_type.first, result) && sax->binary(result);
12335        }
12336
12337        if (size_and_type.first != npos)
12338        {
12339            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
12340            {
12341                return false;
12342            }
12343
12344            if (size_and_type.second != 0)
12345            {
12346                if (size_and_type.second != 'N')
12347                {
12348                    for (std::size_t i = 0; i < size_and_type.first; ++i)
12349                    {
12350                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
12351                        {
12352                            return false;
12353                        }
12354                    }
12355                }
12356            }
12357            else
12358            {
12359                for (std::size_t i = 0; i < size_and_type.first; ++i)
12360                {
12361                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
12362                    {
12363                        return false;
12364                    }
12365                }
12366            }
12367        }
12368        else
12369        {
12370            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
12371            {
12372                return false;
12373            }
12374
12375            while (current != ']')
12376            {
12377                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
12378                {
12379                    return false;
12380                }
12381                get_ignore_noop();
12382            }
12383        }
12384
12385        return sax->end_array();
12386    }
12387
12388    /*!
12389    @return whether object creation completed
12390    */
12391    bool get_ubjson_object()
12392    {
12393        std::pair<std::size_t, char_int_type> size_and_type;
12394        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
12395        {
12396            return false;
12397        }
12398
12399        // do not accept ND-array size in objects in BJData
12400        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
12401        {
12402            auto last_token = get_token_string();
12403            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
12404                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
12405        }
12406
12407        string_t key;
12408        if (size_and_type.first != npos)
12409        {
12410            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
12411            {
12412                return false;
12413            }
12414
12415            if (size_and_type.second != 0)
12416            {
12417                for (std::size_t i = 0; i < size_and_type.first; ++i)
12418                {
12419                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
12420                    {
12421                        return false;
12422                    }
12423                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
12424                    {
12425                        return false;
12426                    }
12427                    key.clear();
12428                }
12429            }
12430            else
12431            {
12432                for (std::size_t i = 0; i < size_and_type.first; ++i)
12433                {
12434                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
12435                    {
12436                        return false;
12437                    }
12438                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
12439                    {
12440                        return false;
12441                    }
12442                    key.clear();
12443                }
12444            }
12445        }
12446        else
12447        {
12448            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
12449            {
12450                return false;
12451            }
12452
12453            while (current != '}')
12454            {
12455                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
12456                {
12457                    return false;
12458                }
12459                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
12460                {
12461                    return false;
12462                }
12463                get_ignore_noop();
12464                key.clear();
12465            }
12466        }
12467
12468        return sax->end_object();
12469    }
12470
12471    // Note, no reader for UBJSON binary types is implemented because they do
12472    // not exist
12473
12474    bool get_ubjson_high_precision_number()
12475    {
12476        // get size of following number string
12477        std::size_t size{};
12478        bool no_ndarray = true;
12479        auto res = get_ubjson_size_value(size, no_ndarray);
12480        if (JSON_HEDLEY_UNLIKELY(!res))
12481        {
12482            return res;
12483        }
12484
12485        // get number string
12486        std::vector<char> number_vector;
12487        for (std::size_t i = 0; i < size; ++i)
12488        {
12489            get();
12490            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
12491            {
12492                return false;
12493            }
12494            number_vector.push_back(static_cast<char>(current));
12495        }
12496
12497        // parse number string
12498        using ia_type = decltype(detail::input_adapter(number_vector));
12499        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
12500        const auto result_number = number_lexer.scan();
12501        const auto number_string = number_lexer.get_token_string();
12502        const auto result_remainder = number_lexer.scan();
12503
12504        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
12505
12506        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
12507        {
12508            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
12509                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
12510        }
12511
12512        switch (result_number)
12513        {
12514            case token_type::value_integer:
12515                return sax->number_integer(number_lexer.get_number_integer());
12516            case token_type::value_unsigned:
12517                return sax->number_unsigned(number_lexer.get_number_unsigned());
12518            case token_type::value_float:
12519                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
12520            case token_type::uninitialized:
12521            case token_type::literal_true:
12522            case token_type::literal_false:
12523            case token_type::literal_null:
12524            case token_type::value_string:
12525            case token_type::begin_array:
12526            case token_type::begin_object:
12527            case token_type::end_array:
12528            case token_type::end_object:
12529            case token_type::name_separator:
12530            case token_type::value_separator:
12531            case token_type::parse_error:
12532            case token_type::end_of_input:
12533            case token_type::literal_or_value:
12534            default:
12535                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
12536                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
12537        }
12538    }
12539
12540    ///////////////////////
12541    // Utility functions //
12542    ///////////////////////
12543
12544    /*!
12545    @brief get next character from the input
12546
12547    This function provides the interface to the used input adapter. It does
12548    not throw in case the input reached EOF, but returns a -'ve valued
12549    `char_traits<char_type>::eof()` in that case.
12550
12551    @return character read from the input
12552    */
12553    char_int_type get()
12554    {
12555        ++chars_read;
12556        return current = ia.get_character();
12557    }
12558
12559    /*!
12560    @brief get_to read into a primitive type
12561
12562    This function provides the interface to the used input adapter. It does
12563    not throw in case the input reached EOF, but returns false instead
12564
12565    @return bool, whether the read was successful
12566    */
12567    template<class T>
12568    bool get_to(T& dest, const input_format_t format, const char* context)
12569    {
12570        auto new_chars_read = ia.get_elements(&dest);
12571        chars_read += new_chars_read;
12572        if (JSON_HEDLEY_UNLIKELY(new_chars_read < sizeof(T)))
12573        {
12574            // in case of failure, advance position by 1 to report failing location
12575            ++chars_read;
12576            sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
12577            return false;
12578        }
12579        return true;
12580    }
12581
12582    /*!
12583    @return character read from the input after ignoring all 'N' entries
12584    */
12585    char_int_type get_ignore_noop()
12586    {
12587        do
12588        {
12589            get();
12590        }
12591        while (current == 'N');
12592
12593        return current;
12594    }
12595
12596    template<class NumberType>
12597    static void byte_swap(NumberType& number)
12598    {
12599        constexpr std::size_t sz = sizeof(number);
12600#ifdef __cpp_lib_byteswap
12601        if constexpr (sz == 1)
12602        {
12603            return;
12604        }
12605        if constexpr(std::is_integral_v<NumberType>)
12606        {
12607            number = std::byteswap(number);
12608            return;
12609        }
12610#endif
12611        auto* ptr = reinterpret_cast<std::uint8_t*>(&number);
12612        for (std::size_t i = 0; i < sz / 2; ++i)
12613        {
12614            std::swap(ptr[i], ptr[sz - i - 1]);
12615        }
12616    }
12617
12618    /*
12619    @brief read a number from the input
12620
12621    @tparam NumberType the type of the number
12622    @param[in] format   the current format (for diagnostics)
12623    @param[out] result  number of type @a NumberType
12624
12625    @return whether conversion completed
12626
12627    @note This function needs to respect the system's endianness, because
12628          bytes in CBOR, MessagePack, and UBJSON are stored in network order
12629          (big endian) and therefore need reordering on little endian systems.
12630          On the other hand, BSON and BJData use little endian and should reorder
12631          on big endian systems.
12632    */
12633    template<typename NumberType, bool InputIsLittleEndian = false>
12634    bool get_number(const input_format_t format, NumberType& result)
12635    {
12636        // read in the original format
12637
12638        if (JSON_HEDLEY_UNLIKELY(!get_to(result, format, "number")))
12639        {
12640            return false;
12641        }
12642        if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
12643        {
12644            byte_swap(result);
12645        }
12646        return true;
12647    }
12648
12649    /*!
12650    @brief create a string by reading characters from the input
12651
12652    @tparam NumberType the type of the number
12653    @param[in] format the current format (for diagnostics)
12654    @param[in] len number of characters to read
12655    @param[out] result string created by reading @a len bytes
12656
12657    @return whether string creation completed
12658
12659    @note We can not reserve @a len bytes for the result, because @a len
12660          may be too large. Usually, @ref unexpect_eof() detects the end of
12661          the input before we run out of string memory.
12662    */
12663    template<typename NumberType>
12664    bool get_string(const input_format_t format,
12665                    const NumberType len,
12666                    string_t& result)
12667    {
12668        bool success = true;
12669        for (NumberType i = 0; i < len; i++)
12670        {
12671            get();
12672            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
12673            {
12674                success = false;
12675                break;
12676            }
12677            result.push_back(static_cast<typename string_t::value_type>(current));
12678        }
12679        return success;
12680    }
12681
12682    /*!
12683    @brief create a byte array by reading bytes from the input
12684
12685    @tparam NumberType the type of the number
12686    @param[in] format the current format (for diagnostics)
12687    @param[in] len number of bytes to read
12688    @param[out] result byte array created by reading @a len bytes
12689
12690    @return whether byte array creation completed
12691
12692    @note We can not reserve @a len bytes for the result, because @a len
12693          may be too large. Usually, @ref unexpect_eof() detects the end of
12694          the input before we run out of memory.
12695    */
12696    template<typename NumberType>
12697    bool get_binary(const input_format_t format,
12698                    const NumberType len,
12699                    binary_t& result)
12700    {
12701        bool success = true;
12702        for (NumberType i = 0; i < len; i++)
12703        {
12704            get();
12705            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
12706            {
12707                success = false;
12708                break;
12709            }
12710            result.push_back(static_cast<std::uint8_t>(current));
12711        }
12712        return success;
12713    }
12714
12715    /*!
12716    @param[in] format   the current format (for diagnostics)
12717    @param[in] context  further context information (for diagnostics)
12718    @return whether the last read character is not EOF
12719    */
12720    JSON_HEDLEY_NON_NULL(3)
12721    bool unexpect_eof(const input_format_t format, const char* context) const
12722    {
12723        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
12724        {
12725            return sax->parse_error(chars_read, "<end of file>",
12726                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
12727        }
12728        return true;
12729    }
12730
12731    /*!
12732    @return a string representation of the last read byte
12733    */
12734    std::string get_token_string() const
12735    {
12736        std::array<char, 3> cr{{}};
12737        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
12738        return std::string{cr.data()};
12739    }
12740
12741    /*!
12742    @param[in] format   the current format
12743    @param[in] detail   a detailed error message
12744    @param[in] context  further context information
12745    @return a message string to use in the parse_error exceptions
12746    */
12747    std::string exception_message(const input_format_t format,
12748                                  const std::string& detail,
12749                                  const std::string& context) const
12750    {
12751        std::string error_msg = "syntax error while parsing ";
12752
12753        switch (format)
12754        {
12755            case input_format_t::cbor:
12756                error_msg += "CBOR";
12757                break;
12758
12759            case input_format_t::msgpack:
12760                error_msg += "MessagePack";
12761                break;
12762
12763            case input_format_t::ubjson:
12764                error_msg += "UBJSON";
12765                break;
12766
12767            case input_format_t::bson:
12768                error_msg += "BSON";
12769                break;
12770
12771            case input_format_t::bjdata:
12772                error_msg += "BJData";
12773                break;
12774
12775            case input_format_t::json: // LCOV_EXCL_LINE
12776            default:            // LCOV_EXCL_LINE
12777                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
12778        }
12779
12780        return concat(error_msg, ' ', context, ": ", detail);
12781    }
12782
12783  private:
12784    static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();
12785
12786    /// input adapter
12787    InputAdapterType ia;
12788
12789    /// the current character
12790    char_int_type current = char_traits<char_type>::eof();
12791
12792    /// the number of characters read
12793    std::size_t chars_read = 0;
12794
12795    /// whether we can assume little endianness
12796    const bool is_little_endian = little_endianness();
12797
12798    /// input format
12799    const input_format_t input_format = input_format_t::json;
12800
12801    /// the SAX parser
12802    json_sax_t* sax = nullptr;
12803
12804    // excluded markers in bjdata optimized type
12805#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
12806    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
12807
12808#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
12809    make_array<bjd_type>(                      \
12810    bjd_type{'B', "byte"},                     \
12811    bjd_type{'C', "char"},                     \
12812    bjd_type{'D', "double"},                   \
12813    bjd_type{'I', "int16"},                    \
12814    bjd_type{'L', "int64"},                    \
12815    bjd_type{'M', "uint64"},                   \
12816    bjd_type{'U', "uint8"},                    \
12817    bjd_type{'d', "single"},                   \
12818    bjd_type{'i', "int8"},                     \
12819    bjd_type{'l', "int32"},                    \
12820    bjd_type{'m', "uint32"},                   \
12821    bjd_type{'u', "uint16"})
12822
12823  JSON_PRIVATE_UNLESS_TESTED:
12824    // lookup tables
12825    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
12826    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
12827        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
12828
12829    using bjd_type = std::pair<char_int_type, string_t>;
12830    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
12831    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
12832        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
12833
12834#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
12835#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
12836};
12837
12838#ifndef JSON_HAS_CPP_17
12839    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
12840    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
12841#endif
12842
12843}  // namespace detail
12844NLOHMANN_JSON_NAMESPACE_END
12845
12846// #include <nlohmann/detail/input/input_adapters.hpp>
12847
12848// #include <nlohmann/detail/input/lexer.hpp>
12849
12850// #include <nlohmann/detail/input/parser.hpp>
12851//     __ _____ _____ _____
12852//  __|  |   __|     |   | |  JSON for Modern C++
12853// |  |  |__   |  |  | | | |  version 3.12.0
12854// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
12855//
12856// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
12857// SPDX-License-Identifier: MIT
12858
12859
12860
12861#include <cmath> // isfinite
12862#include <cstdint> // uint8_t
12863#include <functional> // function
12864#include <string> // string
12865#include <utility> // move
12866#include <vector> // vector
12867
12868// #include <nlohmann/detail/exceptions.hpp>
12869
12870// #include <nlohmann/detail/input/input_adapters.hpp>
12871
12872// #include <nlohmann/detail/input/json_sax.hpp>
12873
12874// #include <nlohmann/detail/input/lexer.hpp>
12875
12876// #include <nlohmann/detail/macro_scope.hpp>
12877
12878// #include <nlohmann/detail/meta/is_sax.hpp>
12879
12880// #include <nlohmann/detail/string_concat.hpp>
12881
12882// #include <nlohmann/detail/value_t.hpp>
12883
12884
12885NLOHMANN_JSON_NAMESPACE_BEGIN
12886namespace detail
12887{
12888////////////
12889// parser //
12890////////////
12891
12892enum class parse_event_t : std::uint8_t
12893{
12894    /// the parser read `{` and started to process a JSON object
12895    object_start,
12896    /// the parser read `}` and finished processing a JSON object
12897    object_end,
12898    /// the parser read `[` and started to process a JSON array
12899    array_start,
12900    /// the parser read `]` and finished processing a JSON array
12901    array_end,
12902    /// the parser read a key of a value in an object
12903    key,
12904    /// the parser finished reading a JSON value
12905    value
12906};
12907
12908template<typename BasicJsonType>
12909using parser_callback_t =
12910    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
12911
12912/*!
12913@brief syntax analysis
12914
12915This class implements a recursive descent parser.
12916*/
12917template<typename BasicJsonType, typename InputAdapterType>
12918class parser
12919{
12920    using number_integer_t = typename BasicJsonType::number_integer_t;
12921    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
12922    using number_float_t = typename BasicJsonType::number_float_t;
12923    using string_t = typename BasicJsonType::string_t;
12924    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
12925    using token_type = typename lexer_t::token_type;
12926
12927  public:
12928    /// a parser reading from an input adapter
12929    explicit parser(InputAdapterType&& adapter,
12930                    parser_callback_t<BasicJsonType> cb = nullptr,
12931                    const bool allow_exceptions_ = true,
12932                    const bool skip_comments = false)
12933        : callback(std::move(cb))
12934        , m_lexer(std::move(adapter), skip_comments)
12935        , allow_exceptions(allow_exceptions_)
12936    {
12937        // read first token
12938        get_token();
12939    }
12940
12941    /*!
12942    @brief public parser interface
12943
12944    @param[in] strict      whether to expect the last token to be EOF
12945    @param[in,out] result  parsed JSON value
12946
12947    @throw parse_error.101 in case of an unexpected token
12948    @throw parse_error.102 if to_unicode fails or surrogate error
12949    @throw parse_error.103 if to_unicode fails
12950    */
12951    void parse(const bool strict, BasicJsonType& result)
12952    {
12953        if (callback)
12954        {
12955            json_sax_dom_callback_parser<BasicJsonType, InputAdapterType> sdp(result, callback, allow_exceptions, &m_lexer);
12956            sax_parse_internal(&sdp);
12957
12958            // in strict mode, input must be completely read
12959            if (strict && (get_token() != token_type::end_of_input))
12960            {
12961                sdp.parse_error(m_lexer.get_position(),
12962                                m_lexer.get_token_string(),
12963                                parse_error::create(101, m_lexer.get_position(),
12964                                                    exception_message(token_type::end_of_input, "value"), nullptr));
12965            }
12966
12967            // in case of an error, return discarded value
12968            if (sdp.is_errored())
12969            {
12970                result = value_t::discarded;
12971                return;
12972            }
12973
12974            // set top-level value to null if it was discarded by the callback
12975            // function
12976            if (result.is_discarded())
12977            {
12978                result = nullptr;
12979            }
12980        }
12981        else
12982        {
12983            json_sax_dom_parser<BasicJsonType, InputAdapterType> sdp(result, allow_exceptions, &m_lexer);
12984            sax_parse_internal(&sdp);
12985
12986            // in strict mode, input must be completely read
12987            if (strict && (get_token() != token_type::end_of_input))
12988            {
12989                sdp.parse_error(m_lexer.get_position(),
12990                                m_lexer.get_token_string(),
12991                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
12992            }
12993
12994            // in case of an error, return discarded value
12995            if (sdp.is_errored())
12996            {
12997                result = value_t::discarded;
12998                return;
12999            }
13000        }
13001
13002        result.assert_invariant();
13003    }
13004
13005    /*!
13006    @brief public accept interface
13007
13008    @param[in] strict  whether to expect the last token to be EOF
13009    @return whether the input is a proper JSON text
13010    */
13011    bool accept(const bool strict = true)
13012    {
13013        json_sax_acceptor<BasicJsonType> sax_acceptor;
13014        return sax_parse(&sax_acceptor, strict);
13015    }
13016
13017    template<typename SAX>
13018    JSON_HEDLEY_NON_NULL(2)
13019    bool sax_parse(SAX* sax, const bool strict = true)
13020    {
13021        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
13022        const bool result = sax_parse_internal(sax);
13023
13024        // strict mode: next byte must be EOF
13025        if (result && strict && (get_token() != token_type::end_of_input))
13026        {
13027            return sax->parse_error(m_lexer.get_position(),
13028                                    m_lexer.get_token_string(),
13029                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
13030        }
13031
13032        return result;
13033    }
13034
13035  private:
13036    template<typename SAX>
13037    JSON_HEDLEY_NON_NULL(2)
13038    bool sax_parse_internal(SAX* sax)
13039    {
13040        // stack to remember the hierarchy of structured values we are parsing
13041        // true = array; false = object
13042        std::vector<bool> states;
13043        // value to avoid a goto (see comment where set to true)
13044        bool skip_to_state_evaluation = false;
13045
13046        while (true)
13047        {
13048            if (!skip_to_state_evaluation)
13049            {
13050                // invariant: get_token() was called before each iteration
13051                switch (last_token)
13052                {
13053                    case token_type::begin_object:
13054                    {
13055                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
13056                        {
13057                            return false;
13058                        }
13059
13060                        // closing } -> we are done
13061                        if (get_token() == token_type::end_object)
13062                        {
13063                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
13064                            {
13065                                return false;
13066                            }
13067                            break;
13068                        }
13069
13070                        // parse key
13071                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
13072                        {
13073                            return sax->parse_error(m_lexer.get_position(),
13074                                                    m_lexer.get_token_string(),
13075                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
13076                        }
13077                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
13078                        {
13079                            return false;
13080                        }
13081
13082                        // parse separator (:)
13083                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
13084                        {
13085                            return sax->parse_error(m_lexer.get_position(),
13086                                                    m_lexer.get_token_string(),
13087                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
13088                        }
13089
13090                        // remember we are now inside an object
13091                        states.push_back(false);
13092
13093                        // parse values
13094                        get_token();
13095                        continue;
13096                    }
13097
13098                    case token_type::begin_array:
13099                    {
13100                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
13101                        {
13102                            return false;
13103                        }
13104
13105                        // closing ] -> we are done
13106                        if (get_token() == token_type::end_array)
13107                        {
13108                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
13109                            {
13110                                return false;
13111                            }
13112                            break;
13113                        }
13114
13115                        // remember we are now inside an array
13116                        states.push_back(true);
13117
13118                        // parse values (no need to call get_token)
13119                        continue;
13120                    }
13121
13122                    case token_type::value_float:
13123                    {
13124                        const auto res = m_lexer.get_number_float();
13125
13126                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
13127                        {
13128                            return sax->parse_error(m_lexer.get_position(),
13129                                                    m_lexer.get_token_string(),
13130                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
13131                        }
13132
13133                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
13134                        {
13135                            return false;
13136                        }
13137
13138                        break;
13139                    }
13140
13141                    case token_type::literal_false:
13142                    {
13143                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
13144                        {
13145                            return false;
13146                        }
13147                        break;
13148                    }
13149
13150                    case token_type::literal_null:
13151                    {
13152                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
13153                        {
13154                            return false;
13155                        }
13156                        break;
13157                    }
13158
13159                    case token_type::literal_true:
13160                    {
13161                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
13162                        {
13163                            return false;
13164                        }
13165                        break;
13166                    }
13167
13168                    case token_type::value_integer:
13169                    {
13170                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
13171                        {
13172                            return false;
13173                        }
13174                        break;
13175                    }
13176
13177                    case token_type::value_string:
13178                    {
13179                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
13180                        {
13181                            return false;
13182                        }
13183                        break;
13184                    }
13185
13186                    case token_type::value_unsigned:
13187                    {
13188                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
13189                        {
13190                            return false;
13191                        }
13192                        break;
13193                    }
13194
13195                    case token_type::parse_error:
13196                    {
13197                        // using "uninitialized" to avoid "expected" message
13198                        return sax->parse_error(m_lexer.get_position(),
13199                                                m_lexer.get_token_string(),
13200                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
13201                    }
13202                    case token_type::end_of_input:
13203                    {
13204                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
13205                        {
13206                            return sax->parse_error(m_lexer.get_position(),
13207                                                    m_lexer.get_token_string(),
13208                                                    parse_error::create(101, m_lexer.get_position(),
13209                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
13210                        }
13211
13212                        return sax->parse_error(m_lexer.get_position(),
13213                                                m_lexer.get_token_string(),
13214                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
13215                    }
13216                    case token_type::uninitialized:
13217                    case token_type::end_array:
13218                    case token_type::end_object:
13219                    case token_type::name_separator:
13220                    case token_type::value_separator:
13221                    case token_type::literal_or_value:
13222                    default: // the last token was unexpected
13223                    {
13224                        return sax->parse_error(m_lexer.get_position(),
13225                                                m_lexer.get_token_string(),
13226                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
13227                    }
13228                }
13229            }
13230            else
13231            {
13232                skip_to_state_evaluation = false;
13233            }
13234
13235            // we reached this line after we successfully parsed a value
13236            if (states.empty())
13237            {
13238                // empty stack: we reached the end of the hierarchy: done
13239                return true;
13240            }
13241
13242            if (states.back())  // array
13243            {
13244                // comma -> next value
13245                if (get_token() == token_type::value_separator)
13246                {
13247                    // parse a new value
13248                    get_token();
13249                    continue;
13250                }
13251
13252                // closing ]
13253                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
13254                {
13255                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
13256                    {
13257                        return false;
13258                    }
13259
13260                    // We are done with this array. Before we can parse a
13261                    // new value, we need to evaluate the new state first.
13262                    // By setting skip_to_state_evaluation to false, we
13263                    // are effectively jumping to the beginning of this if.
13264                    JSON_ASSERT(!states.empty());
13265                    states.pop_back();
13266                    skip_to_state_evaluation = true;
13267                    continue;
13268                }
13269
13270                return sax->parse_error(m_lexer.get_position(),
13271                                        m_lexer.get_token_string(),
13272                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
13273            }
13274
13275            // states.back() is false -> object
13276
13277            // comma -> next value
13278            if (get_token() == token_type::value_separator)
13279            {
13280                // parse key
13281                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
13282                {
13283                    return sax->parse_error(m_lexer.get_position(),
13284                                            m_lexer.get_token_string(),
13285                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
13286                }
13287
13288                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
13289                {
13290                    return false;
13291                }
13292
13293                // parse separator (:)
13294                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
13295                {
13296                    return sax->parse_error(m_lexer.get_position(),
13297                                            m_lexer.get_token_string(),
13298                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
13299                }
13300
13301                // parse values
13302                get_token();
13303                continue;
13304            }
13305
13306            // closing }
13307            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
13308            {
13309                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
13310                {
13311                    return false;
13312                }
13313
13314                // We are done with this object. Before we can parse a
13315                // new value, we need to evaluate the new state first.
13316                // By setting skip_to_state_evaluation to false, we
13317                // are effectively jumping to the beginning of this if.
13318                JSON_ASSERT(!states.empty());
13319                states.pop_back();
13320                skip_to_state_evaluation = true;
13321                continue;
13322            }
13323
13324            return sax->parse_error(m_lexer.get_position(),
13325                                    m_lexer.get_token_string(),
13326                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
13327        }
13328    }
13329
13330    /// get next token from lexer
13331    token_type get_token()
13332    {
13333        return last_token = m_lexer.scan();
13334    }
13335
13336    std::string exception_message(const token_type expected, const std::string& context)
13337    {
13338        std::string error_msg = "syntax error ";
13339
13340        if (!context.empty())
13341        {
13342            error_msg += concat("while parsing ", context, ' ');
13343        }
13344
13345        error_msg += "- ";
13346
13347        if (last_token == token_type::parse_error)
13348        {
13349            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
13350                                m_lexer.get_token_string(), '\'');
13351        }
13352        else
13353        {
13354            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
13355        }
13356
13357        if (expected != token_type::uninitialized)
13358        {
13359            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
13360        }
13361
13362        return error_msg;
13363    }
13364
13365  private:
13366    /// callback function
13367    const parser_callback_t<BasicJsonType> callback = nullptr;
13368    /// the type of the last read token
13369    token_type last_token = token_type::uninitialized;
13370    /// the lexer
13371    lexer_t m_lexer;
13372    /// whether to throw exceptions in case of errors
13373    const bool allow_exceptions = true;
13374};
13375
13376}  // namespace detail
13377NLOHMANN_JSON_NAMESPACE_END
13378
13379// #include <nlohmann/detail/iterators/internal_iterator.hpp>
13380//     __ _____ _____ _____
13381//  __|  |   __|     |   | |  JSON for Modern C++
13382// |  |  |__   |  |  | | | |  version 3.12.0
13383// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
13384//
13385// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
13386// SPDX-License-Identifier: MIT
13387
13388
13389
13390// #include <nlohmann/detail/abi_macros.hpp>
13391
13392// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
13393//     __ _____ _____ _____
13394//  __|  |   __|     |   | |  JSON for Modern C++
13395// |  |  |__   |  |  | | | |  version 3.12.0
13396// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
13397//
13398// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
13399// SPDX-License-Identifier: MIT
13400
13401
13402
13403#include <cstddef> // ptrdiff_t
13404#include <limits>  // numeric_limits
13405
13406// #include <nlohmann/detail/macro_scope.hpp>
13407
13408
13409NLOHMANN_JSON_NAMESPACE_BEGIN
13410namespace detail
13411{
13412
13413/*
13414@brief an iterator for primitive JSON types
13415
13416This class models an iterator for primitive JSON types (boolean, number,
13417string). It's only purpose is to allow the iterator/const_iterator classes
13418to "iterate" over primitive values. Internally, the iterator is modeled by
13419a `difference_type` variable. Value begin_value (`0`) models the begin,
13420end_value (`1`) models past the end.
13421*/
13422class primitive_iterator_t
13423{
13424  private:
13425    using difference_type = std::ptrdiff_t;
13426    static constexpr difference_type begin_value = 0;
13427    static constexpr difference_type end_value = begin_value + 1;
13428
13429  JSON_PRIVATE_UNLESS_TESTED:
13430    /// iterator as signed integer type
13431    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
13432
13433  public:
13434    constexpr difference_type get_value() const noexcept
13435    {
13436        return m_it;
13437    }
13438
13439    /// set iterator to a defined beginning
13440    void set_begin() noexcept
13441    {
13442        m_it = begin_value;
13443    }
13444
13445    /// set iterator to a defined past the end
13446    void set_end() noexcept
13447    {
13448        m_it = end_value;
13449    }
13450
13451    /// return whether the iterator can be dereferenced
13452    constexpr bool is_begin() const noexcept
13453    {
13454        return m_it == begin_value;
13455    }
13456
13457    /// return whether the iterator is at end
13458    constexpr bool is_end() const noexcept
13459    {
13460        return m_it == end_value;
13461    }
13462
13463    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
13464    {
13465        return lhs.m_it == rhs.m_it;
13466    }
13467
13468    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
13469    {
13470        return lhs.m_it < rhs.m_it;
13471    }
13472
13473    primitive_iterator_t operator+(difference_type n) noexcept
13474    {
13475        auto result = *this;
13476        result += n;
13477        return result;
13478    }
13479
13480    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
13481    {
13482        return lhs.m_it - rhs.m_it;
13483    }
13484
13485    primitive_iterator_t& operator++() noexcept
13486    {
13487        ++m_it;
13488        return *this;
13489    }
13490
13491    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
13492    {
13493        auto result = *this;
13494        ++m_it;
13495        return result;
13496    }
13497
13498    primitive_iterator_t& operator--() noexcept
13499    {
13500        --m_it;
13501        return *this;
13502    }
13503
13504    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
13505    {
13506        auto result = *this;
13507        --m_it;
13508        return result;
13509    }
13510
13511    primitive_iterator_t& operator+=(difference_type n) noexcept
13512    {
13513        m_it += n;
13514        return *this;
13515    }
13516
13517    primitive_iterator_t& operator-=(difference_type n) noexcept
13518    {
13519        m_it -= n;
13520        return *this;
13521    }
13522};
13523
13524}  // namespace detail
13525NLOHMANN_JSON_NAMESPACE_END
13526
13527
13528NLOHMANN_JSON_NAMESPACE_BEGIN
13529namespace detail
13530{
13531
13532/*!
13533@brief an iterator value
13534
13535@note This structure could easily be a union, but MSVC currently does not allow
13536unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
13537*/
13538template<typename BasicJsonType> struct internal_iterator
13539{
13540    /// iterator for JSON objects
13541    typename BasicJsonType::object_t::iterator object_iterator {};
13542    /// iterator for JSON arrays
13543    typename BasicJsonType::array_t::iterator array_iterator {};
13544    /// generic iterator for all other types
13545    primitive_iterator_t primitive_iterator {};
13546};
13547
13548}  // namespace detail
13549NLOHMANN_JSON_NAMESPACE_END
13550
13551// #include <nlohmann/detail/iterators/iter_impl.hpp>
13552//     __ _____ _____ _____
13553//  __|  |   __|     |   | |  JSON for Modern C++
13554// |  |  |__   |  |  | | | |  version 3.12.0
13555// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
13556//
13557// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
13558// SPDX-License-Identifier: MIT
13559
13560
13561
13562#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
13563#include <type_traits> // conditional, is_const, remove_const
13564
13565// #include <nlohmann/detail/exceptions.hpp>
13566
13567// #include <nlohmann/detail/iterators/internal_iterator.hpp>
13568
13569// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
13570
13571// #include <nlohmann/detail/macro_scope.hpp>
13572
13573// #include <nlohmann/detail/meta/cpp_future.hpp>
13574
13575// #include <nlohmann/detail/meta/type_traits.hpp>
13576
13577// #include <nlohmann/detail/value_t.hpp>
13578
13579
13580NLOHMANN_JSON_NAMESPACE_BEGIN
13581namespace detail
13582{
13583
13584// forward declare, to be able to friend it later on
13585template<typename IteratorType> class iteration_proxy;
13586template<typename IteratorType> class iteration_proxy_value;
13587
13588/*!
13589@brief a template for a bidirectional iterator for the @ref basic_json class
13590This class implements a both iterators (iterator and const_iterator) for the
13591@ref basic_json class.
13592@note An iterator is called *initialized* when a pointer to a JSON value has
13593      been set (e.g., by a constructor or a copy assignment). If the iterator is
13594      default-constructed, it is *uninitialized* and most methods are undefined.
13595      **The library uses assertions to detect calls on uninitialized iterators.**
13596@requirement The class satisfies the following concept requirements:
13597-
13598[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
13599  The iterator that can be moved can be moved in both directions (i.e.
13600  incremented and decremented).
13601@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
13602       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
13603*/
13604template<typename BasicJsonType>
13605class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
13606{
13607    /// the iterator with BasicJsonType of different const-ness
13608    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
13609    /// allow basic_json to access private members
13610    friend other_iter_impl;
13611    friend BasicJsonType;
13612    friend iteration_proxy<iter_impl>;
13613    friend iteration_proxy_value<iter_impl>;
13614
13615    using object_t = typename BasicJsonType::object_t;
13616    using array_t = typename BasicJsonType::array_t;
13617    // make sure BasicJsonType is basic_json or const basic_json
13618    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
13619                  "iter_impl only accepts (const) basic_json");
13620    // superficial check for the LegacyBidirectionalIterator named requirement
13621    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
13622                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
13623                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
13624
13625  public:
13626    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
13627    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
13628    /// A user-defined iterator should provide publicly accessible typedefs named
13629    /// iterator_category, value_type, difference_type, pointer, and reference.
13630    /// Note that value_type is required to be non-const, even for constant iterators.
13631    using iterator_category = std::bidirectional_iterator_tag;
13632
13633    /// the type of the values when the iterator is dereferenced
13634    using value_type = typename BasicJsonType::value_type;
13635    /// a type to represent differences between iterators
13636    using difference_type = typename BasicJsonType::difference_type;
13637    /// defines a pointer to the type iterated over (value_type)
13638    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
13639          typename BasicJsonType::const_pointer,
13640          typename BasicJsonType::pointer>::type;
13641    /// defines a reference to the type iterated over (value_type)
13642    using reference =
13643        typename std::conditional<std::is_const<BasicJsonType>::value,
13644        typename BasicJsonType::const_reference,
13645        typename BasicJsonType::reference>::type;
13646
13647    iter_impl() = default;
13648    ~iter_impl() = default;
13649    iter_impl(iter_impl&&) noexcept = default;
13650    iter_impl& operator=(iter_impl&&) noexcept = default;
13651
13652    /*!
13653    @brief constructor for a given JSON instance
13654    @param[in] object  pointer to a JSON object for this iterator
13655    @pre object != nullptr
13656    @post The iterator is initialized; i.e. `m_object != nullptr`.
13657    */
13658    explicit iter_impl(pointer object) noexcept : m_object(object)
13659    {
13660        JSON_ASSERT(m_object != nullptr);
13661
13662        switch (m_object->m_data.m_type)
13663        {
13664            case value_t::object:
13665            {
13666                m_it.object_iterator = typename object_t::iterator();
13667                break;
13668            }
13669
13670            case value_t::array:
13671            {
13672                m_it.array_iterator = typename array_t::iterator();
13673                break;
13674            }
13675
13676            case value_t::null:
13677            case value_t::string:
13678            case value_t::boolean:
13679            case value_t::number_integer:
13680            case value_t::number_unsigned:
13681            case value_t::number_float:
13682            case value_t::binary:
13683            case value_t::discarded:
13684            default:
13685            {
13686                m_it.primitive_iterator = primitive_iterator_t();
13687                break;
13688            }
13689        }
13690    }
13691
13692    /*!
13693    @note The conventional copy constructor and copy assignment are implicitly
13694          defined. Combined with the following converting constructor and
13695          assignment, they support: (1) copy from iterator to iterator, (2)
13696          copy from const iterator to const iterator, and (3) conversion from
13697          iterator to const iterator. However conversion from const iterator
13698          to iterator is not defined.
13699    */
13700
13701    /*!
13702    @brief const copy constructor
13703    @param[in] other const iterator to copy from
13704    @note This copy constructor had to be defined explicitly to circumvent a bug
13705          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
13706          information refer to: https://github.com/nlohmann/json/issues/1608
13707    */
13708    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
13709        : m_object(other.m_object), m_it(other.m_it)
13710    {}
13711
13712    /*!
13713    @brief converting assignment
13714    @param[in] other const iterator to copy from
13715    @return const/non-const iterator
13716    @note It is not checked whether @a other is initialized.
13717    */
13718    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
13719    {
13720        if (&other != this)
13721        {
13722            m_object = other.m_object;
13723            m_it = other.m_it;
13724        }
13725        return *this;
13726    }
13727
13728    /*!
13729    @brief converting constructor
13730    @param[in] other  non-const iterator to copy from
13731    @note It is not checked whether @a other is initialized.
13732    */
13733    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
13734        : m_object(other.m_object), m_it(other.m_it)
13735    {}
13736
13737    /*!
13738    @brief converting assignment
13739    @param[in] other  non-const iterator to copy from
13740    @return const/non-const iterator
13741    @note It is not checked whether @a other is initialized.
13742    */
13743    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
13744    {
13745        m_object = other.m_object;
13746        m_it = other.m_it;
13747        return *this;
13748    }
13749
13750  JSON_PRIVATE_UNLESS_TESTED:
13751    /*!
13752    @brief set the iterator to the first value
13753    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13754    */
13755    void set_begin() noexcept
13756    {
13757        JSON_ASSERT(m_object != nullptr);
13758
13759        switch (m_object->m_data.m_type)
13760        {
13761            case value_t::object:
13762            {
13763                m_it.object_iterator = m_object->m_data.m_value.object->begin();
13764                break;
13765            }
13766
13767            case value_t::array:
13768            {
13769                m_it.array_iterator = m_object->m_data.m_value.array->begin();
13770                break;
13771            }
13772
13773            case value_t::null:
13774            {
13775                // set to end so begin()==end() is true: null is empty
13776                m_it.primitive_iterator.set_end();
13777                break;
13778            }
13779
13780            case value_t::string:
13781            case value_t::boolean:
13782            case value_t::number_integer:
13783            case value_t::number_unsigned:
13784            case value_t::number_float:
13785            case value_t::binary:
13786            case value_t::discarded:
13787            default:
13788            {
13789                m_it.primitive_iterator.set_begin();
13790                break;
13791            }
13792        }
13793    }
13794
13795    /*!
13796    @brief set the iterator past the last value
13797    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13798    */
13799    void set_end() noexcept
13800    {
13801        JSON_ASSERT(m_object != nullptr);
13802
13803        switch (m_object->m_data.m_type)
13804        {
13805            case value_t::object:
13806            {
13807                m_it.object_iterator = m_object->m_data.m_value.object->end();
13808                break;
13809            }
13810
13811            case value_t::array:
13812            {
13813                m_it.array_iterator = m_object->m_data.m_value.array->end();
13814                break;
13815            }
13816
13817            case value_t::null:
13818            case value_t::string:
13819            case value_t::boolean:
13820            case value_t::number_integer:
13821            case value_t::number_unsigned:
13822            case value_t::number_float:
13823            case value_t::binary:
13824            case value_t::discarded:
13825            default:
13826            {
13827                m_it.primitive_iterator.set_end();
13828                break;
13829            }
13830        }
13831    }
13832
13833  public:
13834    /*!
13835    @brief return a reference to the value pointed to by the iterator
13836    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13837    */
13838    reference operator*() const
13839    {
13840        JSON_ASSERT(m_object != nullptr);
13841
13842        switch (m_object->m_data.m_type)
13843        {
13844            case value_t::object:
13845            {
13846                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
13847                return m_it.object_iterator->second;
13848            }
13849
13850            case value_t::array:
13851            {
13852                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
13853                return *m_it.array_iterator;
13854            }
13855
13856            case value_t::null:
13857                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13858
13859            case value_t::string:
13860            case value_t::boolean:
13861            case value_t::number_integer:
13862            case value_t::number_unsigned:
13863            case value_t::number_float:
13864            case value_t::binary:
13865            case value_t::discarded:
13866            default:
13867            {
13868                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
13869                {
13870                    return *m_object;
13871                }
13872
13873                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13874            }
13875        }
13876    }
13877
13878    /*!
13879    @brief dereference the iterator
13880    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13881    */
13882    pointer operator->() const
13883    {
13884        JSON_ASSERT(m_object != nullptr);
13885
13886        switch (m_object->m_data.m_type)
13887        {
13888            case value_t::object:
13889            {
13890                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
13891                return &(m_it.object_iterator->second);
13892            }
13893
13894            case value_t::array:
13895            {
13896                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
13897                return &*m_it.array_iterator;
13898            }
13899
13900            case value_t::null:
13901            case value_t::string:
13902            case value_t::boolean:
13903            case value_t::number_integer:
13904            case value_t::number_unsigned:
13905            case value_t::number_float:
13906            case value_t::binary:
13907            case value_t::discarded:
13908            default:
13909            {
13910                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
13911                {
13912                    return m_object;
13913                }
13914
13915                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
13916            }
13917        }
13918    }
13919
13920    /*!
13921    @brief post-increment (it++)
13922    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13923    */
13924    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
13925    {
13926        auto result = *this;
13927        ++(*this);
13928        return result;
13929    }
13930
13931    /*!
13932    @brief pre-increment (++it)
13933    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13934    */
13935    iter_impl& operator++()
13936    {
13937        JSON_ASSERT(m_object != nullptr);
13938
13939        switch (m_object->m_data.m_type)
13940        {
13941            case value_t::object:
13942            {
13943                std::advance(m_it.object_iterator, 1);
13944                break;
13945            }
13946
13947            case value_t::array:
13948            {
13949                std::advance(m_it.array_iterator, 1);
13950                break;
13951            }
13952
13953            case value_t::null:
13954            case value_t::string:
13955            case value_t::boolean:
13956            case value_t::number_integer:
13957            case value_t::number_unsigned:
13958            case value_t::number_float:
13959            case value_t::binary:
13960            case value_t::discarded:
13961            default:
13962            {
13963                ++m_it.primitive_iterator;
13964                break;
13965            }
13966        }
13967
13968        return *this;
13969    }
13970
13971    /*!
13972    @brief post-decrement (it--)
13973    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13974    */
13975    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
13976    {
13977        auto result = *this;
13978        --(*this);
13979        return result;
13980    }
13981
13982    /*!
13983    @brief pre-decrement (--it)
13984    @pre The iterator is initialized; i.e. `m_object != nullptr`.
13985    */
13986    iter_impl& operator--()
13987    {
13988        JSON_ASSERT(m_object != nullptr);
13989
13990        switch (m_object->m_data.m_type)
13991        {
13992            case value_t::object:
13993            {
13994                std::advance(m_it.object_iterator, -1);
13995                break;
13996            }
13997
13998            case value_t::array:
13999            {
14000                std::advance(m_it.array_iterator, -1);
14001                break;
14002            }
14003
14004            case value_t::null:
14005            case value_t::string:
14006            case value_t::boolean:
14007            case value_t::number_integer:
14008            case value_t::number_unsigned:
14009            case value_t::number_float:
14010            case value_t::binary:
14011            case value_t::discarded:
14012            default:
14013            {
14014                --m_it.primitive_iterator;
14015                break;
14016            }
14017        }
14018
14019        return *this;
14020    }
14021
14022    /*!
14023    @brief comparison: equal
14024    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
14025    */
14026    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 >
14027    bool operator==(const IterImpl& other) const
14028    {
14029        // if objects are not the same, the comparison is undefined
14030        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
14031        {
14032            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
14033        }
14034
14035        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
14036        if (m_object == nullptr)
14037        {
14038            return true;
14039        }
14040
14041        switch (m_object->m_data.m_type)
14042        {
14043            case value_t::object:
14044                return (m_it.object_iterator == other.m_it.object_iterator);
14045
14046            case value_t::array:
14047                return (m_it.array_iterator == other.m_it.array_iterator);
14048
14049            case value_t::null:
14050            case value_t::string:
14051            case value_t::boolean:
14052            case value_t::number_integer:
14053            case value_t::number_unsigned:
14054            case value_t::number_float:
14055            case value_t::binary:
14056            case value_t::discarded:
14057            default:
14058                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
14059        }
14060    }
14061
14062    /*!
14063    @brief comparison: not equal
14064    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
14065    */
14066    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 >
14067    bool operator!=(const IterImpl& other) const
14068    {
14069        return !operator==(other);
14070    }
14071
14072    /*!
14073    @brief comparison: smaller
14074    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
14075    */
14076    bool operator<(const iter_impl& other) const
14077    {
14078        // if objects are not the same, the comparison is undefined
14079        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
14080        {
14081            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
14082        }
14083
14084        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
14085        if (m_object == nullptr)
14086        {
14087            // the iterators are both value-initialized and are to be considered equal, but this function checks for smaller, so we return false
14088            return false;
14089        }
14090
14091        switch (m_object->m_data.m_type)
14092        {
14093            case value_t::object:
14094                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
14095
14096            case value_t::array:
14097                return (m_it.array_iterator < other.m_it.array_iterator);
14098
14099            case value_t::null:
14100            case value_t::string:
14101            case value_t::boolean:
14102            case value_t::number_integer:
14103            case value_t::number_unsigned:
14104            case value_t::number_float:
14105            case value_t::binary:
14106            case value_t::discarded:
14107            default:
14108                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
14109        }
14110    }
14111
14112    /*!
14113    @brief comparison: less than or equal
14114    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
14115    */
14116    bool operator<=(const iter_impl& other) const
14117    {
14118        return !other.operator < (*this);
14119    }
14120
14121    /*!
14122    @brief comparison: greater than
14123    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
14124    */
14125    bool operator>(const iter_impl& other) const
14126    {
14127        return !operator<=(other);
14128    }
14129
14130    /*!
14131    @brief comparison: greater than or equal
14132    @pre (1) The iterator is initialized; i.e. `m_object != nullptr`, or (2) both iterators are value-initialized.
14133    */
14134    bool operator>=(const iter_impl& other) const
14135    {
14136        return !operator<(other);
14137    }
14138
14139    /*!
14140    @brief add to iterator
14141    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14142    */
14143    iter_impl& operator+=(difference_type i)
14144    {
14145        JSON_ASSERT(m_object != nullptr);
14146
14147        switch (m_object->m_data.m_type)
14148        {
14149            case value_t::object:
14150                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
14151
14152            case value_t::array:
14153            {
14154                std::advance(m_it.array_iterator, i);
14155                break;
14156            }
14157
14158            case value_t::null:
14159            case value_t::string:
14160            case value_t::boolean:
14161            case value_t::number_integer:
14162            case value_t::number_unsigned:
14163            case value_t::number_float:
14164            case value_t::binary:
14165            case value_t::discarded:
14166            default:
14167            {
14168                m_it.primitive_iterator += i;
14169                break;
14170            }
14171        }
14172
14173        return *this;
14174    }
14175
14176    /*!
14177    @brief subtract from iterator
14178    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14179    */
14180    iter_impl& operator-=(difference_type i)
14181    {
14182        return operator+=(-i);
14183    }
14184
14185    /*!
14186    @brief add to iterator
14187    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14188    */
14189    iter_impl operator+(difference_type i) const
14190    {
14191        auto result = *this;
14192        result += i;
14193        return result;
14194    }
14195
14196    /*!
14197    @brief addition of distance and iterator
14198    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14199    */
14200    friend iter_impl operator+(difference_type i, const iter_impl& it)
14201    {
14202        auto result = it;
14203        result += i;
14204        return result;
14205    }
14206
14207    /*!
14208    @brief subtract from iterator
14209    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14210    */
14211    iter_impl operator-(difference_type i) const
14212    {
14213        auto result = *this;
14214        result -= i;
14215        return result;
14216    }
14217
14218    /*!
14219    @brief return difference
14220    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14221    */
14222    difference_type operator-(const iter_impl& other) const
14223    {
14224        JSON_ASSERT(m_object != nullptr);
14225
14226        switch (m_object->m_data.m_type)
14227        {
14228            case value_t::object:
14229                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
14230
14231            case value_t::array:
14232                return m_it.array_iterator - other.m_it.array_iterator;
14233
14234            case value_t::null:
14235            case value_t::string:
14236            case value_t::boolean:
14237            case value_t::number_integer:
14238            case value_t::number_unsigned:
14239            case value_t::number_float:
14240            case value_t::binary:
14241            case value_t::discarded:
14242            default:
14243                return m_it.primitive_iterator - other.m_it.primitive_iterator;
14244        }
14245    }
14246
14247    /*!
14248    @brief access to successor
14249    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14250    */
14251    reference operator[](difference_type n) const
14252    {
14253        JSON_ASSERT(m_object != nullptr);
14254
14255        switch (m_object->m_data.m_type)
14256        {
14257            case value_t::object:
14258                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
14259
14260            case value_t::array:
14261                return *std::next(m_it.array_iterator, n);
14262
14263            case value_t::null:
14264                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
14265
14266            case value_t::string:
14267            case value_t::boolean:
14268            case value_t::number_integer:
14269            case value_t::number_unsigned:
14270            case value_t::number_float:
14271            case value_t::binary:
14272            case value_t::discarded:
14273            default:
14274            {
14275                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
14276                {
14277                    return *m_object;
14278                }
14279
14280                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
14281            }
14282        }
14283    }
14284
14285    /*!
14286    @brief return the key of an object iterator
14287    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14288    */
14289    const typename object_t::key_type& key() const
14290    {
14291        JSON_ASSERT(m_object != nullptr);
14292
14293        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
14294        {
14295            return m_it.object_iterator->first;
14296        }
14297
14298        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
14299    }
14300
14301    /*!
14302    @brief return the value of an iterator
14303    @pre The iterator is initialized; i.e. `m_object != nullptr`.
14304    */
14305    reference value() const
14306    {
14307        return operator*();
14308    }
14309
14310  JSON_PRIVATE_UNLESS_TESTED:
14311    /// associated JSON instance
14312    pointer m_object = nullptr;
14313    /// the actual iterator of the associated instance
14314    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
14315};
14316
14317}  // namespace detail
14318NLOHMANN_JSON_NAMESPACE_END
14319
14320// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
14321
14322// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
14323//     __ _____ _____ _____
14324//  __|  |   __|     |   | |  JSON for Modern C++
14325// |  |  |__   |  |  | | | |  version 3.12.0
14326// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
14327//
14328// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
14329// SPDX-License-Identifier: MIT
14330
14331
14332
14333#include <cstddef> // ptrdiff_t
14334#include <iterator> // reverse_iterator
14335#include <utility> // declval
14336
14337// #include <nlohmann/detail/abi_macros.hpp>
14338
14339
14340NLOHMANN_JSON_NAMESPACE_BEGIN
14341namespace detail
14342{
14343
14344//////////////////////
14345// reverse_iterator //
14346//////////////////////
14347
14348/*!
14349@brief a template for a reverse iterator class
14350
14351@tparam Base the base iterator type to reverse. Valid types are @ref
14352iterator (to create @ref reverse_iterator) and @ref const_iterator (to
14353create @ref const_reverse_iterator).
14354
14355@requirement The class satisfies the following concept requirements:
14356-
14357[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
14358  The iterator that can be moved can be moved in both directions (i.e.
14359  incremented and decremented).
14360- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
14361  It is possible to write to the pointed-to element (only if @a Base is
14362  @ref iterator).
14363
14364@since version 1.0.0
14365*/
14366template<typename Base>
14367class json_reverse_iterator : public std::reverse_iterator<Base>
14368{
14369  public:
14370    using difference_type = std::ptrdiff_t;
14371    /// shortcut to the reverse iterator adapter
14372    using base_iterator = std::reverse_iterator<Base>;
14373    /// the reference type for the pointed-to element
14374    using reference = typename Base::reference;
14375
14376    /// create reverse iterator from iterator
14377    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
14378        : base_iterator(it) {}
14379
14380    /// create reverse iterator from base class
14381    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
14382
14383    /// post-increment (it++)
14384    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
14385    {
14386        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
14387    }
14388
14389    /// pre-increment (++it)
14390    json_reverse_iterator& operator++()
14391    {
14392        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
14393    }
14394
14395    /// post-decrement (it--)
14396    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
14397    {
14398        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
14399    }
14400
14401    /// pre-decrement (--it)
14402    json_reverse_iterator& operator--()
14403    {
14404        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
14405    }
14406
14407    /// add to iterator
14408    json_reverse_iterator& operator+=(difference_type i)
14409    {
14410        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
14411    }
14412
14413    /// add to iterator
14414    json_reverse_iterator operator+(difference_type i) const
14415    {
14416        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
14417    }
14418
14419    /// subtract from iterator
14420    json_reverse_iterator operator-(difference_type i) const
14421    {
14422        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
14423    }
14424
14425    /// return difference
14426    difference_type operator-(const json_reverse_iterator& other) const
14427    {
14428        return base_iterator(*this) - base_iterator(other);
14429    }
14430
14431    /// access to successor
14432    reference operator[](difference_type n) const
14433    {
14434        return *(this->operator+(n));
14435    }
14436
14437    /// return the key of an object iterator
14438    auto key() const -> decltype(std::declval<Base>().key())
14439    {
14440        auto it = --this->base();
14441        return it.key();
14442    }
14443
14444    /// return the value of an iterator
14445    reference value() const
14446    {
14447        auto it = --this->base();
14448        return it.operator * ();
14449    }
14450};
14451
14452}  // namespace detail
14453NLOHMANN_JSON_NAMESPACE_END
14454
14455// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
14456
14457// #include <nlohmann/detail/json_custom_base_class.hpp>
14458//     __ _____ _____ _____
14459//  __|  |   __|     |   | |  JSON for Modern C++
14460// |  |  |__   |  |  | | | |  version 3.12.0
14461// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
14462//
14463// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
14464// SPDX-License-Identifier: MIT
14465
14466
14467
14468#include <type_traits> // conditional, is_same
14469
14470// #include <nlohmann/detail/abi_macros.hpp>
14471
14472
14473NLOHMANN_JSON_NAMESPACE_BEGIN
14474namespace detail
14475{
14476
14477/*!
14478@brief Default base class of the @ref basic_json class.
14479
14480So that the correct implementations of the copy / move ctors / assign operators
14481of @ref basic_json do not require complex case distinctions
14482(no base class / custom base class used as customization point),
14483@ref basic_json always has a base class.
14484By default, this class is used because it is empty and thus has no effect
14485on the behavior of @ref basic_json.
14486*/
14487struct json_default_base {};
14488
14489template<class T>
14490using json_base_class = typename std::conditional <
14491                        std::is_same<T, void>::value,
14492                        json_default_base,
14493                        T
14494                        >::type;
14495
14496}  // namespace detail
14497NLOHMANN_JSON_NAMESPACE_END
14498
14499// #include <nlohmann/detail/json_pointer.hpp>
14500//     __ _____ _____ _____
14501//  __|  |   __|     |   | |  JSON for Modern C++
14502// |  |  |__   |  |  | | | |  version 3.12.0
14503// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
14504//
14505// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
14506// SPDX-License-Identifier: MIT
14507
14508
14509
14510#include <algorithm> // all_of
14511#include <cctype> // isdigit
14512#include <cerrno> // errno, ERANGE
14513#include <cstdlib> // strtoull
14514#ifndef JSON_NO_IO
14515    #include <iosfwd> // ostream
14516#endif  // JSON_NO_IO
14517#include <limits> // max
14518#include <numeric> // accumulate
14519#include <string> // string
14520#include <utility> // move
14521#include <vector> // vector
14522
14523// #include <nlohmann/detail/exceptions.hpp>
14524
14525// #include <nlohmann/detail/macro_scope.hpp>
14526
14527// #include <nlohmann/detail/string_concat.hpp>
14528
14529// #include <nlohmann/detail/string_escape.hpp>
14530
14531// #include <nlohmann/detail/value_t.hpp>
14532
14533
14534NLOHMANN_JSON_NAMESPACE_BEGIN
14535
14536/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
14537/// @sa https://json.nlohmann.me/api/json_pointer/
14538template<typename RefStringType>
14539class json_pointer
14540{
14541    // allow basic_json to access private members
14542    NLOHMANN_BASIC_JSON_TPL_DECLARATION
14543    friend class basic_json;
14544
14545    template<typename>
14546    friend class json_pointer;
14547
14548    template<typename T>
14549    struct string_t_helper
14550    {
14551        using type = T;
14552    };
14553
14554    NLOHMANN_BASIC_JSON_TPL_DECLARATION
14555    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
14556    {
14557        using type = StringType;
14558    };
14559
14560  public:
14561    // for backwards compatibility accept BasicJsonType
14562    using string_t = typename string_t_helper<RefStringType>::type;
14563
14564    /// @brief create JSON pointer
14565    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
14566    explicit json_pointer(const string_t& s = "")
14567        : reference_tokens(split(s))
14568    {}
14569
14570    /// @brief return a string representation of the JSON pointer
14571    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
14572    string_t to_string() const
14573    {
14574        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
14575                               string_t{},
14576                               [](const string_t& a, const string_t& b)
14577        {
14578            return detail::concat(a, '/', detail::escape(b));
14579        });
14580    }
14581
14582    /// @brief return a string representation of the JSON pointer
14583    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
14584    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
14585    operator string_t() const
14586    {
14587        return to_string();
14588    }
14589
14590#ifndef JSON_NO_IO
14591    /// @brief write string representation of the JSON pointer to stream
14592    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
14593    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
14594    {
14595        o << ptr.to_string();
14596        return o;
14597    }
14598#endif
14599
14600    /// @brief append another JSON pointer at the end of this JSON pointer
14601    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
14602    json_pointer& operator/=(const json_pointer& ptr)
14603    {
14604        reference_tokens.insert(reference_tokens.end(),
14605                                ptr.reference_tokens.begin(),
14606                                ptr.reference_tokens.end());
14607        return *this;
14608    }
14609
14610    /// @brief append an unescaped reference token at the end of this JSON pointer
14611    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
14612    json_pointer& operator/=(string_t token)
14613    {
14614        push_back(std::move(token));
14615        return *this;
14616    }
14617
14618    /// @brief append an array index at the end of this JSON pointer
14619    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
14620    json_pointer& operator/=(std::size_t array_idx)
14621    {
14622        return *this /= std::to_string(array_idx);
14623    }
14624
14625    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
14626    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
14627    friend json_pointer operator/(const json_pointer& lhs,
14628                                  const json_pointer& rhs)
14629    {
14630        return json_pointer(lhs) /= rhs;
14631    }
14632
14633    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
14634    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
14635    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
14636    {
14637        return json_pointer(lhs) /= std::move(token);
14638    }
14639
14640    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
14641    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
14642    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
14643    {
14644        return json_pointer(lhs) /= array_idx;
14645    }
14646
14647    /// @brief returns the parent of this JSON pointer
14648    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
14649    json_pointer parent_pointer() const
14650    {
14651        if (empty())
14652        {
14653            return *this;
14654        }
14655
14656        json_pointer res = *this;
14657        res.pop_back();
14658        return res;
14659    }
14660
14661    /// @brief remove last reference token
14662    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
14663    void pop_back()
14664    {
14665        if (JSON_HEDLEY_UNLIKELY(empty()))
14666        {
14667            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
14668        }
14669
14670        reference_tokens.pop_back();
14671    }
14672
14673    /// @brief return last reference token
14674    /// @sa https://json.nlohmann.me/api/json_pointer/back/
14675    const string_t& back() const
14676    {
14677        if (JSON_HEDLEY_UNLIKELY(empty()))
14678        {
14679            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
14680        }
14681
14682        return reference_tokens.back();
14683    }
14684
14685    /// @brief append an unescaped token at the end of the reference pointer
14686    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
14687    void push_back(const string_t& token)
14688    {
14689        reference_tokens.push_back(token);
14690    }
14691
14692    /// @brief append an unescaped token at the end of the reference pointer
14693    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
14694    void push_back(string_t&& token)
14695    {
14696        reference_tokens.push_back(std::move(token));
14697    }
14698
14699    /// @brief return whether pointer points to the root document
14700    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
14701    bool empty() const noexcept
14702    {
14703        return reference_tokens.empty();
14704    }
14705
14706  private:
14707    /*!
14708    @param[in] s  reference token to be converted into an array index
14709
14710    @return integer representation of @a s
14711
14712    @throw parse_error.106  if an array index begins with '0'
14713    @throw parse_error.109  if an array index begins not with a digit
14714    @throw out_of_range.404 if string @a s could not be converted to an integer
14715    @throw out_of_range.410 if an array index exceeds size_type
14716    */
14717    template<typename BasicJsonType>
14718    static typename BasicJsonType::size_type array_index(const string_t& s)
14719    {
14720        using size_type = typename BasicJsonType::size_type;
14721
14722        // error condition (cf. RFC 6901, Sect. 4)
14723        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
14724        {
14725            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
14726        }
14727
14728        // error condition (cf. RFC 6901, Sect. 4)
14729        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
14730        {
14731            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
14732        }
14733
14734        const char* p = s.c_str();
14735        char* p_end = nullptr; // NOLINT(misc-const-correctness)
14736        errno = 0; // strtoull doesn't reset errno
14737        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
14738        if (p == p_end // invalid input or empty string
14739                || errno == ERANGE // out of range
14740                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
14741        {
14742            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
14743        }
14744
14745        // only triggered on special platforms (like 32bit), see also
14746        // https://github.com/nlohmann/json/pull/2203
14747        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
14748        {
14749            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
14750        }
14751
14752        return static_cast<size_type>(res);
14753    }
14754
14755  JSON_PRIVATE_UNLESS_TESTED:
14756    json_pointer top() const
14757    {
14758        if (JSON_HEDLEY_UNLIKELY(empty()))
14759        {
14760            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
14761        }
14762
14763        json_pointer result = *this;
14764        result.reference_tokens = {reference_tokens[0]};
14765        return result;
14766    }
14767
14768  private:
14769    /*!
14770    @brief create and return a reference to the pointed to value
14771
14772    @complexity Linear in the number of reference tokens.
14773
14774    @throw parse_error.109 if array index is not a number
14775    @throw type_error.313 if value cannot be unflattened
14776    */
14777    template<typename BasicJsonType>
14778    BasicJsonType& get_and_create(BasicJsonType& j) const
14779    {
14780        auto* result = &j;
14781
14782        // in case no reference tokens exist, return a reference to the JSON value
14783        // j which will be overwritten by a primitive value
14784        for (const auto& reference_token : reference_tokens)
14785        {
14786            switch (result->type())
14787            {
14788                case detail::value_t::null:
14789                {
14790                    if (reference_token == "0")
14791                    {
14792                        // start a new array if reference token is 0
14793                        result = &result->operator[](0);
14794                    }
14795                    else
14796                    {
14797                        // start a new object otherwise
14798                        result = &result->operator[](reference_token);
14799                    }
14800                    break;
14801                }
14802
14803                case detail::value_t::object:
14804                {
14805                    // create an entry in the object
14806                    result = &result->operator[](reference_token);
14807                    break;
14808                }
14809
14810                case detail::value_t::array:
14811                {
14812                    // create an entry in the array
14813                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
14814                    break;
14815                }
14816
14817                /*
14818                The following code is only reached if there exists a reference
14819                token _and_ the current value is primitive. In this case, we have
14820                an error situation, because primitive values may only occur as
14821                single value; that is, with an empty list of reference tokens.
14822                */
14823                case detail::value_t::string:
14824                case detail::value_t::boolean:
14825                case detail::value_t::number_integer:
14826                case detail::value_t::number_unsigned:
14827                case detail::value_t::number_float:
14828                case detail::value_t::binary:
14829                case detail::value_t::discarded:
14830                default:
14831                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
14832            }
14833        }
14834
14835        return *result;
14836    }
14837
14838    /*!
14839    @brief return a reference to the pointed to value
14840
14841    @note This version does not throw if a value is not present, but tries to
14842          create nested values instead. For instance, calling this function
14843          with pointer `"/this/that"` on a null value is equivalent to calling
14844          `operator[]("this").operator[]("that")` on that value, effectively
14845          changing the null value to an object.
14846
14847    @param[in] ptr  a JSON value
14848
14849    @return reference to the JSON value pointed to by the JSON pointer
14850
14851    @complexity Linear in the length of the JSON pointer.
14852
14853    @throw parse_error.106   if an array index begins with '0'
14854    @throw parse_error.109   if an array index was not a number
14855    @throw out_of_range.404  if the JSON pointer can not be resolved
14856    */
14857    template<typename BasicJsonType>
14858    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
14859    {
14860        for (const auto& reference_token : reference_tokens)
14861        {
14862            // convert null values to arrays or objects before continuing
14863            if (ptr->is_null())
14864            {
14865                // check if reference token is a number
14866                const bool nums =
14867                    std::all_of(reference_token.begin(), reference_token.end(),
14868                                [](const unsigned char x)
14869                {
14870                    return std::isdigit(x);
14871                });
14872
14873                // change value to array for numbers or "-" or to object otherwise
14874                *ptr = (nums || reference_token == "-")
14875                       ? detail::value_t::array
14876                       : detail::value_t::object;
14877            }
14878
14879            switch (ptr->type())
14880            {
14881                case detail::value_t::object:
14882                {
14883                    // use unchecked object access
14884                    ptr = &ptr->operator[](reference_token);
14885                    break;
14886                }
14887
14888                case detail::value_t::array:
14889                {
14890                    if (reference_token == "-")
14891                    {
14892                        // explicitly treat "-" as index beyond the end
14893                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
14894                    }
14895                    else
14896                    {
14897                        // convert array index to number; unchecked access
14898                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
14899                    }
14900                    break;
14901                }
14902
14903                case detail::value_t::null:
14904                case detail::value_t::string:
14905                case detail::value_t::boolean:
14906                case detail::value_t::number_integer:
14907                case detail::value_t::number_unsigned:
14908                case detail::value_t::number_float:
14909                case detail::value_t::binary:
14910                case detail::value_t::discarded:
14911                default:
14912                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
14913            }
14914        }
14915
14916        return *ptr;
14917    }
14918
14919    /*!
14920    @throw parse_error.106   if an array index begins with '0'
14921    @throw parse_error.109   if an array index was not a number
14922    @throw out_of_range.402  if the array index '-' is used
14923    @throw out_of_range.404  if the JSON pointer can not be resolved
14924    */
14925    template<typename BasicJsonType>
14926    BasicJsonType& get_checked(BasicJsonType* ptr) const
14927    {
14928        for (const auto& reference_token : reference_tokens)
14929        {
14930            switch (ptr->type())
14931            {
14932                case detail::value_t::object:
14933                {
14934                    // note: at performs range check
14935                    ptr = &ptr->at(reference_token);
14936                    break;
14937                }
14938
14939                case detail::value_t::array:
14940                {
14941                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
14942                    {
14943                        // "-" always fails the range check
14944                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
14945                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
14946                                ") is out of range"), ptr));
14947                    }
14948
14949                    // note: at performs range check
14950                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
14951                    break;
14952                }
14953
14954                case detail::value_t::null:
14955                case detail::value_t::string:
14956                case detail::value_t::boolean:
14957                case detail::value_t::number_integer:
14958                case detail::value_t::number_unsigned:
14959                case detail::value_t::number_float:
14960                case detail::value_t::binary:
14961                case detail::value_t::discarded:
14962                default:
14963                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
14964            }
14965        }
14966
14967        return *ptr;
14968    }
14969
14970    /*!
14971    @brief return a const reference to the pointed to value
14972
14973    @param[in] ptr  a JSON value
14974
14975    @return const reference to the JSON value pointed to by the JSON
14976    pointer
14977
14978    @throw parse_error.106   if an array index begins with '0'
14979    @throw parse_error.109   if an array index was not a number
14980    @throw out_of_range.402  if the array index '-' is used
14981    @throw out_of_range.404  if the JSON pointer can not be resolved
14982    */
14983    template<typename BasicJsonType>
14984    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
14985    {
14986        for (const auto& reference_token : reference_tokens)
14987        {
14988            switch (ptr->type())
14989            {
14990                case detail::value_t::object:
14991                {
14992                    // use unchecked object access
14993                    ptr = &ptr->operator[](reference_token);
14994                    break;
14995                }
14996
14997                case detail::value_t::array:
14998                {
14999                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
15000                    {
15001                        // "-" cannot be used for const access
15002                        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));
15003                    }
15004
15005                    // use unchecked array access
15006                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
15007                    break;
15008                }
15009
15010                case detail::value_t::null:
15011                case detail::value_t::string:
15012                case detail::value_t::boolean:
15013                case detail::value_t::number_integer:
15014                case detail::value_t::number_unsigned:
15015                case detail::value_t::number_float:
15016                case detail::value_t::binary:
15017                case detail::value_t::discarded:
15018                default:
15019                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
15020            }
15021        }
15022
15023        return *ptr;
15024    }
15025
15026    /*!
15027    @throw parse_error.106   if an array index begins with '0'
15028    @throw parse_error.109   if an array index was not a number
15029    @throw out_of_range.402  if the array index '-' is used
15030    @throw out_of_range.404  if the JSON pointer can not be resolved
15031    */
15032    template<typename BasicJsonType>
15033    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
15034    {
15035        for (const auto& reference_token : reference_tokens)
15036        {
15037            switch (ptr->type())
15038            {
15039                case detail::value_t::object:
15040                {
15041                    // note: at performs range check
15042                    ptr = &ptr->at(reference_token);
15043                    break;
15044                }
15045
15046                case detail::value_t::array:
15047                {
15048                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
15049                    {
15050                        // "-" always fails the range check
15051                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
15052                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
15053                                ") is out of range"), ptr));
15054                    }
15055
15056                    // note: at performs range check
15057                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
15058                    break;
15059                }
15060
15061                case detail::value_t::null:
15062                case detail::value_t::string:
15063                case detail::value_t::boolean:
15064                case detail::value_t::number_integer:
15065                case detail::value_t::number_unsigned:
15066                case detail::value_t::number_float:
15067                case detail::value_t::binary:
15068                case detail::value_t::discarded:
15069                default:
15070                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
15071            }
15072        }
15073
15074        return *ptr;
15075    }
15076
15077    /*!
15078    @throw parse_error.106   if an array index begins with '0'
15079    @throw parse_error.109   if an array index was not a number
15080    */
15081    template<typename BasicJsonType>
15082    bool contains(const BasicJsonType* ptr) const
15083    {
15084        for (const auto& reference_token : reference_tokens)
15085        {
15086            switch (ptr->type())
15087            {
15088                case detail::value_t::object:
15089                {
15090                    if (!ptr->contains(reference_token))
15091                    {
15092                        // we did not find the key in the object
15093                        return false;
15094                    }
15095
15096                    ptr = &ptr->operator[](reference_token);
15097                    break;
15098                }
15099
15100                case detail::value_t::array:
15101                {
15102                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
15103                    {
15104                        // "-" always fails the range check
15105                        return false;
15106                    }
15107                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
15108                    {
15109                        // invalid char
15110                        return false;
15111                    }
15112                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
15113                    {
15114                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
15115                        {
15116                            // first char should be between '1' and '9'
15117                            return false;
15118                        }
15119                        for (std::size_t i = 1; i < reference_token.size(); i++)
15120                        {
15121                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
15122                            {
15123                                // other char should be between '0' and '9'
15124                                return false;
15125                            }
15126                        }
15127                    }
15128
15129                    const auto idx = array_index<BasicJsonType>(reference_token);
15130                    if (idx >= ptr->size())
15131                    {
15132                        // index out of range
15133                        return false;
15134                    }
15135
15136                    ptr = &ptr->operator[](idx);
15137                    break;
15138                }
15139
15140                case detail::value_t::null:
15141                case detail::value_t::string:
15142                case detail::value_t::boolean:
15143                case detail::value_t::number_integer:
15144                case detail::value_t::number_unsigned:
15145                case detail::value_t::number_float:
15146                case detail::value_t::binary:
15147                case detail::value_t::discarded:
15148                default:
15149                {
15150                    // we do not expect primitive values if there is still a
15151                    // reference token to process
15152                    return false;
15153                }
15154            }
15155        }
15156
15157        // no reference token left means we found a primitive value
15158        return true;
15159    }
15160
15161    /*!
15162    @brief split the string input to reference tokens
15163
15164    @note This function is only called by the json_pointer constructor.
15165          All exceptions below are documented there.
15166
15167    @throw parse_error.107  if the pointer is not empty or begins with '/'
15168    @throw parse_error.108  if character '~' is not followed by '0' or '1'
15169    */
15170    static std::vector<string_t> split(const string_t& reference_string)
15171    {
15172        std::vector<string_t> result;
15173
15174        // special case: empty reference string -> no reference tokens
15175        if (reference_string.empty())
15176        {
15177            return result;
15178        }
15179
15180        // check if nonempty reference string begins with slash
15181        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
15182        {
15183            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
15184        }
15185
15186        // extract the reference tokens:
15187        // - slash: position of the last read slash (or end of string)
15188        // - start: position after the previous slash
15189        for (
15190            // search for the first slash after the first character
15191            std::size_t slash = reference_string.find_first_of('/', 1),
15192            // set the beginning of the first reference token
15193            start = 1;
15194            // we can stop if start == 0 (if slash == string_t::npos)
15195            start != 0;
15196            // set the beginning of the next reference token
15197            // (will eventually be 0 if slash == string_t::npos)
15198            start = (slash == string_t::npos) ? 0 : slash + 1,
15199            // find next slash
15200            slash = reference_string.find_first_of('/', start))
15201        {
15202            // use the text between the beginning of the reference token
15203            // (start) and the last slash (slash).
15204            auto reference_token = reference_string.substr(start, slash - start);
15205
15206            // check reference tokens are properly escaped
15207            for (std::size_t pos = reference_token.find_first_of('~');
15208                    pos != string_t::npos;
15209                    pos = reference_token.find_first_of('~', pos + 1))
15210            {
15211                JSON_ASSERT(reference_token[pos] == '~');
15212
15213                // ~ must be followed by 0 or 1
15214                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
15215                                         (reference_token[pos + 1] != '0' &&
15216                                          reference_token[pos + 1] != '1')))
15217                {
15218                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
15219                }
15220            }
15221
15222            // finally, store the reference token
15223            detail::unescape(reference_token);
15224            result.push_back(reference_token);
15225        }
15226
15227        return result;
15228    }
15229
15230  private:
15231    /*!
15232    @param[in] reference_string  the reference string to the current value
15233    @param[in] value             the value to consider
15234    @param[in,out] result        the result object to insert values to
15235
15236    @note Empty objects or arrays are flattened to `null`.
15237    */
15238    template<typename BasicJsonType>
15239    static void flatten(const string_t& reference_string,
15240                        const BasicJsonType& value,
15241                        BasicJsonType& result)
15242    {
15243        switch (value.type())
15244        {
15245            case detail::value_t::array:
15246            {
15247                if (value.m_data.m_value.array->empty())
15248                {
15249                    // flatten empty array as null
15250                    result[reference_string] = nullptr;
15251                }
15252                else
15253                {
15254                    // iterate array and use index as reference string
15255                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
15256                    {
15257                        flatten(detail::concat<string_t>(reference_string, '/', std::to_string(i)),
15258                                value.m_data.m_value.array->operator[](i), result);
15259                    }
15260                }
15261                break;
15262            }
15263
15264            case detail::value_t::object:
15265            {
15266                if (value.m_data.m_value.object->empty())
15267                {
15268                    // flatten empty object as null
15269                    result[reference_string] = nullptr;
15270                }
15271                else
15272                {
15273                    // iterate object and use keys as reference string
15274                    for (const auto& element : *value.m_data.m_value.object)
15275                    {
15276                        flatten(detail::concat<string_t>(reference_string, '/', detail::escape(element.first)), element.second, result);
15277                    }
15278                }
15279                break;
15280            }
15281
15282            case detail::value_t::null:
15283            case detail::value_t::string:
15284            case detail::value_t::boolean:
15285            case detail::value_t::number_integer:
15286            case detail::value_t::number_unsigned:
15287            case detail::value_t::number_float:
15288            case detail::value_t::binary:
15289            case detail::value_t::discarded:
15290            default:
15291            {
15292                // add primitive value with its reference string
15293                result[reference_string] = value;
15294                break;
15295            }
15296        }
15297    }
15298
15299    /*!
15300    @param[in] value  flattened JSON
15301
15302    @return unflattened JSON
15303
15304    @throw parse_error.109 if array index is not a number
15305    @throw type_error.314  if value is not an object
15306    @throw type_error.315  if object values are not primitive
15307    @throw type_error.313  if value cannot be unflattened
15308    */
15309    template<typename BasicJsonType>
15310    static BasicJsonType
15311    unflatten(const BasicJsonType& value)
15312    {
15313        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
15314        {
15315            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
15316        }
15317
15318        BasicJsonType result;
15319
15320        // iterate the JSON object values
15321        for (const auto& element : *value.m_data.m_value.object)
15322        {
15323            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
15324            {
15325                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
15326            }
15327
15328            // assign value to reference pointed to by JSON pointer; Note that if
15329            // the JSON pointer is "" (i.e., points to the whole value), function
15330            // get_and_create returns a reference to result itself. An assignment
15331            // will then create a primitive value.
15332            json_pointer(element.first).get_and_create(result) = element.second;
15333        }
15334
15335        return result;
15336    }
15337
15338    // can't use conversion operator because of ambiguity
15339    json_pointer<string_t> convert() const&
15340    {
15341        json_pointer<string_t> result;
15342        result.reference_tokens = reference_tokens;
15343        return result;
15344    }
15345
15346    json_pointer<string_t> convert()&&
15347    {
15348        json_pointer<string_t> result;
15349        result.reference_tokens = std::move(reference_tokens);
15350        return result;
15351    }
15352
15353  public:
15354#if JSON_HAS_THREE_WAY_COMPARISON
15355    /// @brief compares two JSON pointers for equality
15356    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
15357    template<typename RefStringTypeRhs>
15358    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
15359    {
15360        return reference_tokens == rhs.reference_tokens;
15361    }
15362
15363    /// @brief compares JSON pointer and string for equality
15364    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
15365    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
15366    bool operator==(const string_t& rhs) const
15367    {
15368        return *this == json_pointer(rhs);
15369    }
15370
15371    /// @brief 3-way compares two JSON pointers
15372    template<typename RefStringTypeRhs>
15373    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
15374    {
15375        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
15376    }
15377#else
15378    /// @brief compares two JSON pointers for equality
15379    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
15380    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
15381    // NOLINTNEXTLINE(readability-redundant-declaration)
15382    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
15383                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
15384
15385    /// @brief compares JSON pointer and string for equality
15386    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
15387    template<typename RefStringTypeLhs, typename StringType>
15388    // NOLINTNEXTLINE(readability-redundant-declaration)
15389    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
15390                           const StringType& rhs);
15391
15392    /// @brief compares string and JSON pointer for equality
15393    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
15394    template<typename RefStringTypeRhs, typename StringType>
15395    // NOLINTNEXTLINE(readability-redundant-declaration)
15396    friend bool operator==(const StringType& lhs,
15397                           const json_pointer<RefStringTypeRhs>& rhs);
15398
15399    /// @brief compares two JSON pointers for inequality
15400    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
15401    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
15402    // NOLINTNEXTLINE(readability-redundant-declaration)
15403    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
15404                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
15405
15406    /// @brief compares JSON pointer and string for inequality
15407    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
15408    template<typename RefStringTypeLhs, typename StringType>
15409    // NOLINTNEXTLINE(readability-redundant-declaration)
15410    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
15411                           const StringType& rhs);
15412
15413    /// @brief compares string and JSON pointer for inequality
15414    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
15415    template<typename RefStringTypeRhs, typename StringType>
15416    // NOLINTNEXTLINE(readability-redundant-declaration)
15417    friend bool operator!=(const StringType& lhs,
15418                           const json_pointer<RefStringTypeRhs>& rhs);
15419
15420    /// @brief compares two JSON pointer for less-than
15421    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
15422    // NOLINTNEXTLINE(readability-redundant-declaration)
15423    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
15424                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
15425#endif
15426
15427  private:
15428    /// the reference tokens
15429    std::vector<string_t> reference_tokens;
15430};
15431
15432#if !JSON_HAS_THREE_WAY_COMPARISON
15433// functions cannot be defined inside class due to ODR violations
15434template<typename RefStringTypeLhs, typename RefStringTypeRhs>
15435inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
15436                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
15437{
15438    return lhs.reference_tokens == rhs.reference_tokens;
15439}
15440
15441template<typename RefStringTypeLhs,
15442         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
15443JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
15444inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
15445                       const StringType& rhs)
15446{
15447    return lhs == json_pointer<RefStringTypeLhs>(rhs);
15448}
15449
15450template<typename RefStringTypeRhs,
15451         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
15452JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
15453inline bool operator==(const StringType& lhs,
15454                       const json_pointer<RefStringTypeRhs>& rhs)
15455{
15456    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
15457}
15458
15459template<typename RefStringTypeLhs, typename RefStringTypeRhs>
15460inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
15461                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
15462{
15463    return !(lhs == rhs);
15464}
15465
15466template<typename RefStringTypeLhs,
15467         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
15468JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
15469inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
15470                       const StringType& rhs)
15471{
15472    return !(lhs == rhs);
15473}
15474
15475template<typename RefStringTypeRhs,
15476         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
15477JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
15478inline bool operator!=(const StringType& lhs,
15479                       const json_pointer<RefStringTypeRhs>& rhs)
15480{
15481    return !(lhs == rhs);
15482}
15483
15484template<typename RefStringTypeLhs, typename RefStringTypeRhs>
15485inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
15486                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
15487{
15488    return lhs.reference_tokens < rhs.reference_tokens;
15489}
15490#endif
15491
15492NLOHMANN_JSON_NAMESPACE_END
15493
15494// #include <nlohmann/detail/json_ref.hpp>
15495//     __ _____ _____ _____
15496//  __|  |   __|     |   | |  JSON for Modern C++
15497// |  |  |__   |  |  | | | |  version 3.12.0
15498// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
15499//
15500// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
15501// SPDX-License-Identifier: MIT
15502
15503
15504
15505#include <initializer_list>
15506#include <utility>
15507
15508// #include <nlohmann/detail/abi_macros.hpp>
15509
15510// #include <nlohmann/detail/meta/type_traits.hpp>
15511
15512
15513NLOHMANN_JSON_NAMESPACE_BEGIN
15514namespace detail
15515{
15516
15517template<typename BasicJsonType>
15518class json_ref
15519{
15520  public:
15521    using value_type = BasicJsonType;
15522
15523    json_ref(value_type&& value)
15524        : owned_value(std::move(value))
15525    {}
15526
15527    json_ref(const value_type& value)
15528        : value_ref(&value)
15529    {}
15530
15531    json_ref(std::initializer_list<json_ref> init)
15532        : owned_value(init)
15533    {}
15534
15535    template <
15536        class... Args,
15537        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
15538    json_ref(Args && ... args)
15539        : owned_value(std::forward<Args>(args)...)
15540    {}
15541
15542    // class should be movable only
15543    json_ref(json_ref&&) noexcept = default;
15544    json_ref(const json_ref&) = delete;
15545    json_ref& operator=(const json_ref&) = delete;
15546    json_ref& operator=(json_ref&&) = delete;
15547    ~json_ref() = default;
15548
15549    value_type moved_or_copied() const
15550    {
15551        if (value_ref == nullptr)
15552        {
15553            return std::move(owned_value);
15554        }
15555        return *value_ref;
15556    }
15557
15558    value_type const& operator*() const
15559    {
15560        return value_ref ? *value_ref : owned_value;
15561    }
15562
15563    value_type const* operator->() const
15564    {
15565        return &** this;
15566    }
15567
15568  private:
15569    mutable value_type owned_value = nullptr;
15570    value_type const* value_ref = nullptr;
15571};
15572
15573}  // namespace detail
15574NLOHMANN_JSON_NAMESPACE_END
15575
15576// #include <nlohmann/detail/macro_scope.hpp>
15577
15578// #include <nlohmann/detail/string_concat.hpp>
15579
15580// #include <nlohmann/detail/string_escape.hpp>
15581
15582// #include <nlohmann/detail/string_utils.hpp>
15583
15584// #include <nlohmann/detail/meta/cpp_future.hpp>
15585
15586// #include <nlohmann/detail/meta/type_traits.hpp>
15587
15588// #include <nlohmann/detail/output/binary_writer.hpp>
15589//     __ _____ _____ _____
15590//  __|  |   __|     |   | |  JSON for Modern C++
15591// |  |  |__   |  |  | | | |  version 3.12.0
15592// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
15593//
15594// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
15595// SPDX-License-Identifier: MIT
15596
15597
15598
15599#include <algorithm> // reverse
15600#include <array> // array
15601#include <map> // map
15602#include <cmath> // isnan, isinf
15603#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
15604#include <cstring> // memcpy
15605#include <limits> // numeric_limits
15606#include <string> // string
15607#include <utility> // move
15608#include <vector> // vector
15609
15610// #include <nlohmann/detail/input/binary_reader.hpp>
15611
15612// #include <nlohmann/detail/macro_scope.hpp>
15613
15614// #include <nlohmann/detail/output/output_adapters.hpp>
15615//     __ _____ _____ _____
15616//  __|  |   __|     |   | |  JSON for Modern C++
15617// |  |  |__   |  |  | | | |  version 3.12.0
15618// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
15619//
15620// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
15621// SPDX-License-Identifier: MIT
15622
15623
15624
15625#include <algorithm> // copy
15626#include <cstddef> // size_t
15627#include <iterator> // back_inserter
15628#include <memory> // shared_ptr, make_shared
15629#include <string> // basic_string
15630#include <vector> // vector
15631
15632#ifndef JSON_NO_IO
15633    #include <ios>      // streamsize
15634    #include <ostream>  // basic_ostream
15635#endif  // JSON_NO_IO
15636
15637// #include <nlohmann/detail/macro_scope.hpp>
15638
15639
15640NLOHMANN_JSON_NAMESPACE_BEGIN
15641namespace detail
15642{
15643
15644/// abstract output adapter interface
15645template<typename CharType> struct output_adapter_protocol
15646{
15647    virtual void write_character(CharType c) = 0;
15648    virtual void write_characters(const CharType* s, std::size_t length) = 0;
15649    virtual ~output_adapter_protocol() = default;
15650
15651    output_adapter_protocol() = default;
15652    output_adapter_protocol(const output_adapter_protocol&) = default;
15653    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
15654    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
15655    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
15656};
15657
15658/// a type to simplify interfaces
15659template<typename CharType>
15660using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
15661
15662/// output adapter for byte vectors
15663template<typename CharType, typename AllocatorType = std::allocator<CharType>>
15664class output_vector_adapter : public output_adapter_protocol<CharType>
15665{
15666  public:
15667    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
15668        : v(vec)
15669    {}
15670
15671    void write_character(CharType c) override
15672    {
15673        v.push_back(c);
15674    }
15675
15676    JSON_HEDLEY_NON_NULL(2)
15677    void write_characters(const CharType* s, std::size_t length) override
15678    {
15679        v.insert(v.end(), s, s + length);
15680    }
15681
15682  private:
15683    std::vector<CharType, AllocatorType>& v;
15684};
15685
15686#ifndef JSON_NO_IO
15687/// output adapter for output streams
15688template<typename CharType>
15689class output_stream_adapter : public output_adapter_protocol<CharType>
15690{
15691  public:
15692    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
15693        : stream(s)
15694    {}
15695
15696    void write_character(CharType c) override
15697    {
15698        stream.put(c);
15699    }
15700
15701    JSON_HEDLEY_NON_NULL(2)
15702    void write_characters(const CharType* s, std::size_t length) override
15703    {
15704        stream.write(s, static_cast<std::streamsize>(length));
15705    }
15706
15707  private:
15708    std::basic_ostream<CharType>& stream;
15709};
15710#endif  // JSON_NO_IO
15711
15712/// output adapter for basic_string
15713template<typename CharType, typename StringType = std::basic_string<CharType>>
15714class output_string_adapter : public output_adapter_protocol<CharType>
15715{
15716  public:
15717    explicit output_string_adapter(StringType& s) noexcept
15718        : str(s)
15719    {}
15720
15721    void write_character(CharType c) override
15722    {
15723        str.push_back(c);
15724    }
15725
15726    JSON_HEDLEY_NON_NULL(2)
15727    void write_characters(const CharType* s, std::size_t length) override
15728    {
15729        str.append(s, length);
15730    }
15731
15732  private:
15733    StringType& str;
15734};
15735
15736template<typename CharType, typename StringType = std::basic_string<CharType>>
15737class output_adapter
15738{
15739  public:
15740    template<typename AllocatorType = std::allocator<CharType>>
15741    output_adapter(std::vector<CharType, AllocatorType>& vec)
15742        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
15743
15744#ifndef JSON_NO_IO
15745    output_adapter(std::basic_ostream<CharType>& s)
15746        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
15747#endif  // JSON_NO_IO
15748
15749    output_adapter(StringType& s)
15750        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
15751
15752    operator output_adapter_t<CharType>()
15753    {
15754        return oa;
15755    }
15756
15757  private:
15758    output_adapter_t<CharType> oa = nullptr;
15759};
15760
15761}  // namespace detail
15762NLOHMANN_JSON_NAMESPACE_END
15763
15764// #include <nlohmann/detail/string_concat.hpp>
15765
15766
15767NLOHMANN_JSON_NAMESPACE_BEGIN
15768namespace detail
15769{
15770
15771/// how to encode BJData
15772enum class bjdata_version_t
15773{
15774    draft2,
15775    draft3,
15776};
15777
15778///////////////////
15779// binary writer //
15780///////////////////
15781
15782/*!
15783@brief serialization to CBOR and MessagePack values
15784*/
15785template<typename BasicJsonType, typename CharType>
15786class binary_writer
15787{
15788    using string_t = typename BasicJsonType::string_t;
15789    using binary_t = typename BasicJsonType::binary_t;
15790    using number_float_t = typename BasicJsonType::number_float_t;
15791
15792  public:
15793    /*!
15794    @brief create a binary writer
15795
15796    @param[in] adapter  output adapter to write to
15797    */
15798    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
15799    {
15800        JSON_ASSERT(oa);
15801    }
15802
15803    /*!
15804    @param[in] j  JSON value to serialize
15805    @pre       j.type() == value_t::object
15806    */
15807    void write_bson(const BasicJsonType& j)
15808    {
15809        switch (j.type())
15810        {
15811            case value_t::object:
15812            {
15813                write_bson_object(*j.m_data.m_value.object);
15814                break;
15815            }
15816
15817            case value_t::null:
15818            case value_t::array:
15819            case value_t::string:
15820            case value_t::boolean:
15821            case value_t::number_integer:
15822            case value_t::number_unsigned:
15823            case value_t::number_float:
15824            case value_t::binary:
15825            case value_t::discarded:
15826            default:
15827            {
15828                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
15829            }
15830        }
15831    }
15832
15833    /*!
15834    @param[in] j  JSON value to serialize
15835    */
15836    void write_cbor(const BasicJsonType& j)
15837    {
15838        switch (j.type())
15839        {
15840            case value_t::null:
15841            {
15842                oa->write_character(to_char_type(0xF6));
15843                break;
15844            }
15845
15846            case value_t::boolean:
15847            {
15848                oa->write_character(j.m_data.m_value.boolean
15849                                    ? to_char_type(0xF5)
15850                                    : to_char_type(0xF4));
15851                break;
15852            }
15853
15854            case value_t::number_integer:
15855            {
15856                if (j.m_data.m_value.number_integer >= 0)
15857                {
15858                    // CBOR does not differentiate between positive signed
15859                    // integers and unsigned integers. Therefore, we used the
15860                    // code from the value_t::number_unsigned case here.
15861                    if (j.m_data.m_value.number_integer <= 0x17)
15862                    {
15863                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15864                    }
15865                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
15866                    {
15867                        oa->write_character(to_char_type(0x18));
15868                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
15869                    }
15870                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
15871                    {
15872                        oa->write_character(to_char_type(0x19));
15873                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
15874                    }
15875                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
15876                    {
15877                        oa->write_character(to_char_type(0x1A));
15878                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
15879                    }
15880                    else
15881                    {
15882                        oa->write_character(to_char_type(0x1B));
15883                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
15884                    }
15885                }
15886                else
15887                {
15888                    // The conversions below encode the sign in the first
15889                    // byte, and the value is converted to a positive number.
15890                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
15891                    if (j.m_data.m_value.number_integer >= -24)
15892                    {
15893                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
15894                    }
15895                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
15896                    {
15897                        oa->write_character(to_char_type(0x38));
15898                        write_number(static_cast<std::uint8_t>(positive_number));
15899                    }
15900                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
15901                    {
15902                        oa->write_character(to_char_type(0x39));
15903                        write_number(static_cast<std::uint16_t>(positive_number));
15904                    }
15905                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
15906                    {
15907                        oa->write_character(to_char_type(0x3A));
15908                        write_number(static_cast<std::uint32_t>(positive_number));
15909                    }
15910                    else
15911                    {
15912                        oa->write_character(to_char_type(0x3B));
15913                        write_number(static_cast<std::uint64_t>(positive_number));
15914                    }
15915                }
15916                break;
15917            }
15918
15919            case value_t::number_unsigned:
15920            {
15921                if (j.m_data.m_value.number_unsigned <= 0x17)
15922                {
15923                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
15924                }
15925                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15926                {
15927                    oa->write_character(to_char_type(0x18));
15928                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
15929                }
15930                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15931                {
15932                    oa->write_character(to_char_type(0x19));
15933                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
15934                }
15935                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15936                {
15937                    oa->write_character(to_char_type(0x1A));
15938                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
15939                }
15940                else
15941                {
15942                    oa->write_character(to_char_type(0x1B));
15943                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
15944                }
15945                break;
15946            }
15947
15948            case value_t::number_float:
15949            {
15950                if (std::isnan(j.m_data.m_value.number_float))
15951                {
15952                    // NaN is 0xf97e00 in CBOR
15953                    oa->write_character(to_char_type(0xF9));
15954                    oa->write_character(to_char_type(0x7E));
15955                    oa->write_character(to_char_type(0x00));
15956                }
15957                else if (std::isinf(j.m_data.m_value.number_float))
15958                {
15959                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
15960                    oa->write_character(to_char_type(0xf9));
15961                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
15962                    oa->write_character(to_char_type(0x00));
15963                }
15964                else
15965                {
15966                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
15967                }
15968                break;
15969            }
15970
15971            case value_t::string:
15972            {
15973                // step 1: write control byte and the string length
15974                const auto N = j.m_data.m_value.string->size();
15975                if (N <= 0x17)
15976                {
15977                    write_number(static_cast<std::uint8_t>(0x60 + N));
15978                }
15979                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15980                {
15981                    oa->write_character(to_char_type(0x78));
15982                    write_number(static_cast<std::uint8_t>(N));
15983                }
15984                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15985                {
15986                    oa->write_character(to_char_type(0x79));
15987                    write_number(static_cast<std::uint16_t>(N));
15988                }
15989                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15990                {
15991                    oa->write_character(to_char_type(0x7A));
15992                    write_number(static_cast<std::uint32_t>(N));
15993                }
15994                // LCOV_EXCL_START
15995                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15996                {
15997                    oa->write_character(to_char_type(0x7B));
15998                    write_number(static_cast<std::uint64_t>(N));
15999                }
16000                // LCOV_EXCL_STOP
16001
16002                // step 2: write the string
16003                oa->write_characters(
16004                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
16005                    j.m_data.m_value.string->size());
16006                break;
16007            }
16008
16009            case value_t::array:
16010            {
16011                // step 1: write control byte and the array size
16012                const auto N = j.m_data.m_value.array->size();
16013                if (N <= 0x17)
16014                {
16015                    write_number(static_cast<std::uint8_t>(0x80 + N));
16016                }
16017                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
16018                {
16019                    oa->write_character(to_char_type(0x98));
16020                    write_number(static_cast<std::uint8_t>(N));
16021                }
16022                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16023                {
16024                    oa->write_character(to_char_type(0x99));
16025                    write_number(static_cast<std::uint16_t>(N));
16026                }
16027                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16028                {
16029                    oa->write_character(to_char_type(0x9A));
16030                    write_number(static_cast<std::uint32_t>(N));
16031                }
16032                // LCOV_EXCL_START
16033                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
16034                {
16035                    oa->write_character(to_char_type(0x9B));
16036                    write_number(static_cast<std::uint64_t>(N));
16037                }
16038                // LCOV_EXCL_STOP
16039
16040                // step 2: write each element
16041                for (const auto& el : *j.m_data.m_value.array)
16042                {
16043                    write_cbor(el);
16044                }
16045                break;
16046            }
16047
16048            case value_t::binary:
16049            {
16050                if (j.m_data.m_value.binary->has_subtype())
16051                {
16052                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
16053                    {
16054                        write_number(static_cast<std::uint8_t>(0xd8));
16055                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
16056                    }
16057                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
16058                    {
16059                        write_number(static_cast<std::uint8_t>(0xd9));
16060                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
16061                    }
16062                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
16063                    {
16064                        write_number(static_cast<std::uint8_t>(0xda));
16065                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
16066                    }
16067                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
16068                    {
16069                        write_number(static_cast<std::uint8_t>(0xdb));
16070                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
16071                    }
16072                }
16073
16074                // step 1: write control byte and the binary array size
16075                const auto N = j.m_data.m_value.binary->size();
16076                if (N <= 0x17)
16077                {
16078                    write_number(static_cast<std::uint8_t>(0x40 + N));
16079                }
16080                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
16081                {
16082                    oa->write_character(to_char_type(0x58));
16083                    write_number(static_cast<std::uint8_t>(N));
16084                }
16085                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16086                {
16087                    oa->write_character(to_char_type(0x59));
16088                    write_number(static_cast<std::uint16_t>(N));
16089                }
16090                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16091                {
16092                    oa->write_character(to_char_type(0x5A));
16093                    write_number(static_cast<std::uint32_t>(N));
16094                }
16095                // LCOV_EXCL_START
16096                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
16097                {
16098                    oa->write_character(to_char_type(0x5B));
16099                    write_number(static_cast<std::uint64_t>(N));
16100                }
16101                // LCOV_EXCL_STOP
16102
16103                // step 2: write each element
16104                oa->write_characters(
16105                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
16106                    N);
16107
16108                break;
16109            }
16110
16111            case value_t::object:
16112            {
16113                // step 1: write control byte and the object size
16114                const auto N = j.m_data.m_value.object->size();
16115                if (N <= 0x17)
16116                {
16117                    write_number(static_cast<std::uint8_t>(0xA0 + N));
16118                }
16119                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
16120                {
16121                    oa->write_character(to_char_type(0xB8));
16122                    write_number(static_cast<std::uint8_t>(N));
16123                }
16124                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16125                {
16126                    oa->write_character(to_char_type(0xB9));
16127                    write_number(static_cast<std::uint16_t>(N));
16128                }
16129                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16130                {
16131                    oa->write_character(to_char_type(0xBA));
16132                    write_number(static_cast<std::uint32_t>(N));
16133                }
16134                // LCOV_EXCL_START
16135                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
16136                {
16137                    oa->write_character(to_char_type(0xBB));
16138                    write_number(static_cast<std::uint64_t>(N));
16139                }
16140                // LCOV_EXCL_STOP
16141
16142                // step 2: write each element
16143                for (const auto& el : *j.m_data.m_value.object)
16144                {
16145                    write_cbor(el.first);
16146                    write_cbor(el.second);
16147                }
16148                break;
16149            }
16150
16151            case value_t::discarded:
16152            default:
16153                break;
16154        }
16155    }
16156
16157    /*!
16158    @param[in] j  JSON value to serialize
16159    */
16160    void write_msgpack(const BasicJsonType& j)
16161    {
16162        switch (j.type())
16163        {
16164            case value_t::null: // nil
16165            {
16166                oa->write_character(to_char_type(0xC0));
16167                break;
16168            }
16169
16170            case value_t::boolean: // true and false
16171            {
16172                oa->write_character(j.m_data.m_value.boolean
16173                                    ? to_char_type(0xC3)
16174                                    : to_char_type(0xC2));
16175                break;
16176            }
16177
16178            case value_t::number_integer:
16179            {
16180                if (j.m_data.m_value.number_integer >= 0)
16181                {
16182                    // MessagePack does not differentiate between positive
16183                    // signed integers and unsigned integers. Therefore, we used
16184                    // the code from the value_t::number_unsigned case here.
16185                    if (j.m_data.m_value.number_unsigned < 128)
16186                    {
16187                        // positive fixnum
16188                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
16189                    }
16190                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
16191                    {
16192                        // uint 8
16193                        oa->write_character(to_char_type(0xCC));
16194                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
16195                    }
16196                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
16197                    {
16198                        // uint 16
16199                        oa->write_character(to_char_type(0xCD));
16200                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
16201                    }
16202                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
16203                    {
16204                        // uint 32
16205                        oa->write_character(to_char_type(0xCE));
16206                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
16207                    }
16208                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
16209                    {
16210                        // uint 64
16211                        oa->write_character(to_char_type(0xCF));
16212                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
16213                    }
16214                }
16215                else
16216                {
16217                    if (j.m_data.m_value.number_integer >= -32)
16218                    {
16219                        // negative fixnum
16220                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
16221                    }
16222                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
16223                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
16224                    {
16225                        // int 8
16226                        oa->write_character(to_char_type(0xD0));
16227                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
16228                    }
16229                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
16230                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
16231                    {
16232                        // int 16
16233                        oa->write_character(to_char_type(0xD1));
16234                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
16235                    }
16236                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
16237                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
16238                    {
16239                        // int 32
16240                        oa->write_character(to_char_type(0xD2));
16241                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
16242                    }
16243                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
16244                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
16245                    {
16246                        // int 64
16247                        oa->write_character(to_char_type(0xD3));
16248                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
16249                    }
16250                }
16251                break;
16252            }
16253
16254            case value_t::number_unsigned:
16255            {
16256                if (j.m_data.m_value.number_unsigned < 128)
16257                {
16258                    // positive fixnum
16259                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
16260                }
16261                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
16262                {
16263                    // uint 8
16264                    oa->write_character(to_char_type(0xCC));
16265                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
16266                }
16267                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
16268                {
16269                    // uint 16
16270                    oa->write_character(to_char_type(0xCD));
16271                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
16272                }
16273                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
16274                {
16275                    // uint 32
16276                    oa->write_character(to_char_type(0xCE));
16277                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
16278                }
16279                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
16280                {
16281                    // uint 64
16282                    oa->write_character(to_char_type(0xCF));
16283                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
16284                }
16285                break;
16286            }
16287
16288            case value_t::number_float:
16289            {
16290                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
16291                break;
16292            }
16293
16294            case value_t::string:
16295            {
16296                // step 1: write control byte and the string length
16297                const auto N = j.m_data.m_value.string->size();
16298                if (N <= 31)
16299                {
16300                    // fixstr
16301                    write_number(static_cast<std::uint8_t>(0xA0 | N));
16302                }
16303                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
16304                {
16305                    // str 8
16306                    oa->write_character(to_char_type(0xD9));
16307                    write_number(static_cast<std::uint8_t>(N));
16308                }
16309                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16310                {
16311                    // str 16
16312                    oa->write_character(to_char_type(0xDA));
16313                    write_number(static_cast<std::uint16_t>(N));
16314                }
16315                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16316                {
16317                    // str 32
16318                    oa->write_character(to_char_type(0xDB));
16319                    write_number(static_cast<std::uint32_t>(N));
16320                }
16321
16322                // step 2: write the string
16323                oa->write_characters(
16324                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
16325                    j.m_data.m_value.string->size());
16326                break;
16327            }
16328
16329            case value_t::array:
16330            {
16331                // step 1: write control byte and the array size
16332                const auto N = j.m_data.m_value.array->size();
16333                if (N <= 15)
16334                {
16335                    // fixarray
16336                    write_number(static_cast<std::uint8_t>(0x90 | N));
16337                }
16338                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16339                {
16340                    // array 16
16341                    oa->write_character(to_char_type(0xDC));
16342                    write_number(static_cast<std::uint16_t>(N));
16343                }
16344                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16345                {
16346                    // array 32
16347                    oa->write_character(to_char_type(0xDD));
16348                    write_number(static_cast<std::uint32_t>(N));
16349                }
16350
16351                // step 2: write each element
16352                for (const auto& el : *j.m_data.m_value.array)
16353                {
16354                    write_msgpack(el);
16355                }
16356                break;
16357            }
16358
16359            case value_t::binary:
16360            {
16361                // step 0: determine if the binary type has a set subtype to
16362                // determine whether to use the ext or fixext types
16363                const bool use_ext = j.m_data.m_value.binary->has_subtype();
16364
16365                // step 1: write control byte and the byte string length
16366                const auto N = j.m_data.m_value.binary->size();
16367                if (N <= (std::numeric_limits<std::uint8_t>::max)())
16368                {
16369                    std::uint8_t output_type{};
16370                    bool fixed = true;
16371                    if (use_ext)
16372                    {
16373                        switch (N)
16374                        {
16375                            case 1:
16376                                output_type = 0xD4; // fixext 1
16377                                break;
16378                            case 2:
16379                                output_type = 0xD5; // fixext 2
16380                                break;
16381                            case 4:
16382                                output_type = 0xD6; // fixext 4
16383                                break;
16384                            case 8:
16385                                output_type = 0xD7; // fixext 8
16386                                break;
16387                            case 16:
16388                                output_type = 0xD8; // fixext 16
16389                                break;
16390                            default:
16391                                output_type = 0xC7; // ext 8
16392                                fixed = false;
16393                                break;
16394                        }
16395
16396                    }
16397                    else
16398                    {
16399                        output_type = 0xC4; // bin 8
16400                        fixed = false;
16401                    }
16402
16403                    oa->write_character(to_char_type(output_type));
16404                    if (!fixed)
16405                    {
16406                        write_number(static_cast<std::uint8_t>(N));
16407                    }
16408                }
16409                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16410                {
16411                    const std::uint8_t output_type = use_ext
16412                                                     ? 0xC8 // ext 16
16413                                                     : 0xC5; // bin 16
16414
16415                    oa->write_character(to_char_type(output_type));
16416                    write_number(static_cast<std::uint16_t>(N));
16417                }
16418                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16419                {
16420                    const std::uint8_t output_type = use_ext
16421                                                     ? 0xC9 // ext 32
16422                                                     : 0xC6; // bin 32
16423
16424                    oa->write_character(to_char_type(output_type));
16425                    write_number(static_cast<std::uint32_t>(N));
16426                }
16427
16428                // step 1.5: if this is an ext type, write the subtype
16429                if (use_ext)
16430                {
16431                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
16432                }
16433
16434                // step 2: write the byte string
16435                oa->write_characters(
16436                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
16437                    N);
16438
16439                break;
16440            }
16441
16442            case value_t::object:
16443            {
16444                // step 1: write control byte and the object size
16445                const auto N = j.m_data.m_value.object->size();
16446                if (N <= 15)
16447                {
16448                    // fixmap
16449                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
16450                }
16451                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
16452                {
16453                    // map 16
16454                    oa->write_character(to_char_type(0xDE));
16455                    write_number(static_cast<std::uint16_t>(N));
16456                }
16457                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
16458                {
16459                    // map 32
16460                    oa->write_character(to_char_type(0xDF));
16461                    write_number(static_cast<std::uint32_t>(N));
16462                }
16463
16464                // step 2: write each element
16465                for (const auto& el : *j.m_data.m_value.object)
16466                {
16467                    write_msgpack(el.first);
16468                    write_msgpack(el.second);
16469                }
16470                break;
16471            }
16472
16473            case value_t::discarded:
16474            default:
16475                break;
16476        }
16477    }
16478
16479    /*!
16480    @param[in] j  JSON value to serialize
16481    @param[in] use_count   whether to use '#' prefixes (optimized format)
16482    @param[in] use_type    whether to use '$' prefixes (optimized format)
16483    @param[in] add_prefix  whether prefixes need to be used for this value
16484    @param[in] use_bjdata  whether write in BJData format, default is false
16485    @param[in] bjdata_version  which BJData version to use, default is draft2
16486    */
16487    void write_ubjson(const BasicJsonType& j, const bool use_count,
16488                      const bool use_type, const bool add_prefix = true,
16489                      const bool use_bjdata = false, const bjdata_version_t bjdata_version = bjdata_version_t::draft2)
16490    {
16491        const bool bjdata_draft3 = use_bjdata && bjdata_version == bjdata_version_t::draft3;
16492
16493        switch (j.type())
16494        {
16495            case value_t::null:
16496            {
16497                if (add_prefix)
16498                {
16499                    oa->write_character(to_char_type('Z'));
16500                }
16501                break;
16502            }
16503
16504            case value_t::boolean:
16505            {
16506                if (add_prefix)
16507                {
16508                    oa->write_character(j.m_data.m_value.boolean
16509                                        ? to_char_type('T')
16510                                        : to_char_type('F'));
16511                }
16512                break;
16513            }
16514
16515            case value_t::number_integer:
16516            {
16517                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
16518                break;
16519            }
16520
16521            case value_t::number_unsigned:
16522            {
16523                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
16524                break;
16525            }
16526
16527            case value_t::number_float:
16528            {
16529                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
16530                break;
16531            }
16532
16533            case value_t::string:
16534            {
16535                if (add_prefix)
16536                {
16537                    oa->write_character(to_char_type('S'));
16538                }
16539                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
16540                oa->write_characters(
16541                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
16542                    j.m_data.m_value.string->size());
16543                break;
16544            }
16545
16546            case value_t::array:
16547            {
16548                if (add_prefix)
16549                {
16550                    oa->write_character(to_char_type('['));
16551                }
16552
16553                bool prefix_required = true;
16554                if (use_type && !j.m_data.m_value.array->empty())
16555                {
16556                    JSON_ASSERT(use_count);
16557                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
16558                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
16559                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
16560                    {
16561                        return ubjson_prefix(v, use_bjdata) == first_prefix;
16562                    });
16563
16564                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
16565
16566                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
16567                    {
16568                        prefix_required = false;
16569                        oa->write_character(to_char_type('$'));
16570                        oa->write_character(first_prefix);
16571                    }
16572                }
16573
16574                if (use_count)
16575                {
16576                    oa->write_character(to_char_type('#'));
16577                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
16578                }
16579
16580                for (const auto& el : *j.m_data.m_value.array)
16581                {
16582                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
16583                }
16584
16585                if (!use_count)
16586                {
16587                    oa->write_character(to_char_type(']'));
16588                }
16589
16590                break;
16591            }
16592
16593            case value_t::binary:
16594            {
16595                if (add_prefix)
16596                {
16597                    oa->write_character(to_char_type('['));
16598                }
16599
16600                if (use_type && (bjdata_draft3 || !j.m_data.m_value.binary->empty()))
16601                {
16602                    JSON_ASSERT(use_count);
16603                    oa->write_character(to_char_type('$'));
16604                    oa->write_character(bjdata_draft3 ? 'B' : 'U');
16605                }
16606
16607                if (use_count)
16608                {
16609                    oa->write_character(to_char_type('#'));
16610                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
16611                }
16612
16613                if (use_type)
16614                {
16615                    oa->write_characters(
16616                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
16617                        j.m_data.m_value.binary->size());
16618                }
16619                else
16620                {
16621                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
16622                    {
16623                        oa->write_character(to_char_type(bjdata_draft3 ? 'B' : 'U'));
16624                        oa->write_character(j.m_data.m_value.binary->data()[i]);
16625                    }
16626                }
16627
16628                if (!use_count)
16629                {
16630                    oa->write_character(to_char_type(']'));
16631                }
16632
16633                break;
16634            }
16635
16636            case value_t::object:
16637            {
16638                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())
16639                {
16640                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type, bjdata_version))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
16641                    {
16642                        break;
16643                    }
16644                }
16645
16646                if (add_prefix)
16647                {
16648                    oa->write_character(to_char_type('{'));
16649                }
16650
16651                bool prefix_required = true;
16652                if (use_type && !j.m_data.m_value.object->empty())
16653                {
16654                    JSON_ASSERT(use_count);
16655                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
16656                    const bool same_prefix = std::all_of(j.begin(), j.end(),
16657                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
16658                    {
16659                        return ubjson_prefix(v, use_bjdata) == first_prefix;
16660                    });
16661
16662                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
16663
16664                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
16665                    {
16666                        prefix_required = false;
16667                        oa->write_character(to_char_type('$'));
16668                        oa->write_character(first_prefix);
16669                    }
16670                }
16671
16672                if (use_count)
16673                {
16674                    oa->write_character(to_char_type('#'));
16675                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
16676                }
16677
16678                for (const auto& el : *j.m_data.m_value.object)
16679                {
16680                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
16681                    oa->write_characters(
16682                        reinterpret_cast<const CharType*>(el.first.c_str()),
16683                        el.first.size());
16684                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
16685                }
16686
16687                if (!use_count)
16688                {
16689                    oa->write_character(to_char_type('}'));
16690                }
16691
16692                break;
16693            }
16694
16695            case value_t::discarded:
16696            default:
16697                break;
16698        }
16699    }
16700
16701  private:
16702    //////////
16703    // BSON //
16704    //////////
16705
16706    /*!
16707    @return The size of a BSON document entry header, including the id marker
16708            and the entry name size (and its null-terminator).
16709    */
16710    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
16711    {
16712        const auto it = name.find(static_cast<typename string_t::value_type>(0));
16713        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
16714        {
16715            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
16716            static_cast<void>(j);
16717        }
16718
16719        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
16720    }
16721
16722    /*!
16723    @brief Writes the given @a element_type and @a name to the output adapter
16724    */
16725    void write_bson_entry_header(const string_t& name,
16726                                 const std::uint8_t element_type)
16727    {
16728        oa->write_character(to_char_type(element_type)); // boolean
16729        oa->write_characters(
16730            reinterpret_cast<const CharType*>(name.c_str()),
16731            name.size() + 1u);
16732    }
16733
16734    /*!
16735    @brief Writes a BSON element with key @a name and boolean value @a value
16736    */
16737    void write_bson_boolean(const string_t& name,
16738                            const bool value)
16739    {
16740        write_bson_entry_header(name, 0x08);
16741        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
16742    }
16743
16744    /*!
16745    @brief Writes a BSON element with key @a name and double value @a value
16746    */
16747    void write_bson_double(const string_t& name,
16748                           const double value)
16749    {
16750        write_bson_entry_header(name, 0x01);
16751        write_number<double>(value, true);
16752    }
16753
16754    /*!
16755    @return The size of the BSON-encoded string in @a value
16756    */
16757    static std::size_t calc_bson_string_size(const string_t& value)
16758    {
16759        return sizeof(std::int32_t) + value.size() + 1ul;
16760    }
16761
16762    /*!
16763    @brief Writes a BSON element with key @a name and string value @a value
16764    */
16765    void write_bson_string(const string_t& name,
16766                           const string_t& value)
16767    {
16768        write_bson_entry_header(name, 0x02);
16769
16770        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
16771        oa->write_characters(
16772            reinterpret_cast<const CharType*>(value.c_str()),
16773            value.size() + 1);
16774    }
16775
16776    /*!
16777    @brief Writes a BSON element with key @a name and null value
16778    */
16779    void write_bson_null(const string_t& name)
16780    {
16781        write_bson_entry_header(name, 0x0A);
16782    }
16783
16784    /*!
16785    @return The size of the BSON-encoded integer @a value
16786    */
16787    static std::size_t calc_bson_integer_size(const std::int64_t value)
16788    {
16789        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
16790               ? sizeof(std::int32_t)
16791               : sizeof(std::int64_t);
16792    }
16793
16794    /*!
16795    @brief Writes a BSON element with key @a name and integer @a value
16796    */
16797    void write_bson_integer(const string_t& name,
16798                            const std::int64_t value)
16799    {
16800        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
16801        {
16802            write_bson_entry_header(name, 0x10); // int32
16803            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
16804        }
16805        else
16806        {
16807            write_bson_entry_header(name, 0x12); // int64
16808            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
16809        }
16810    }
16811
16812    /*!
16813    @return The size of the BSON-encoded unsigned integer in @a j
16814    */
16815    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
16816    {
16817        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16818               ? sizeof(std::int32_t)
16819               : sizeof(std::int64_t);
16820    }
16821
16822    /*!
16823    @brief Writes a BSON element with key @a name and unsigned @a value
16824    */
16825    void write_bson_unsigned(const string_t& name,
16826                             const BasicJsonType& j)
16827    {
16828        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16829        {
16830            write_bson_entry_header(name, 0x10 /* int32 */);
16831            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
16832        }
16833        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16834        {
16835            write_bson_entry_header(name, 0x12 /* int64 */);
16836            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
16837        }
16838        else
16839        {
16840            write_bson_entry_header(name, 0x11 /* uint64 */);
16841            write_number<std::uint64_t>(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned), true);
16842        }
16843    }
16844
16845    /*!
16846    @brief Writes a BSON element with key @a name and object @a value
16847    */
16848    void write_bson_object_entry(const string_t& name,
16849                                 const typename BasicJsonType::object_t& value)
16850    {
16851        write_bson_entry_header(name, 0x03); // object
16852        write_bson_object(value);
16853    }
16854
16855    /*!
16856    @return The size of the BSON-encoded array @a value
16857    */
16858    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
16859    {
16860        std::size_t array_index = 0ul;
16861
16862        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)
16863        {
16864            return result + calc_bson_element_size(std::to_string(array_index++), el);
16865        });
16866
16867        return sizeof(std::int32_t) + embedded_document_size + 1ul;
16868    }
16869
16870    /*!
16871    @return The size of the BSON-encoded binary array @a value
16872    */
16873    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
16874    {
16875        return sizeof(std::int32_t) + value.size() + 1ul;
16876    }
16877
16878    /*!
16879    @brief Writes a BSON element with key @a name and array @a value
16880    */
16881    void write_bson_array(const string_t& name,
16882                          const typename BasicJsonType::array_t& value)
16883    {
16884        write_bson_entry_header(name, 0x04); // array
16885        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
16886
16887        std::size_t array_index = 0ul;
16888
16889        for (const auto& el : value)
16890        {
16891            write_bson_element(std::to_string(array_index++), el);
16892        }
16893
16894        oa->write_character(to_char_type(0x00));
16895    }
16896
16897    /*!
16898    @brief Writes a BSON element with key @a name and binary value @a value
16899    */
16900    void write_bson_binary(const string_t& name,
16901                           const binary_t& value)
16902    {
16903        write_bson_entry_header(name, 0x05);
16904
16905        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
16906        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
16907
16908        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
16909    }
16910
16911    /*!
16912    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
16913    @return The calculated size for the BSON document entry for @a j with the given @a name.
16914    */
16915    static std::size_t calc_bson_element_size(const string_t& name,
16916            const BasicJsonType& j)
16917    {
16918        const auto header_size = calc_bson_entry_header_size(name, j);
16919        switch (j.type())
16920        {
16921            case value_t::object:
16922                return header_size + calc_bson_object_size(*j.m_data.m_value.object);
16923
16924            case value_t::array:
16925                return header_size + calc_bson_array_size(*j.m_data.m_value.array);
16926
16927            case value_t::binary:
16928                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
16929
16930            case value_t::boolean:
16931                return header_size + 1ul;
16932
16933            case value_t::number_float:
16934                return header_size + 8ul;
16935
16936            case value_t::number_integer:
16937                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
16938
16939            case value_t::number_unsigned:
16940                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
16941
16942            case value_t::string:
16943                return header_size + calc_bson_string_size(*j.m_data.m_value.string);
16944
16945            case value_t::null:
16946                return header_size + 0ul;
16947
16948            // LCOV_EXCL_START
16949            case value_t::discarded:
16950            default:
16951                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
16952                return 0ul;
16953                // LCOV_EXCL_STOP
16954        }
16955    }
16956
16957    /*!
16958    @brief Serializes the JSON value @a j to BSON and associates it with the
16959           key @a name.
16960    @param name The name to associate with the JSON entity @a j within the
16961                current BSON document
16962    */
16963    void write_bson_element(const string_t& name,
16964                            const BasicJsonType& j)
16965    {
16966        switch (j.type())
16967        {
16968            case value_t::object:
16969                return write_bson_object_entry(name, *j.m_data.m_value.object);
16970
16971            case value_t::array:
16972                return write_bson_array(name, *j.m_data.m_value.array);
16973
16974            case value_t::binary:
16975                return write_bson_binary(name, *j.m_data.m_value.binary);
16976
16977            case value_t::boolean:
16978                return write_bson_boolean(name, j.m_data.m_value.boolean);
16979
16980            case value_t::number_float:
16981                return write_bson_double(name, j.m_data.m_value.number_float);
16982
16983            case value_t::number_integer:
16984                return write_bson_integer(name, j.m_data.m_value.number_integer);
16985
16986            case value_t::number_unsigned:
16987                return write_bson_unsigned(name, j);
16988
16989            case value_t::string:
16990                return write_bson_string(name, *j.m_data.m_value.string);
16991
16992            case value_t::null:
16993                return write_bson_null(name);
16994
16995            // LCOV_EXCL_START
16996            case value_t::discarded:
16997            default:
16998                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
16999                return;
17000                // LCOV_EXCL_STOP
17001        }
17002    }
17003
17004    /*!
17005    @brief Calculates the size of the BSON serialization of the given
17006           JSON-object @a j.
17007    @param[in] value  JSON value to serialize
17008    @pre       value.type() == value_t::object
17009    */
17010    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
17011    {
17012        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
17013                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
17014        {
17015            return result += calc_bson_element_size(el.first, el.second);
17016        });
17017
17018        return sizeof(std::int32_t) + document_size + 1ul;
17019    }
17020
17021    /*!
17022    @param[in] value  JSON value to serialize
17023    @pre       value.type() == value_t::object
17024    */
17025    void write_bson_object(const typename BasicJsonType::object_t& value)
17026    {
17027        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
17028
17029        for (const auto& el : value)
17030        {
17031            write_bson_element(el.first, el.second);
17032        }
17033
17034        oa->write_character(to_char_type(0x00));
17035    }
17036
17037    //////////
17038    // CBOR //
17039    //////////
17040
17041    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
17042    {
17043        return to_char_type(0xFA);  // Single-Precision Float
17044    }
17045
17046    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
17047    {
17048        return to_char_type(0xFB);  // Double-Precision Float
17049    }
17050
17051    /////////////
17052    // MsgPack //
17053    /////////////
17054
17055    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
17056    {
17057        return to_char_type(0xCA);  // float 32
17058    }
17059
17060    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
17061    {
17062        return to_char_type(0xCB);  // float 64
17063    }
17064
17065    ////////////
17066    // UBJSON //
17067    ////////////
17068
17069    // UBJSON: write number (floating point)
17070    template<typename NumberType, typename std::enable_if<
17071                 std::is_floating_point<NumberType>::value, int>::type = 0>
17072    void write_number_with_ubjson_prefix(const NumberType n,
17073                                         const bool add_prefix,
17074                                         const bool use_bjdata)
17075    {
17076        if (add_prefix)
17077        {
17078            oa->write_character(get_ubjson_float_prefix(n));
17079        }
17080        write_number(n, use_bjdata);
17081    }
17082
17083    // UBJSON: write number (unsigned integer)
17084    template<typename NumberType, typename std::enable_if<
17085                 std::is_unsigned<NumberType>::value, int>::type = 0>
17086    void write_number_with_ubjson_prefix(const NumberType n,
17087                                         const bool add_prefix,
17088                                         const bool use_bjdata)
17089    {
17090        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
17091        {
17092            if (add_prefix)
17093            {
17094                oa->write_character(to_char_type('i'));  // int8
17095            }
17096            write_number(static_cast<std::uint8_t>(n), use_bjdata);
17097        }
17098        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
17099        {
17100            if (add_prefix)
17101            {
17102                oa->write_character(to_char_type('U'));  // uint8
17103            }
17104            write_number(static_cast<std::uint8_t>(n), use_bjdata);
17105        }
17106        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
17107        {
17108            if (add_prefix)
17109            {
17110                oa->write_character(to_char_type('I'));  // int16
17111            }
17112            write_number(static_cast<std::int16_t>(n), use_bjdata);
17113        }
17114        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
17115        {
17116            if (add_prefix)
17117            {
17118                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
17119            }
17120            write_number(static_cast<std::uint16_t>(n), use_bjdata);
17121        }
17122        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
17123        {
17124            if (add_prefix)
17125            {
17126                oa->write_character(to_char_type('l'));  // int32
17127            }
17128            write_number(static_cast<std::int32_t>(n), use_bjdata);
17129        }
17130        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
17131        {
17132            if (add_prefix)
17133            {
17134                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
17135            }
17136            write_number(static_cast<std::uint32_t>(n), use_bjdata);
17137        }
17138        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
17139        {
17140            if (add_prefix)
17141            {
17142                oa->write_character(to_char_type('L'));  // int64
17143            }
17144            write_number(static_cast<std::int64_t>(n), use_bjdata);
17145        }
17146        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
17147        {
17148            if (add_prefix)
17149            {
17150                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
17151            }
17152            write_number(static_cast<std::uint64_t>(n), use_bjdata);
17153        }
17154        else
17155        {
17156            if (add_prefix)
17157            {
17158                oa->write_character(to_char_type('H'));  // high-precision number
17159            }
17160
17161            const auto number = BasicJsonType(n).dump();
17162            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
17163            for (std::size_t i = 0; i < number.size(); ++i)
17164            {
17165                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
17166            }
17167        }
17168    }
17169
17170    // UBJSON: write number (signed integer)
17171    template < typename NumberType, typename std::enable_if <
17172                   std::is_signed<NumberType>::value&&
17173                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
17174    void write_number_with_ubjson_prefix(const NumberType n,
17175                                         const bool add_prefix,
17176                                         const bool use_bjdata)
17177    {
17178        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
17179        {
17180            if (add_prefix)
17181            {
17182                oa->write_character(to_char_type('i'));  // int8
17183            }
17184            write_number(static_cast<std::int8_t>(n), use_bjdata);
17185        }
17186        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)()))
17187        {
17188            if (add_prefix)
17189            {
17190                oa->write_character(to_char_type('U'));  // uint8
17191            }
17192            write_number(static_cast<std::uint8_t>(n), use_bjdata);
17193        }
17194        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
17195        {
17196            if (add_prefix)
17197            {
17198                oa->write_character(to_char_type('I'));  // int16
17199            }
17200            write_number(static_cast<std::int16_t>(n), use_bjdata);
17201        }
17202        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)())))
17203        {
17204            if (add_prefix)
17205            {
17206                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
17207            }
17208            write_number(static_cast<uint16_t>(n), use_bjdata);
17209        }
17210        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
17211        {
17212            if (add_prefix)
17213            {
17214                oa->write_character(to_char_type('l'));  // int32
17215            }
17216            write_number(static_cast<std::int32_t>(n), use_bjdata);
17217        }
17218        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)())))
17219        {
17220            if (add_prefix)
17221            {
17222                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
17223            }
17224            write_number(static_cast<uint32_t>(n), use_bjdata);
17225        }
17226        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
17227        {
17228            if (add_prefix)
17229            {
17230                oa->write_character(to_char_type('L'));  // int64
17231            }
17232            write_number(static_cast<std::int64_t>(n), use_bjdata);
17233        }
17234        // LCOV_EXCL_START
17235        else
17236        {
17237            if (add_prefix)
17238            {
17239                oa->write_character(to_char_type('H'));  // high-precision number
17240            }
17241
17242            const auto number = BasicJsonType(n).dump();
17243            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
17244            for (std::size_t i = 0; i < number.size(); ++i)
17245            {
17246                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
17247            }
17248        }
17249        // LCOV_EXCL_STOP
17250    }
17251
17252    /*!
17253    @brief determine the type prefix of container values
17254    */
17255    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
17256    {
17257        switch (j.type())
17258        {
17259            case value_t::null:
17260                return 'Z';
17261
17262            case value_t::boolean:
17263                return j.m_data.m_value.boolean ? 'T' : 'F';
17264
17265            case value_t::number_integer:
17266            {
17267                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)())
17268                {
17269                    return 'i';
17270                }
17271                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)())
17272                {
17273                    return 'U';
17274                }
17275                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)())
17276                {
17277                    return 'I';
17278                }
17279                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)()))
17280                {
17281                    return 'u';
17282                }
17283                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)())
17284                {
17285                    return 'l';
17286                }
17287                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)()))
17288                {
17289                    return 'm';
17290                }
17291                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)())
17292                {
17293                    return 'L';
17294                }
17295                // anything else is treated as high-precision number
17296                return 'H'; // LCOV_EXCL_LINE
17297            }
17298
17299            case value_t::number_unsigned:
17300            {
17301                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
17302                {
17303                    return 'i';
17304                }
17305                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
17306                {
17307                    return 'U';
17308                }
17309                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
17310                {
17311                    return 'I';
17312                }
17313                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
17314                {
17315                    return 'u';
17316                }
17317                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
17318                {
17319                    return 'l';
17320                }
17321                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
17322                {
17323                    return 'm';
17324                }
17325                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
17326                {
17327                    return 'L';
17328                }
17329                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
17330                {
17331                    return 'M';
17332                }
17333                // anything else is treated as high-precision number
17334                return 'H'; // LCOV_EXCL_LINE
17335            }
17336
17337            case value_t::number_float:
17338                return get_ubjson_float_prefix(j.m_data.m_value.number_float);
17339
17340            case value_t::string:
17341                return 'S';
17342
17343            case value_t::array: // fallthrough
17344            case value_t::binary:
17345                return '[';
17346
17347            case value_t::object:
17348                return '{';
17349
17350            case value_t::discarded:
17351            default:  // discarded values
17352                return 'N';
17353        }
17354    }
17355
17356    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
17357    {
17358        return 'd';  // float 32
17359    }
17360
17361    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
17362    {
17363        return 'D';  // float 64
17364    }
17365
17366    /*!
17367    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
17368    */
17369    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type, const bjdata_version_t bjdata_version)
17370    {
17371        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
17372            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'},
17373            {"char", 'C'}, {"byte", 'B'}
17374        };
17375
17376        string_t key = "_ArrayType_";
17377        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
17378        if (it == bjdtype.end())
17379        {
17380            return true;
17381        }
17382        CharType dtype = it->second;
17383
17384        key = "_ArraySize_";
17385        std::size_t len = (value.at(key).empty() ? 0 : 1);
17386        for (const auto& el : value.at(key))
17387        {
17388            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
17389        }
17390
17391        key = "_ArrayData_";
17392        if (value.at(key).size() != len)
17393        {
17394            return true;
17395        }
17396
17397        oa->write_character('[');
17398        oa->write_character('$');
17399        oa->write_character(dtype);
17400        oa->write_character('#');
17401
17402        key = "_ArraySize_";
17403        write_ubjson(value.at(key), use_count, use_type, true,  true, bjdata_version);
17404
17405        key = "_ArrayData_";
17406        if (dtype == 'U' || dtype == 'C' || dtype == 'B')
17407        {
17408            for (const auto& el : value.at(key))
17409            {
17410                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
17411            }
17412        }
17413        else if (dtype == 'i')
17414        {
17415            for (const auto& el : value.at(key))
17416            {
17417                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
17418            }
17419        }
17420        else if (dtype == 'u')
17421        {
17422            for (const auto& el : value.at(key))
17423            {
17424                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
17425            }
17426        }
17427        else if (dtype == 'I')
17428        {
17429            for (const auto& el : value.at(key))
17430            {
17431                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
17432            }
17433        }
17434        else if (dtype == 'm')
17435        {
17436            for (const auto& el : value.at(key))
17437            {
17438                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
17439            }
17440        }
17441        else if (dtype == 'l')
17442        {
17443            for (const auto& el : value.at(key))
17444            {
17445                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
17446            }
17447        }
17448        else if (dtype == 'M')
17449        {
17450            for (const auto& el : value.at(key))
17451            {
17452                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
17453            }
17454        }
17455        else if (dtype == 'L')
17456        {
17457            for (const auto& el : value.at(key))
17458            {
17459                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
17460            }
17461        }
17462        else if (dtype == 'd')
17463        {
17464            for (const auto& el : value.at(key))
17465            {
17466                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
17467            }
17468        }
17469        else if (dtype == 'D')
17470        {
17471            for (const auto& el : value.at(key))
17472            {
17473                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
17474            }
17475        }
17476        return false;
17477    }
17478
17479    ///////////////////////
17480    // Utility functions //
17481    ///////////////////////
17482
17483    /*
17484    @brief write a number to output input
17485    @param[in] n number of type @a NumberType
17486    @param[in] OutputIsLittleEndian Set to true if output data is
17487                                 required to be little endian
17488    @tparam NumberType the type of the number
17489
17490    @note This function needs to respect the system's endianness, because bytes
17491          in CBOR, MessagePack, and UBJSON are stored in network order (big
17492          endian) and therefore need reordering on little endian systems.
17493          On the other hand, BSON and BJData use little endian and should reorder
17494          on big endian systems.
17495    */
17496    template<typename NumberType>
17497    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
17498    {
17499        // step 1: write number to array of length NumberType
17500        std::array<CharType, sizeof(NumberType)> vec{};
17501        std::memcpy(vec.data(), &n, sizeof(NumberType));
17502
17503        // step 2: write array to output (with possible reordering)
17504        if (is_little_endian != OutputIsLittleEndian)
17505        {
17506            // reverse byte order prior to conversion if necessary
17507            std::reverse(vec.begin(), vec.end());
17508        }
17509
17510        oa->write_characters(vec.data(), sizeof(NumberType));
17511    }
17512
17513    void write_compact_float(const number_float_t n, detail::input_format_t format)
17514    {
17515#ifdef __GNUC__
17516#pragma GCC diagnostic push
17517#pragma GCC diagnostic ignored "-Wfloat-equal"
17518#endif
17519        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
17520                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
17521                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
17522        {
17523            oa->write_character(format == detail::input_format_t::cbor
17524                                ? get_cbor_float_prefix(static_cast<float>(n))
17525                                : get_msgpack_float_prefix(static_cast<float>(n)));
17526            write_number(static_cast<float>(n));
17527        }
17528        else
17529        {
17530            oa->write_character(format == detail::input_format_t::cbor
17531                                ? get_cbor_float_prefix(n)
17532                                : get_msgpack_float_prefix(n));
17533            write_number(n);
17534        }
17535#ifdef __GNUC__
17536#pragma GCC diagnostic pop
17537#endif
17538    }
17539
17540  public:
17541    // The following to_char_type functions are implement the conversion
17542    // between uint8_t and CharType. In case CharType is not unsigned,
17543    // such a conversion is required to allow values greater than 128.
17544    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
17545    template < typename C = CharType,
17546               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
17547    static constexpr CharType to_char_type(std::uint8_t x) noexcept
17548    {
17549        return *reinterpret_cast<char*>(&x);
17550    }
17551
17552    template < typename C = CharType,
17553               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
17554    static CharType to_char_type(std::uint8_t x) noexcept
17555    {
17556        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
17557        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
17558        CharType result;
17559        std::memcpy(&result, &x, sizeof(x));
17560        return result;
17561    }
17562
17563    template<typename C = CharType,
17564             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
17565    static constexpr CharType to_char_type(std::uint8_t x) noexcept
17566    {
17567        return x;
17568    }
17569
17570    template < typename InputCharType, typename C = CharType,
17571               enable_if_t <
17572                   std::is_signed<C>::value &&
17573                   std::is_signed<char>::value &&
17574                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
17575                   > * = nullptr >
17576    static constexpr CharType to_char_type(InputCharType x) noexcept
17577    {
17578        return x;
17579    }
17580
17581  private:
17582    /// whether we can assume little endianness
17583    const bool is_little_endian = little_endianness();
17584
17585    /// the output
17586    output_adapter_t<CharType> oa = nullptr;
17587};
17588
17589}  // namespace detail
17590NLOHMANN_JSON_NAMESPACE_END
17591
17592// #include <nlohmann/detail/output/output_adapters.hpp>
17593
17594// #include <nlohmann/detail/output/serializer.hpp>
17595//     __ _____ _____ _____
17596//  __|  |   __|     |   | |  JSON for Modern C++
17597// |  |  |__   |  |  | | | |  version 3.12.0
17598// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
17599//
17600// SPDX-FileCopyrightText: 2008 - 2009 Björn Hoehrmann <bjoern@hoehrmann.de>
17601// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
17602// SPDX-License-Identifier: MIT
17603
17604
17605
17606#include <algorithm> // reverse, remove, fill, find, none_of
17607#include <array> // array
17608#include <clocale> // localeconv, lconv
17609#include <cmath> // labs, isfinite, isnan, signbit
17610#include <cstddef> // size_t, ptrdiff_t
17611#include <cstdint> // uint8_t
17612#include <cstdio> // snprintf
17613#include <limits> // numeric_limits
17614#include <string> // string, char_traits
17615#include <iomanip> // setfill, setw
17616#include <type_traits> // is_same
17617#include <utility> // move
17618
17619// #include <nlohmann/detail/conversions/to_chars.hpp>
17620//     __ _____ _____ _____
17621//  __|  |   __|     |   | |  JSON for Modern C++
17622// |  |  |__   |  |  | | | |  version 3.12.0
17623// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
17624//
17625// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
17626// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
17627// SPDX-License-Identifier: MIT
17628
17629
17630
17631#include <array> // array
17632#include <cmath>   // signbit, isfinite
17633#include <cstdint> // intN_t, uintN_t
17634#include <cstring> // memcpy, memmove
17635#include <limits> // numeric_limits
17636#include <type_traits> // conditional
17637
17638// #include <nlohmann/detail/macro_scope.hpp>
17639
17640
17641NLOHMANN_JSON_NAMESPACE_BEGIN
17642namespace detail
17643{
17644
17645/*!
17646@brief implements the Grisu2 algorithm for binary to decimal floating-point
17647conversion.
17648
17649This implementation is a slightly modified version of the reference
17650implementation which may be obtained from
17651http://florian.loitsch.com/publications (bench.tar.gz).
17652
17653The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
17654
17655For a detailed description of the algorithm see:
17656
17657[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
17658    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
17659    Language Design and Implementation, PLDI 2010
17660[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
17661    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
17662    Design and Implementation, PLDI 1996
17663*/
17664namespace dtoa_impl
17665{
17666
17667template<typename Target, typename Source>
17668Target reinterpret_bits(const Source source)
17669{
17670    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
17671
17672    Target target;
17673    std::memcpy(&target, &source, sizeof(Source));
17674    return target;
17675}
17676
17677struct diyfp // f * 2^e
17678{
17679    static constexpr int kPrecision = 64; // = q
17680
17681    std::uint64_t f = 0;
17682    int e = 0;
17683
17684    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
17685
17686    /*!
17687    @brief returns x - y
17688    @pre x.e == y.e and x.f >= y.f
17689    */
17690    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
17691    {
17692        JSON_ASSERT(x.e == y.e);
17693        JSON_ASSERT(x.f >= y.f);
17694
17695        return {x.f - y.f, x.e};
17696    }
17697
17698    /*!
17699    @brief returns x * y
17700    @note The result is rounded. (Only the upper q bits are returned.)
17701    */
17702    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
17703    {
17704        static_assert(kPrecision == 64, "internal error");
17705
17706        // Computes:
17707        //  f = round((x.f * y.f) / 2^q)
17708        //  e = x.e + y.e + q
17709
17710        // Emulate the 64-bit * 64-bit multiplication:
17711        //
17712        // p = u * v
17713        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
17714        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
17715        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
17716        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
17717        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
17718        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
17719        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
17720        //
17721        // (Since Q might be larger than 2^32 - 1)
17722        //
17723        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
17724        //
17725        // (Q_hi + H does not overflow a 64-bit int)
17726        //
17727        //   = p_lo + 2^64 p_hi
17728
17729        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
17730        const std::uint64_t u_hi = x.f >> 32u;
17731        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
17732        const std::uint64_t v_hi = y.f >> 32u;
17733
17734        const std::uint64_t p0 = u_lo * v_lo;
17735        const std::uint64_t p1 = u_lo * v_hi;
17736        const std::uint64_t p2 = u_hi * v_lo;
17737        const std::uint64_t p3 = u_hi * v_hi;
17738
17739        const std::uint64_t p0_hi = p0 >> 32u;
17740        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
17741        const std::uint64_t p1_hi = p1 >> 32u;
17742        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
17743        const std::uint64_t p2_hi = p2 >> 32u;
17744
17745        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
17746
17747        // The full product might now be computed as
17748        //
17749        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
17750        // p_lo = p0_lo + (Q << 32)
17751        //
17752        // But in this particular case here, the full p_lo is not required.
17753        // Effectively we only need to add the highest bit in p_lo to p_hi (and
17754        // Q_hi + 1 does not overflow).
17755
17756        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
17757
17758        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
17759
17760        return {h, x.e + y.e + 64};
17761    }
17762
17763    /*!
17764    @brief normalize x such that the significand is >= 2^(q-1)
17765    @pre x.f != 0
17766    */
17767    static diyfp normalize(diyfp x) noexcept
17768    {
17769        JSON_ASSERT(x.f != 0);
17770
17771        while ((x.f >> 63u) == 0)
17772        {
17773            x.f <<= 1u;
17774            x.e--;
17775        }
17776
17777        return x;
17778    }
17779
17780    /*!
17781    @brief normalize x such that the result has the exponent E
17782    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
17783    */
17784    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
17785    {
17786        const int delta = x.e - target_exponent;
17787
17788        JSON_ASSERT(delta >= 0);
17789        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
17790
17791        return {x.f << delta, target_exponent};
17792    }
17793};
17794
17795struct boundaries
17796{
17797    diyfp w;
17798    diyfp minus;
17799    diyfp plus;
17800};
17801
17802/*!
17803Compute the (normalized) diyfp representing the input number 'value' and its
17804boundaries.
17805
17806@pre value must be finite and positive
17807*/
17808template<typename FloatType>
17809boundaries compute_boundaries(FloatType value)
17810{
17811    JSON_ASSERT(std::isfinite(value));
17812    JSON_ASSERT(value > 0);
17813
17814    // Convert the IEEE representation into a diyfp.
17815    //
17816    // If v is denormal:
17817    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
17818    // If v is normalized:
17819    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
17820
17821    static_assert(std::numeric_limits<FloatType>::is_iec559,
17822                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
17823
17824    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
17825    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
17826    constexpr int      kMinExp    = 1 - kBias;
17827    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
17828
17829    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
17830
17831    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
17832    const std::uint64_t E = bits >> (kPrecision - 1);
17833    const std::uint64_t F = bits & (kHiddenBit - 1);
17834
17835    const bool is_denormal = E == 0;
17836    const diyfp v = is_denormal
17837                    ? diyfp(F, kMinExp)
17838                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
17839
17840    // Compute the boundaries m- and m+ of the floating-point value
17841    // v = f * 2^e.
17842    //
17843    // Determine v- and v+, the floating-point predecessor and successor if v,
17844    // respectively.
17845    //
17846    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
17847    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
17848    //
17849    //      v+ = v + 2^e
17850    //
17851    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
17852    // between m- and m+ round to v, regardless of how the input rounding
17853    // algorithm breaks ties.
17854    //
17855    //      ---+-------------+-------------+-------------+-------------+---  (A)
17856    //         v-            m-            v             m+            v+
17857    //
17858    //      -----------------+------+------+-------------+-------------+---  (B)
17859    //                       v-     m-     v             m+            v+
17860
17861    const bool lower_boundary_is_closer = F == 0 && E > 1;
17862    const diyfp m_plus = diyfp((2 * v.f) + 1, v.e - 1);
17863    const diyfp m_minus = lower_boundary_is_closer
17864                          ? diyfp((4 * v.f) - 1, v.e - 2)  // (B)
17865                          : diyfp((2 * v.f) - 1, v.e - 1); // (A)
17866
17867    // Determine the normalized w+ = m+.
17868    const diyfp w_plus = diyfp::normalize(m_plus);
17869
17870    // Determine w- = m- such that e_(w-) = e_(w+).
17871    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
17872
17873    return {diyfp::normalize(v), w_minus, w_plus};
17874}
17875
17876// Given normalized diyfp w, Grisu needs to find a (normalized) cached
17877// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
17878// within a certain range [alpha, gamma] (Definition 3.2 from [1])
17879//
17880//      alpha <= e = e_c + e_w + q <= gamma
17881//
17882// or
17883//
17884//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
17885//                          <= f_c * f_w * 2^gamma
17886//
17887// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
17888//
17889//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
17890//
17891// or
17892//
17893//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
17894//
17895// The choice of (alpha,gamma) determines the size of the table and the form of
17896// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
17897// in practice:
17898//
17899// The idea is to cut the number c * w = f * 2^e into two parts, which can be
17900// processed independently: An integral part p1, and a fractional part p2:
17901//
17902//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
17903//              = (f div 2^-e) + (f mod 2^-e) * 2^e
17904//              = p1 + p2 * 2^e
17905//
17906// The conversion of p1 into decimal form requires a series of divisions and
17907// modulos by (a power of) 10. These operations are faster for 32-bit than for
17908// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
17909// achieved by choosing
17910//
17911//      -e >= 32   or   e <= -32 := gamma
17912//
17913// In order to convert the fractional part
17914//
17915//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
17916//
17917// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
17918// d[-i] are extracted in order:
17919//
17920//      (10 * p2) div 2^-e = d[-1]
17921//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
17922//
17923// The multiplication by 10 must not overflow. It is sufficient to choose
17924//
17925//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
17926//
17927// Since p2 = f mod 2^-e < 2^-e,
17928//
17929//      -e <= 60   or   e >= -60 := alpha
17930
17931constexpr int kAlpha = -60;
17932constexpr int kGamma = -32;
17933
17934struct cached_power // c = f * 2^e ~= 10^k
17935{
17936    std::uint64_t f;
17937    int e;
17938    int k;
17939};
17940
17941/*!
17942For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
17943power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
17944satisfies (Definition 3.2 from [1])
17945
17946     alpha <= e_c + e + q <= gamma.
17947*/
17948inline cached_power get_cached_power_for_binary_exponent(int e)
17949{
17950    // Now
17951    //
17952    //      alpha <= e_c + e + q <= gamma                                    (1)
17953    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
17954    //
17955    // and since the c's are normalized, 2^(q-1) <= f_c,
17956    //
17957    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
17958    //      ==> 2^(alpha - e - 1) <= c
17959    //
17960    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
17961    //
17962    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
17963    //        = ceil( (alpha - e - 1) * log_10(2) )
17964    //
17965    // From the paper:
17966    // "In theory the result of the procedure could be wrong since c is rounded,
17967    //  and the computation itself is approximated [...]. In practice, however,
17968    //  this simple function is sufficient."
17969    //
17970    // For IEEE double precision floating-point numbers converted into
17971    // normalized diyfp's w = f * 2^e, with q = 64,
17972    //
17973    //      e >= -1022      (min IEEE exponent)
17974    //           -52        (p - 1)
17975    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
17976    //           -11        (normalize the diyfp)
17977    //         = -1137
17978    //
17979    // and
17980    //
17981    //      e <= +1023      (max IEEE exponent)
17982    //           -52        (p - 1)
17983    //           -11        (normalize the diyfp)
17984    //         = 960
17985    //
17986    // This binary exponent range [-1137,960] results in a decimal exponent
17987    // range [-307,324]. One does not need to store a cached power for each
17988    // k in this range. For each such k it suffices to find a cached power
17989    // such that the exponent of the product lies in [alpha,gamma].
17990    // This implies that the difference of the decimal exponents of adjacent
17991    // table entries must be less than or equal to
17992    //
17993    //      floor( (gamma - alpha) * log_10(2) ) = 8.
17994    //
17995    // (A smaller distance gamma-alpha would require a larger table.)
17996
17997    // NB:
17998    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
17999
18000    constexpr int kCachedPowersMinDecExp = -300;
18001    constexpr int kCachedPowersDecStep = 8;
18002
18003    static constexpr std::array<cached_power, 79> kCachedPowers =
18004    {
18005        {
18006            { 0xAB70FE17C79AC6CA, -1060, -300 },
18007            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
18008            { 0xBE5691EF416BD60C, -1007, -284 },
18009            { 0x8DD01FAD907FFC3C,  -980, -276 },
18010            { 0xD3515C2831559A83,  -954, -268 },
18011            { 0x9D71AC8FADA6C9B5,  -927, -260 },
18012            { 0xEA9C227723EE8BCB,  -901, -252 },
18013            { 0xAECC49914078536D,  -874, -244 },
18014            { 0x823C12795DB6CE57,  -847, -236 },
18015            { 0xC21094364DFB5637,  -821, -228 },
18016            { 0x9096EA6F3848984F,  -794, -220 },
18017            { 0xD77485CB25823AC7,  -768, -212 },
18018            { 0xA086CFCD97BF97F4,  -741, -204 },
18019            { 0xEF340A98172AACE5,  -715, -196 },
18020            { 0xB23867FB2A35B28E,  -688, -188 },
18021            { 0x84C8D4DFD2C63F3B,  -661, -180 },
18022            { 0xC5DD44271AD3CDBA,  -635, -172 },
18023            { 0x936B9FCEBB25C996,  -608, -164 },
18024            { 0xDBAC6C247D62A584,  -582, -156 },
18025            { 0xA3AB66580D5FDAF6,  -555, -148 },
18026            { 0xF3E2F893DEC3F126,  -529, -140 },
18027            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
18028            { 0x87625F056C7C4A8B,  -475, -124 },
18029            { 0xC9BCFF6034C13053,  -449, -116 },
18030            { 0x964E858C91BA2655,  -422, -108 },
18031            { 0xDFF9772470297EBD,  -396, -100 },
18032            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
18033            { 0xF8A95FCF88747D94,  -343,  -84 },
18034            { 0xB94470938FA89BCF,  -316,  -76 },
18035            { 0x8A08F0F8BF0F156B,  -289,  -68 },
18036            { 0xCDB02555653131B6,  -263,  -60 },
18037            { 0x993FE2C6D07B7FAC,  -236,  -52 },
18038            { 0xE45C10C42A2B3B06,  -210,  -44 },
18039            { 0xAA242499697392D3,  -183,  -36 },
18040            { 0xFD87B5F28300CA0E,  -157,  -28 },
18041            { 0xBCE5086492111AEB,  -130,  -20 },
18042            { 0x8CBCCC096F5088CC,  -103,  -12 },
18043            { 0xD1B71758E219652C,   -77,   -4 },
18044            { 0x9C40000000000000,   -50,    4 },
18045            { 0xE8D4A51000000000,   -24,   12 },
18046            { 0xAD78EBC5AC620000,     3,   20 },
18047            { 0x813F3978F8940984,    30,   28 },
18048            { 0xC097CE7BC90715B3,    56,   36 },
18049            { 0x8F7E32CE7BEA5C70,    83,   44 },
18050            { 0xD5D238A4ABE98068,   109,   52 },
18051            { 0x9F4F2726179A2245,   136,   60 },
18052            { 0xED63A231D4C4FB27,   162,   68 },
18053            { 0xB0DE65388CC8ADA8,   189,   76 },
18054            { 0x83C7088E1AAB65DB,   216,   84 },
18055            { 0xC45D1DF942711D9A,   242,   92 },
18056            { 0x924D692CA61BE758,   269,  100 },
18057            { 0xDA01EE641A708DEA,   295,  108 },
18058            { 0xA26DA3999AEF774A,   322,  116 },
18059            { 0xF209787BB47D6B85,   348,  124 },
18060            { 0xB454E4A179DD1877,   375,  132 },
18061            { 0x865B86925B9BC5C2,   402,  140 },
18062            { 0xC83553C5C8965D3D,   428,  148 },
18063            { 0x952AB45CFA97A0B3,   455,  156 },
18064            { 0xDE469FBD99A05FE3,   481,  164 },
18065            { 0xA59BC234DB398C25,   508,  172 },
18066            { 0xF6C69A72A3989F5C,   534,  180 },
18067            { 0xB7DCBF5354E9BECE,   561,  188 },
18068            { 0x88FCF317F22241E2,   588,  196 },
18069            { 0xCC20CE9BD35C78A5,   614,  204 },
18070            { 0x98165AF37B2153DF,   641,  212 },
18071            { 0xE2A0B5DC971F303A,   667,  220 },
18072            { 0xA8D9D1535CE3B396,   694,  228 },
18073            { 0xFB9B7CD9A4A7443C,   720,  236 },
18074            { 0xBB764C4CA7A44410,   747,  244 },
18075            { 0x8BAB8EEFB6409C1A,   774,  252 },
18076            { 0xD01FEF10A657842C,   800,  260 },
18077            { 0x9B10A4E5E9913129,   827,  268 },
18078            { 0xE7109BFBA19C0C9D,   853,  276 },
18079            { 0xAC2820D9623BF429,   880,  284 },
18080            { 0x80444B5E7AA7CF85,   907,  292 },
18081            { 0xBF21E44003ACDD2D,   933,  300 },
18082            { 0x8E679C2F5E44FF8F,   960,  308 },
18083            { 0xD433179D9C8CB841,   986,  316 },
18084            { 0x9E19DB92B4E31BA9,  1013,  324 },
18085        }
18086    };
18087
18088    // This computation gives exactly the same results for k as
18089    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
18090    // for |e| <= 1500, but doesn't require floating-point operations.
18091    // NB: log_10(2) ~= 78913 / 2^18
18092    JSON_ASSERT(e >= -1500);
18093    JSON_ASSERT(e <=  1500);
18094    const int f = kAlpha - e - 1;
18095    const int k = ((f * 78913) / (1 << 18)) + static_cast<int>(f > 0);
18096
18097    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
18098    JSON_ASSERT(index >= 0);
18099    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
18100
18101    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
18102    JSON_ASSERT(kAlpha <= cached.e + e + 64);
18103    JSON_ASSERT(kGamma >= cached.e + e + 64);
18104
18105    return cached;
18106}
18107
18108/*!
18109For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
18110For n == 0, returns 1 and sets pow10 := 1.
18111*/
18112inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
18113{
18114    // LCOV_EXCL_START
18115    if (n >= 1000000000)
18116    {
18117        pow10 = 1000000000;
18118        return 10;
18119    }
18120    // LCOV_EXCL_STOP
18121    if (n >= 100000000)
18122    {
18123        pow10 = 100000000;
18124        return  9;
18125    }
18126    if (n >= 10000000)
18127    {
18128        pow10 = 10000000;
18129        return  8;
18130    }
18131    if (n >= 1000000)
18132    {
18133        pow10 = 1000000;
18134        return  7;
18135    }
18136    if (n >= 100000)
18137    {
18138        pow10 = 100000;
18139        return  6;
18140    }
18141    if (n >= 10000)
18142    {
18143        pow10 = 10000;
18144        return  5;
18145    }
18146    if (n >= 1000)
18147    {
18148        pow10 = 1000;
18149        return  4;
18150    }
18151    if (n >= 100)
18152    {
18153        pow10 = 100;
18154        return  3;
18155    }
18156    if (n >= 10)
18157    {
18158        pow10 = 10;
18159        return  2;
18160    }
18161
18162    pow10 = 1;
18163    return 1;
18164}
18165
18166inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
18167                         std::uint64_t rest, std::uint64_t ten_k)
18168{
18169    JSON_ASSERT(len >= 1);
18170    JSON_ASSERT(dist <= delta);
18171    JSON_ASSERT(rest <= delta);
18172    JSON_ASSERT(ten_k > 0);
18173
18174    //               <--------------------------- delta ---->
18175    //                                  <---- dist --------->
18176    // --------------[------------------+-------------------]--------------
18177    //               M-                 w                   M+
18178    //
18179    //                                  ten_k
18180    //                                <------>
18181    //                                       <---- rest ---->
18182    // --------------[------------------+----+--------------]--------------
18183    //                                  w    V
18184    //                                       = buf * 10^k
18185    //
18186    // ten_k represents a unit-in-the-last-place in the decimal representation
18187    // stored in buf.
18188    // Decrement buf by ten_k while this takes buf closer to w.
18189
18190    // The tests are written in this order to avoid overflow in unsigned
18191    // integer arithmetic.
18192
18193    while (rest < dist
18194            && delta - rest >= ten_k
18195            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
18196    {
18197        JSON_ASSERT(buf[len - 1] != '0');
18198        buf[len - 1]--;
18199        rest += ten_k;
18200    }
18201}
18202
18203/*!
18204Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
18205M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
18206*/
18207inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
18208                             diyfp M_minus, diyfp w, diyfp M_plus)
18209{
18210    static_assert(kAlpha >= -60, "internal error");
18211    static_assert(kGamma <= -32, "internal error");
18212
18213    // Generates the digits (and the exponent) of a decimal floating-point
18214    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
18215    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
18216    //
18217    //               <--------------------------- delta ---->
18218    //                                  <---- dist --------->
18219    // --------------[------------------+-------------------]--------------
18220    //               M-                 w                   M+
18221    //
18222    // Grisu2 generates the digits of M+ from left to right and stops as soon as
18223    // V is in [M-,M+].
18224
18225    JSON_ASSERT(M_plus.e >= kAlpha);
18226    JSON_ASSERT(M_plus.e <= kGamma);
18227
18228    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
18229    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
18230
18231    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
18232    //
18233    //      M+ = f * 2^e
18234    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
18235    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
18236    //         = p1 + p2 * 2^e
18237
18238    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
18239
18240    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.)
18241    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
18242
18243    // 1)
18244    //
18245    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
18246
18247    JSON_ASSERT(p1 > 0);
18248
18249    std::uint32_t pow10{};
18250    const int k = find_largest_pow10(p1, pow10);
18251
18252    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
18253    //
18254    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
18255    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
18256    //
18257    //      M+ = p1                                             + p2 * 2^e
18258    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
18259    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
18260    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
18261    //
18262    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
18263    //
18264    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
18265    //
18266    // but stop as soon as
18267    //
18268    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
18269
18270    int n = k;
18271    while (n > 0)
18272    {
18273        // Invariants:
18274        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
18275        //      pow10 = 10^(n-1) <= p1 < 10^n
18276        //
18277        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
18278        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
18279        //
18280        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
18281        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
18282        //
18283        JSON_ASSERT(d <= 9);
18284        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
18285        //
18286        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
18287        //
18288        p1 = r;
18289        n--;
18290        //
18291        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
18292        //      pow10 = 10^n
18293        //
18294
18295        // Now check if enough digits have been generated.
18296        // Compute
18297        //
18298        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
18299        //
18300        // Note:
18301        // Since rest and delta share the same exponent e, it suffices to
18302        // compare the significands.
18303        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
18304        if (rest <= delta)
18305        {
18306            // V = buffer * 10^n, with M- <= V <= M+.
18307
18308            decimal_exponent += n;
18309
18310            // We may now just stop. But instead look if the buffer could be
18311            // decremented to bring V closer to w.
18312            //
18313            // pow10 = 10^n is now 1 ulp in the decimal representation V.
18314            // The rounding procedure works with diyfp's with an implicit
18315            // exponent of e.
18316            //
18317            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
18318            //
18319            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
18320            grisu2_round(buffer, length, dist, delta, rest, ten_n);
18321
18322            return;
18323        }
18324
18325        pow10 /= 10;
18326        //
18327        //      pow10 = 10^(n-1) <= p1 < 10^n
18328        // Invariants restored.
18329    }
18330
18331    // 2)
18332    //
18333    // The digits of the integral part have been generated:
18334    //
18335    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
18336    //         = buffer            + p2 * 2^e
18337    //
18338    // Now generate the digits of the fractional part p2 * 2^e.
18339    //
18340    // Note:
18341    // No decimal point is generated: the exponent is adjusted instead.
18342    //
18343    // p2 actually represents the fraction
18344    //
18345    //      p2 * 2^e
18346    //          = p2 / 2^-e
18347    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
18348    //
18349    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
18350    //
18351    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
18352    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
18353    //
18354    // using
18355    //
18356    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
18357    //                = (                   d) * 2^-e + (                   r)
18358    //
18359    // or
18360    //      10^m * p2 * 2^e = d + r * 2^e
18361    //
18362    // i.e.
18363    //
18364    //      M+ = buffer + p2 * 2^e
18365    //         = buffer + 10^-m * (d + r * 2^e)
18366    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
18367    //
18368    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
18369
18370    JSON_ASSERT(p2 > delta);
18371
18372    int m = 0;
18373    for (;;)
18374    {
18375        // Invariant:
18376        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
18377        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
18378        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
18379        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
18380        //
18381        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
18382        p2 *= 10;
18383        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
18384        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
18385        //
18386        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
18387        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
18388        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
18389        //
18390        JSON_ASSERT(d <= 9);
18391        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
18392        //
18393        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
18394        //
18395        p2 = r;
18396        m++;
18397        //
18398        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
18399        // Invariant restored.
18400
18401        // Check if enough digits have been generated.
18402        //
18403        //      10^-m * p2 * 2^e <= delta * 2^e
18404        //              p2 * 2^e <= 10^m * delta * 2^e
18405        //                    p2 <= 10^m * delta
18406        delta *= 10;
18407        dist  *= 10;
18408        if (p2 <= delta)
18409        {
18410            break;
18411        }
18412    }
18413
18414    // V = buffer * 10^-m, with M- <= V <= M+.
18415
18416    decimal_exponent -= m;
18417
18418    // 1 ulp in the decimal representation is now 10^-m.
18419    // Since delta and dist are now scaled by 10^m, we need to do the
18420    // same with ulp in order to keep the units in sync.
18421    //
18422    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
18423    //
18424    const std::uint64_t ten_m = one.f;
18425    grisu2_round(buffer, length, dist, delta, p2, ten_m);
18426
18427    // By construction this algorithm generates the shortest possible decimal
18428    // number (Loitsch, Theorem 6.2) which rounds back to w.
18429    // For an input number of precision p, at least
18430    //
18431    //      N = 1 + ceil(p * log_10(2))
18432    //
18433    // decimal digits are sufficient to identify all binary floating-point
18434    // numbers (Matula, "In-and-Out conversions").
18435    // This implies that the algorithm does not produce more than N decimal
18436    // digits.
18437    //
18438    //      N = 17 for p = 53 (IEEE double precision)
18439    //      N = 9  for p = 24 (IEEE single precision)
18440}
18441
18442/*!
18443v = buf * 10^decimal_exponent
18444len is the length of the buffer (number of decimal digits)
18445The buffer must be large enough, i.e. >= max_digits10.
18446*/
18447JSON_HEDLEY_NON_NULL(1)
18448inline void grisu2(char* buf, int& len, int& decimal_exponent,
18449                   diyfp m_minus, diyfp v, diyfp m_plus)
18450{
18451    JSON_ASSERT(m_plus.e == m_minus.e);
18452    JSON_ASSERT(m_plus.e == v.e);
18453
18454    //  --------(-----------------------+-----------------------)--------    (A)
18455    //          m-                      v                       m+
18456    //
18457    //  --------------------(-----------+-----------------------)--------    (B)
18458    //                      m-          v                       m+
18459    //
18460    // First scale v (and m- and m+) such that the exponent is in the range
18461    // [alpha, gamma].
18462
18463    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
18464
18465    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
18466
18467    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
18468    const diyfp w       = diyfp::mul(v,       c_minus_k);
18469    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
18470    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
18471
18472    //  ----(---+---)---------------(---+---)---------------(---+---)----
18473    //          w-                      w                       w+
18474    //          = c*m-                  = c*v                   = c*m+
18475    //
18476    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
18477    // w+ are now off by a small amount.
18478    // In fact:
18479    //
18480    //      w - v * 10^k < 1 ulp
18481    //
18482    // To account for this inaccuracy, add resp. subtract 1 ulp.
18483    //
18484    //  --------+---[---------------(---+---)---------------]---+--------
18485    //          w-  M-                  w                   M+  w+
18486    //
18487    // Now any number in [M-, M+] (bounds included) will round to w when input,
18488    // regardless of how the input rounding algorithm breaks ties.
18489    //
18490    // And digit_gen generates the shortest possible such number in [M-, M+].
18491    // Note that this does not mean that Grisu2 always generates the shortest
18492    // possible number in the interval (m-, m+).
18493    const diyfp M_minus(w_minus.f + 1, w_minus.e);
18494    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
18495
18496    decimal_exponent = -cached.k; // = -(-k) = k
18497
18498    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
18499}
18500
18501/*!
18502v = buf * 10^decimal_exponent
18503len is the length of the buffer (number of decimal digits)
18504The buffer must be large enough, i.e. >= max_digits10.
18505*/
18506template<typename FloatType>
18507JSON_HEDLEY_NON_NULL(1)
18508void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
18509{
18510    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
18511                  "internal error: not enough precision");
18512
18513    JSON_ASSERT(std::isfinite(value));
18514    JSON_ASSERT(value > 0);
18515
18516    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
18517    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
18518    // decimal representations are not exactly "short".
18519    //
18520    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
18521    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
18522    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
18523    // does.
18524    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
18525    // representation using the corresponding std::from_chars function recovers value exactly". That
18526    // indicates that single precision floating-point numbers should be recovered using
18527    // 'std::strtof'.
18528    //
18529    // NB: If the neighbors are computed for single-precision numbers, there is a single float
18530    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
18531    //     value is off by 1 ulp.
18532#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
18533    const boundaries w = compute_boundaries(static_cast<double>(value));
18534#else
18535    const boundaries w = compute_boundaries(value);
18536#endif
18537
18538    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
18539}
18540
18541/*!
18542@brief appends a decimal representation of e to buf
18543@return a pointer to the element following the exponent.
18544@pre -1000 < e < 1000
18545*/
18546JSON_HEDLEY_NON_NULL(1)
18547JSON_HEDLEY_RETURNS_NON_NULL
18548inline char* append_exponent(char* buf, int e)
18549{
18550    JSON_ASSERT(e > -1000);
18551    JSON_ASSERT(e <  1000);
18552
18553    if (e < 0)
18554    {
18555        e = -e;
18556        *buf++ = '-';
18557    }
18558    else
18559    {
18560        *buf++ = '+';
18561    }
18562
18563    auto k = static_cast<std::uint32_t>(e);
18564    if (k < 10)
18565    {
18566        // Always print at least two digits in the exponent.
18567        // This is for compatibility with printf("%g").
18568        *buf++ = '0';
18569        *buf++ = static_cast<char>('0' + k);
18570    }
18571    else if (k < 100)
18572    {
18573        *buf++ = static_cast<char>('0' + (k / 10));
18574        k %= 10;
18575        *buf++ = static_cast<char>('0' + k);
18576    }
18577    else
18578    {
18579        *buf++ = static_cast<char>('0' + (k / 100));
18580        k %= 100;
18581        *buf++ = static_cast<char>('0' + (k / 10));
18582        k %= 10;
18583        *buf++ = static_cast<char>('0' + k);
18584    }
18585
18586    return buf;
18587}
18588
18589/*!
18590@brief prettify v = buf * 10^decimal_exponent
18591
18592If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
18593notation. Otherwise it will be printed in exponential notation.
18594
18595@pre min_exp < 0
18596@pre max_exp > 0
18597*/
18598JSON_HEDLEY_NON_NULL(1)
18599JSON_HEDLEY_RETURNS_NON_NULL
18600inline char* format_buffer(char* buf, int len, int decimal_exponent,
18601                           int min_exp, int max_exp)
18602{
18603    JSON_ASSERT(min_exp < 0);
18604    JSON_ASSERT(max_exp > 0);
18605
18606    const int k = len;
18607    const int n = len + decimal_exponent;
18608
18609    // v = buf * 10^(n-k)
18610    // k is the length of the buffer (number of decimal digits)
18611    // n is the position of the decimal point relative to the start of the buffer.
18612
18613    if (k <= n && n <= max_exp)
18614    {
18615        // digits[000]
18616        // len <= max_exp + 2
18617
18618        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
18619        // Make it look like a floating-point number (#362, #378)
18620        buf[n + 0] = '.';
18621        buf[n + 1] = '0';
18622        return buf + (static_cast<size_t>(n) + 2);
18623    }
18624
18625    if (0 < n && n <= max_exp)
18626    {
18627        // dig.its
18628        // len <= max_digits10 + 1
18629
18630        JSON_ASSERT(k > n);
18631
18632        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
18633        buf[n] = '.';
18634        return buf + (static_cast<size_t>(k) + 1U);
18635    }
18636
18637    if (min_exp < n && n <= 0)
18638    {
18639        // 0.[000]digits
18640        // len <= 2 + (-min_exp - 1) + max_digits10
18641
18642        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
18643        buf[0] = '0';
18644        buf[1] = '.';
18645        std::memset(buf + 2, '0', static_cast<size_t>(-n));
18646        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
18647    }
18648
18649    if (k == 1)
18650    {
18651        // dE+123
18652        // len <= 1 + 5
18653
18654        buf += 1;
18655    }
18656    else
18657    {
18658        // d.igitsE+123
18659        // len <= max_digits10 + 1 + 5
18660
18661        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
18662        buf[1] = '.';
18663        buf += 1 + static_cast<size_t>(k);
18664    }
18665
18666    *buf++ = 'e';
18667    return append_exponent(buf, n - 1);
18668}
18669
18670}  // namespace dtoa_impl
18671
18672/*!
18673@brief generates a decimal representation of the floating-point number value in [first, last).
18674
18675The format of the resulting decimal representation is similar to printf's %g
18676format. Returns an iterator pointing past-the-end of the decimal representation.
18677
18678@note The input number must be finite, i.e. NaN's and Inf's are not supported.
18679@note The buffer must be large enough.
18680@note The result is NOT null-terminated.
18681*/
18682template<typename FloatType>
18683JSON_HEDLEY_NON_NULL(1, 2)
18684JSON_HEDLEY_RETURNS_NON_NULL
18685char* to_chars(char* first, const char* last, FloatType value)
18686{
18687    static_cast<void>(last); // maybe unused - fix warning
18688    JSON_ASSERT(std::isfinite(value));
18689
18690    // Use signbit(value) instead of (value < 0) since signbit works for -0.
18691    if (std::signbit(value))
18692    {
18693        value = -value;
18694        *first++ = '-';
18695    }
18696
18697#ifdef __GNUC__
18698#pragma GCC diagnostic push
18699#pragma GCC diagnostic ignored "-Wfloat-equal"
18700#endif
18701    if (value == 0) // +-0
18702    {
18703        *first++ = '0';
18704        // Make it look like a floating-point number (#362, #378)
18705        *first++ = '.';
18706        *first++ = '0';
18707        return first;
18708    }
18709#ifdef __GNUC__
18710#pragma GCC diagnostic pop
18711#endif
18712
18713    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
18714
18715    // Compute v = buffer * 10^decimal_exponent.
18716    // The decimal digits are stored in the buffer, which needs to be interpreted
18717    // as an unsigned decimal integer.
18718    // len is the length of the buffer, i.e. the number of decimal digits.
18719    int len = 0;
18720    int decimal_exponent = 0;
18721    dtoa_impl::grisu2(first, len, decimal_exponent, value);
18722
18723    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
18724
18725    // Format the buffer like printf("%.*g", prec, value)
18726    constexpr int kMinExp = -4;
18727    // Use digits10 here to increase compatibility with version 2.
18728    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
18729
18730    JSON_ASSERT(last - first >= kMaxExp + 2);
18731    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
18732    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
18733
18734    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
18735}
18736
18737}  // namespace detail
18738NLOHMANN_JSON_NAMESPACE_END
18739
18740// #include <nlohmann/detail/exceptions.hpp>
18741
18742// #include <nlohmann/detail/macro_scope.hpp>
18743
18744// #include <nlohmann/detail/meta/cpp_future.hpp>
18745
18746// #include <nlohmann/detail/output/binary_writer.hpp>
18747
18748// #include <nlohmann/detail/output/output_adapters.hpp>
18749
18750// #include <nlohmann/detail/string_concat.hpp>
18751
18752// #include <nlohmann/detail/value_t.hpp>
18753
18754
18755NLOHMANN_JSON_NAMESPACE_BEGIN
18756namespace detail
18757{
18758
18759///////////////////
18760// serialization //
18761///////////////////
18762
18763/// how to treat decoding errors
18764enum class error_handler_t
18765{
18766    strict,  ///< throw a type_error exception in case of invalid UTF-8
18767    replace, ///< replace invalid UTF-8 sequences with U+FFFD
18768    ignore   ///< ignore invalid UTF-8 sequences
18769};
18770
18771template<typename BasicJsonType>
18772class serializer
18773{
18774    using string_t = typename BasicJsonType::string_t;
18775    using number_float_t = typename BasicJsonType::number_float_t;
18776    using number_integer_t = typename BasicJsonType::number_integer_t;
18777    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
18778    using binary_char_t = typename BasicJsonType::binary_t::value_type;
18779    static constexpr std::uint8_t UTF8_ACCEPT = 0;
18780    static constexpr std::uint8_t UTF8_REJECT = 1;
18781
18782  public:
18783    /*!
18784    @param[in] s  output stream to serialize to
18785    @param[in] ichar  indentation character to use
18786    @param[in] error_handler_  how to react on decoding errors
18787    */
18788    serializer(output_adapter_t<char> s, const char ichar,
18789               error_handler_t error_handler_ = error_handler_t::strict)
18790        : o(std::move(s))
18791        , loc(std::localeconv())
18792        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
18793        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
18794        , indent_char(ichar)
18795        , indent_string(512, indent_char)
18796        , error_handler(error_handler_)
18797    {}
18798
18799    // delete because of pointer members
18800    serializer(const serializer&) = delete;
18801    serializer& operator=(const serializer&) = delete;
18802    serializer(serializer&&) = delete;
18803    serializer& operator=(serializer&&) = delete;
18804    ~serializer() = default;
18805
18806    /*!
18807    @brief internal implementation of the serialization function
18808
18809    This function is called by the public member function dump and organizes
18810    the serialization internally. The indentation level is propagated as
18811    additional parameter. In case of arrays and objects, the function is
18812    called recursively.
18813
18814    - strings and object keys are escaped using `escape_string()`
18815    - integer numbers are converted implicitly via `operator<<`
18816    - floating-point numbers are converted to a string using `"%g"` format
18817    - binary values are serialized as objects containing the subtype and the
18818      byte array
18819
18820    @param[in] val               value to serialize
18821    @param[in] pretty_print      whether the output shall be pretty-printed
18822    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
18823    in the output are escaped with `\uXXXX` sequences, and the result consists
18824    of ASCII characters only.
18825    @param[in] indent_step       the indent level
18826    @param[in] current_indent    the current indent level (only used internally)
18827    */
18828    void dump(const BasicJsonType& val,
18829              const bool pretty_print,
18830              const bool ensure_ascii,
18831              const unsigned int indent_step,
18832              const unsigned int current_indent = 0)
18833    {
18834        switch (val.m_data.m_type)
18835        {
18836            case value_t::object:
18837            {
18838                if (val.m_data.m_value.object->empty())
18839                {
18840                    o->write_characters("{}", 2);
18841                    return;
18842                }
18843
18844                if (pretty_print)
18845                {
18846                    o->write_characters("{\n", 2);
18847
18848                    // variable to hold indentation for recursive calls
18849                    const auto new_indent = current_indent + indent_step;
18850                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
18851                    {
18852                        indent_string.resize(indent_string.size() * 2, ' ');
18853                    }
18854
18855                    // first n-1 elements
18856                    auto i = val.m_data.m_value.object->cbegin();
18857                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
18858                    {
18859                        o->write_characters(indent_string.c_str(), new_indent);
18860                        o->write_character('\"');
18861                        dump_escaped(i->first, ensure_ascii);
18862                        o->write_characters("\": ", 3);
18863                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
18864                        o->write_characters(",\n", 2);
18865                    }
18866
18867                    // last element
18868                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
18869                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
18870                    o->write_characters(indent_string.c_str(), new_indent);
18871                    o->write_character('\"');
18872                    dump_escaped(i->first, ensure_ascii);
18873                    o->write_characters("\": ", 3);
18874                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
18875
18876                    o->write_character('\n');
18877                    o->write_characters(indent_string.c_str(), current_indent);
18878                    o->write_character('}');
18879                }
18880                else
18881                {
18882                    o->write_character('{');
18883
18884                    // first n-1 elements
18885                    auto i = val.m_data.m_value.object->cbegin();
18886                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
18887                    {
18888                        o->write_character('\"');
18889                        dump_escaped(i->first, ensure_ascii);
18890                        o->write_characters("\":", 2);
18891                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
18892                        o->write_character(',');
18893                    }
18894
18895                    // last element
18896                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
18897                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
18898                    o->write_character('\"');
18899                    dump_escaped(i->first, ensure_ascii);
18900                    o->write_characters("\":", 2);
18901                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
18902
18903                    o->write_character('}');
18904                }
18905
18906                return;
18907            }
18908
18909            case value_t::array:
18910            {
18911                if (val.m_data.m_value.array->empty())
18912                {
18913                    o->write_characters("[]", 2);
18914                    return;
18915                }
18916
18917                if (pretty_print)
18918                {
18919                    o->write_characters("[\n", 2);
18920
18921                    // variable to hold indentation for recursive calls
18922                    const auto new_indent = current_indent + indent_step;
18923                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
18924                    {
18925                        indent_string.resize(indent_string.size() * 2, ' ');
18926                    }
18927
18928                    // first n-1 elements
18929                    for (auto i = val.m_data.m_value.array->cbegin();
18930                            i != val.m_data.m_value.array->cend() - 1; ++i)
18931                    {
18932                        o->write_characters(indent_string.c_str(), new_indent);
18933                        dump(*i, true, ensure_ascii, indent_step, new_indent);
18934                        o->write_characters(",\n", 2);
18935                    }
18936
18937                    // last element
18938                    JSON_ASSERT(!val.m_data.m_value.array->empty());
18939                    o->write_characters(indent_string.c_str(), new_indent);
18940                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
18941
18942                    o->write_character('\n');
18943                    o->write_characters(indent_string.c_str(), current_indent);
18944                    o->write_character(']');
18945                }
18946                else
18947                {
18948                    o->write_character('[');
18949
18950                    // first n-1 elements
18951                    for (auto i = val.m_data.m_value.array->cbegin();
18952                            i != val.m_data.m_value.array->cend() - 1; ++i)
18953                    {
18954                        dump(*i, false, ensure_ascii, indent_step, current_indent);
18955                        o->write_character(',');
18956                    }
18957
18958                    // last element
18959                    JSON_ASSERT(!val.m_data.m_value.array->empty());
18960                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
18961
18962                    o->write_character(']');
18963                }
18964
18965                return;
18966            }
18967
18968            case value_t::string:
18969            {
18970                o->write_character('\"');
18971                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
18972                o->write_character('\"');
18973                return;
18974            }
18975
18976            case value_t::binary:
18977            {
18978                if (pretty_print)
18979                {
18980                    o->write_characters("{\n", 2);
18981
18982                    // variable to hold indentation for recursive calls
18983                    const auto new_indent = current_indent + indent_step;
18984                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
18985                    {
18986                        indent_string.resize(indent_string.size() * 2, ' ');
18987                    }
18988
18989                    o->write_characters(indent_string.c_str(), new_indent);
18990
18991                    o->write_characters("\"bytes\": [", 10);
18992
18993                    if (!val.m_data.m_value.binary->empty())
18994                    {
18995                        for (auto i = val.m_data.m_value.binary->cbegin();
18996                                i != val.m_data.m_value.binary->cend() - 1; ++i)
18997                        {
18998                            dump_integer(*i);
18999                            o->write_characters(", ", 2);
19000                        }
19001                        dump_integer(val.m_data.m_value.binary->back());
19002                    }
19003
19004                    o->write_characters("],\n", 3);
19005                    o->write_characters(indent_string.c_str(), new_indent);
19006
19007                    o->write_characters("\"subtype\": ", 11);
19008                    if (val.m_data.m_value.binary->has_subtype())
19009                    {
19010                        dump_integer(val.m_data.m_value.binary->subtype());
19011                    }
19012                    else
19013                    {
19014                        o->write_characters("null", 4);
19015                    }
19016                    o->write_character('\n');
19017                    o->write_characters(indent_string.c_str(), current_indent);
19018                    o->write_character('}');
19019                }
19020                else
19021                {
19022                    o->write_characters("{\"bytes\":[", 10);
19023
19024                    if (!val.m_data.m_value.binary->empty())
19025                    {
19026                        for (auto i = val.m_data.m_value.binary->cbegin();
19027                                i != val.m_data.m_value.binary->cend() - 1; ++i)
19028                        {
19029                            dump_integer(*i);
19030                            o->write_character(',');
19031                        }
19032                        dump_integer(val.m_data.m_value.binary->back());
19033                    }
19034
19035                    o->write_characters("],\"subtype\":", 12);
19036                    if (val.m_data.m_value.binary->has_subtype())
19037                    {
19038                        dump_integer(val.m_data.m_value.binary->subtype());
19039                        o->write_character('}');
19040                    }
19041                    else
19042                    {
19043                        o->write_characters("null}", 5);
19044                    }
19045                }
19046                return;
19047            }
19048
19049            case value_t::boolean:
19050            {
19051                if (val.m_data.m_value.boolean)
19052                {
19053                    o->write_characters("true", 4);
19054                }
19055                else
19056                {
19057                    o->write_characters("false", 5);
19058                }
19059                return;
19060            }
19061
19062            case value_t::number_integer:
19063            {
19064                dump_integer(val.m_data.m_value.number_integer);
19065                return;
19066            }
19067
19068            case value_t::number_unsigned:
19069            {
19070                dump_integer(val.m_data.m_value.number_unsigned);
19071                return;
19072            }
19073
19074            case value_t::number_float:
19075            {
19076                dump_float(val.m_data.m_value.number_float);
19077                return;
19078            }
19079
19080            case value_t::discarded:
19081            {
19082                o->write_characters("<discarded>", 11);
19083                return;
19084            }
19085
19086            case value_t::null:
19087            {
19088                o->write_characters("null", 4);
19089                return;
19090            }
19091
19092            default:            // LCOV_EXCL_LINE
19093                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
19094        }
19095    }
19096
19097  JSON_PRIVATE_UNLESS_TESTED:
19098    /*!
19099    @brief dump escaped string
19100
19101    Escape a string by replacing certain special characters by a sequence of an
19102    escape character (backslash) and another character and other control
19103    characters by a sequence of "\u" followed by a four-digit hex
19104    representation. The escaped string is written to output stream @a o.
19105
19106    @param[in] s  the string to escape
19107    @param[in] ensure_ascii  whether to escape non-ASCII characters with
19108                             \uXXXX sequences
19109
19110    @complexity Linear in the length of string @a s.
19111    */
19112    void dump_escaped(const string_t& s, const bool ensure_ascii)
19113    {
19114        std::uint32_t codepoint{};
19115        std::uint8_t state = UTF8_ACCEPT;
19116        std::size_t bytes = 0;  // number of bytes written to string_buffer
19117
19118        // number of bytes written at the point of the last valid byte
19119        std::size_t bytes_after_last_accept = 0;
19120        std::size_t undumped_chars = 0;
19121
19122        for (std::size_t i = 0; i < s.size(); ++i)
19123        {
19124            const auto byte = static_cast<std::uint8_t>(s[i]);
19125
19126            switch (decode(state, codepoint, byte))
19127            {
19128                case UTF8_ACCEPT:  // decode found a new code point
19129                {
19130                    switch (codepoint)
19131                    {
19132                        case 0x08: // backspace
19133                        {
19134                            string_buffer[bytes++] = '\\';
19135                            string_buffer[bytes++] = 'b';
19136                            break;
19137                        }
19138
19139                        case 0x09: // horizontal tab
19140                        {
19141                            string_buffer[bytes++] = '\\';
19142                            string_buffer[bytes++] = 't';
19143                            break;
19144                        }
19145
19146                        case 0x0A: // newline
19147                        {
19148                            string_buffer[bytes++] = '\\';
19149                            string_buffer[bytes++] = 'n';
19150                            break;
19151                        }
19152
19153                        case 0x0C: // formfeed
19154                        {
19155                            string_buffer[bytes++] = '\\';
19156                            string_buffer[bytes++] = 'f';
19157                            break;
19158                        }
19159
19160                        case 0x0D: // carriage return
19161                        {
19162                            string_buffer[bytes++] = '\\';
19163                            string_buffer[bytes++] = 'r';
19164                            break;
19165                        }
19166
19167                        case 0x22: // quotation mark
19168                        {
19169                            string_buffer[bytes++] = '\\';
19170                            string_buffer[bytes++] = '\"';
19171                            break;
19172                        }
19173
19174                        case 0x5C: // reverse solidus
19175                        {
19176                            string_buffer[bytes++] = '\\';
19177                            string_buffer[bytes++] = '\\';
19178                            break;
19179                        }
19180
19181                        default:
19182                        {
19183                            // escape control characters (0x00..0x1F) or, if
19184                            // ensure_ascii parameter is used, non-ASCII characters
19185                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
19186                            {
19187                                if (codepoint <= 0xFFFF)
19188                                {
19189                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
19190                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
19191                                                                      static_cast<std::uint16_t>(codepoint)));
19192                                    bytes += 6;
19193                                }
19194                                else
19195                                {
19196                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
19197                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
19198                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
19199                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
19200                                    bytes += 12;
19201                                }
19202                            }
19203                            else
19204                            {
19205                                // copy byte to buffer (all previous bytes
19206                                // been copied have in default case above)
19207                                string_buffer[bytes++] = s[i];
19208                            }
19209                            break;
19210                        }
19211                    }
19212
19213                    // write buffer and reset index; there must be 13 bytes
19214                    // left, as this is the maximal number of bytes to be
19215                    // written ("\uxxxx\uxxxx\0") for one code point
19216                    if (string_buffer.size() - bytes < 13)
19217                    {
19218                        o->write_characters(string_buffer.data(), bytes);
19219                        bytes = 0;
19220                    }
19221
19222                    // remember the byte position of this accept
19223                    bytes_after_last_accept = bytes;
19224                    undumped_chars = 0;
19225                    break;
19226                }
19227
19228                case UTF8_REJECT:  // decode found invalid UTF-8 byte
19229                {
19230                    switch (error_handler)
19231                    {
19232                        case error_handler_t::strict:
19233                        {
19234                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
19235                        }
19236
19237                        case error_handler_t::ignore:
19238                        case error_handler_t::replace:
19239                        {
19240                            // in case we saw this character the first time, we
19241                            // would like to read it again, because the byte
19242                            // may be OK for itself, but just not OK for the
19243                            // previous sequence
19244                            if (undumped_chars > 0)
19245                            {
19246                                --i;
19247                            }
19248
19249                            // reset length buffer to the last accepted index;
19250                            // thus removing/ignoring the invalid characters
19251                            bytes = bytes_after_last_accept;
19252
19253                            if (error_handler == error_handler_t::replace)
19254                            {
19255                                // add a replacement character
19256                                if (ensure_ascii)
19257                                {
19258                                    string_buffer[bytes++] = '\\';
19259                                    string_buffer[bytes++] = 'u';
19260                                    string_buffer[bytes++] = 'f';
19261                                    string_buffer[bytes++] = 'f';
19262                                    string_buffer[bytes++] = 'f';
19263                                    string_buffer[bytes++] = 'd';
19264                                }
19265                                else
19266                                {
19267                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
19268                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
19269                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
19270                                }
19271
19272                                // write buffer and reset index; there must be 13 bytes
19273                                // left, as this is the maximal number of bytes to be
19274                                // written ("\uxxxx\uxxxx\0") for one code point
19275                                if (string_buffer.size() - bytes < 13)
19276                                {
19277                                    o->write_characters(string_buffer.data(), bytes);
19278                                    bytes = 0;
19279                                }
19280
19281                                bytes_after_last_accept = bytes;
19282                            }
19283
19284                            undumped_chars = 0;
19285
19286                            // continue processing the string
19287                            state = UTF8_ACCEPT;
19288                            break;
19289                        }
19290
19291                        default:            // LCOV_EXCL_LINE
19292                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
19293                    }
19294                    break;
19295                }
19296
19297                default:  // decode found yet incomplete multi-byte code point
19298                {
19299                    if (!ensure_ascii)
19300                    {
19301                        // code point will not be escaped - copy byte to buffer
19302                        string_buffer[bytes++] = s[i];
19303                    }
19304                    ++undumped_chars;
19305                    break;
19306                }
19307            }
19308        }
19309
19310        // we finished processing the string
19311        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
19312        {
19313            // write buffer
19314            if (bytes > 0)
19315            {
19316                o->write_characters(string_buffer.data(), bytes);
19317            }
19318        }
19319        else
19320        {
19321            // we finish reading, but do not accept: string was incomplete
19322            switch (error_handler)
19323            {
19324                case error_handler_t::strict:
19325                {
19326                    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));
19327                }
19328
19329                case error_handler_t::ignore:
19330                {
19331                    // write all accepted bytes
19332                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
19333                    break;
19334                }
19335
19336                case error_handler_t::replace:
19337                {
19338                    // write all accepted bytes
19339                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
19340                    // add a replacement character
19341                    if (ensure_ascii)
19342                    {
19343                        o->write_characters("\\ufffd", 6);
19344                    }
19345                    else
19346                    {
19347                        o->write_characters("\xEF\xBF\xBD", 3);
19348                    }
19349                    break;
19350                }
19351
19352                default:            // LCOV_EXCL_LINE
19353                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
19354            }
19355        }
19356    }
19357
19358  private:
19359    /*!
19360    @brief count digits
19361
19362    Count the number of decimal (base 10) digits for an input unsigned integer.
19363
19364    @param[in] x  unsigned integer number to count its digits
19365    @return    number of decimal digits
19366    */
19367    unsigned int count_digits(number_unsigned_t x) noexcept
19368    {
19369        unsigned int n_digits = 1;
19370        for (;;)
19371        {
19372            if (x < 10)
19373            {
19374                return n_digits;
19375            }
19376            if (x < 100)
19377            {
19378                return n_digits + 1;
19379            }
19380            if (x < 1000)
19381            {
19382                return n_digits + 2;
19383            }
19384            if (x < 10000)
19385            {
19386                return n_digits + 3;
19387            }
19388            x = x / 10000u;
19389            n_digits += 4;
19390        }
19391    }
19392
19393    /*!
19394     * @brief convert a byte to a uppercase hex representation
19395     * @param[in] byte byte to represent
19396     * @return representation ("00".."FF")
19397     */
19398    static std::string hex_bytes(std::uint8_t byte)
19399    {
19400        std::string result = "FF";
19401        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
19402        result[0] = nibble_to_hex[byte / 16];
19403        result[1] = nibble_to_hex[byte % 16];
19404        return result;
19405    }
19406
19407    // templates to avoid warnings about useless casts
19408    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
19409    bool is_negative_number(NumberType x)
19410    {
19411        return x < 0;
19412    }
19413
19414    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
19415    bool is_negative_number(NumberType /*unused*/)
19416    {
19417        return false;
19418    }
19419
19420    /*!
19421    @brief dump an integer
19422
19423    Dump a given integer to output stream @a o. Works internally with
19424    @a number_buffer.
19425
19426    @param[in] x  integer number (signed or unsigned) to dump
19427    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
19428    */
19429    template < typename NumberType, detail::enable_if_t <
19430                   std::is_integral<NumberType>::value ||
19431                   std::is_same<NumberType, number_unsigned_t>::value ||
19432                   std::is_same<NumberType, number_integer_t>::value ||
19433                   std::is_same<NumberType, binary_char_t>::value,
19434                   int > = 0 >
19435    void dump_integer(NumberType x)
19436    {
19437        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
19438        {
19439            {
19440                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
19441                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
19442                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
19443                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
19444                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
19445                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
19446                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
19447                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
19448                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
19449                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
19450            }
19451        };
19452
19453        // special case for "0"
19454        if (x == 0)
19455        {
19456            o->write_character('0');
19457            return;
19458        }
19459
19460        // use a pointer to fill the buffer
19461        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
19462
19463        number_unsigned_t abs_value;
19464
19465        unsigned int n_chars{};
19466
19467        if (is_negative_number(x))
19468        {
19469            *buffer_ptr = '-';
19470            abs_value = remove_sign(static_cast<number_integer_t>(x));
19471
19472            // account one more byte for the minus sign
19473            n_chars = 1 + count_digits(abs_value);
19474        }
19475        else
19476        {
19477            abs_value = static_cast<number_unsigned_t>(x);
19478            n_chars = count_digits(abs_value);
19479        }
19480
19481        // spare 1 byte for '\0'
19482        JSON_ASSERT(n_chars < number_buffer.size() - 1);
19483
19484        // jump to the end to generate the string from backward,
19485        // so we later avoid reversing the result
19486        buffer_ptr += n_chars;
19487
19488        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
19489        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
19490        while (abs_value >= 100)
19491        {
19492            const auto digits_index = static_cast<unsigned>((abs_value % 100));
19493            abs_value /= 100;
19494            *(--buffer_ptr) = digits_to_99[digits_index][1];
19495            *(--buffer_ptr) = digits_to_99[digits_index][0];
19496        }
19497
19498        if (abs_value >= 10)
19499        {
19500            const auto digits_index = static_cast<unsigned>(abs_value);
19501            *(--buffer_ptr) = digits_to_99[digits_index][1];
19502            *(--buffer_ptr) = digits_to_99[digits_index][0];
19503        }
19504        else
19505        {
19506            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
19507        }
19508
19509        o->write_characters(number_buffer.data(), n_chars);
19510    }
19511
19512    /*!
19513    @brief dump a floating-point number
19514
19515    Dump a given floating-point number to output stream @a o. Works internally
19516    with @a number_buffer.
19517
19518    @param[in] x  floating-point number to dump
19519    */
19520    void dump_float(number_float_t x)
19521    {
19522        // NaN / inf
19523        if (!std::isfinite(x))
19524        {
19525            o->write_characters("null", 4);
19526            return;
19527        }
19528
19529        // If number_float_t is an IEEE-754 single or double precision number,
19530        // use the Grisu2 algorithm to produce short numbers which are
19531        // guaranteed to round-trip, using strtof and strtod, resp.
19532        //
19533        // NB: The test below works if <long double> == <double>.
19534        static constexpr bool is_ieee_single_or_double
19535            = (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) ||
19536              (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);
19537
19538        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
19539    }
19540
19541    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
19542    {
19543        auto* begin = number_buffer.data();
19544        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
19545
19546        o->write_characters(begin, static_cast<size_t>(end - begin));
19547    }
19548
19549    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
19550    {
19551        // get number of digits for a float -> text -> float round-trip
19552        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
19553
19554        // the actual conversion
19555        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
19556        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
19557
19558        // negative value indicates an error
19559        JSON_ASSERT(len > 0);
19560        // check if buffer was large enough
19561        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
19562
19563        // erase thousands separator
19564        if (thousands_sep != '\0')
19565        {
19566            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
19567            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
19568            std::fill(end, number_buffer.end(), '\0');
19569            JSON_ASSERT((end - number_buffer.begin()) <= len);
19570            len = (end - number_buffer.begin());
19571        }
19572
19573        // convert decimal point to '.'
19574        if (decimal_point != '\0' && decimal_point != '.')
19575        {
19576            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
19577            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
19578            if (dec_pos != number_buffer.end())
19579            {
19580                *dec_pos = '.';
19581            }
19582        }
19583
19584        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
19585
19586        // determine if we need to append ".0"
19587        const bool value_is_int_like =
19588            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
19589                         [](char c)
19590        {
19591            return c == '.' || c == 'e';
19592        });
19593
19594        if (value_is_int_like)
19595        {
19596            o->write_characters(".0", 2);
19597        }
19598    }
19599
19600    /*!
19601    @brief check whether a string is UTF-8 encoded
19602
19603    The function checks each byte of a string whether it is UTF-8 encoded. The
19604    result of the check is stored in the @a state parameter. The function must
19605    be called initially with state 0 (accept). State 1 means the string must
19606    be rejected, because the current byte is not allowed. If the string is
19607    completely processed, but the state is non-zero, the string ended
19608    prematurely; that is, the last byte indicated more bytes should have
19609    followed.
19610
19611    @param[in,out] state  the state of the decoding
19612    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
19613    @param[in] byte       next byte to decode
19614    @return               new state
19615
19616    @note The function has been edited: a std::array is used.
19617
19618    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
19619    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
19620    */
19621    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
19622    {
19623        static const std::array<std::uint8_t, 400> utf8d =
19624        {
19625            {
19626                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
19627                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
19628                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
19629                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
19630                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
19631                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
19632                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
19633                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
19634                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
19635                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
19636                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
19637                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
19638                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
19639                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
19640            }
19641        };
19642
19643        JSON_ASSERT(byte < utf8d.size());
19644        const std::uint8_t type = utf8d[byte];
19645
19646        codep = (state != UTF8_ACCEPT)
19647                ? (byte & 0x3fu) | (codep << 6u)
19648                : (0xFFu >> type) & (byte);
19649
19650        const std::size_t index = 256u + (static_cast<size_t>(state) * 16u) + static_cast<size_t>(type);
19651        JSON_ASSERT(index < utf8d.size());
19652        state = utf8d[index];
19653        return state;
19654    }
19655
19656    /*
19657     * Overload to make the compiler happy while it is instantiating
19658     * dump_integer for number_unsigned_t.
19659     * Must never be called.
19660     */
19661    number_unsigned_t remove_sign(number_unsigned_t x)
19662    {
19663        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
19664        return x; // LCOV_EXCL_LINE
19665    }
19666
19667    /*
19668     * Helper function for dump_integer
19669     *
19670     * This function takes a negative signed integer and returns its absolute
19671     * value as unsigned integer. The plus/minus shuffling is necessary as we can
19672     * not directly remove the sign of an arbitrary signed integer as the
19673     * absolute values of INT_MIN and INT_MAX are usually not the same. See
19674     * #1708 for details.
19675     */
19676    number_unsigned_t remove_sign(number_integer_t x) noexcept
19677    {
19678        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
19679        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
19680    }
19681
19682  private:
19683    /// the output of the serializer
19684    output_adapter_t<char> o = nullptr;
19685
19686    /// a (hopefully) large enough character buffer
19687    std::array<char, 64> number_buffer{{}};
19688
19689    /// the locale
19690    const std::lconv* loc = nullptr;
19691    /// the locale's thousand separator character
19692    const char thousands_sep = '\0';
19693    /// the locale's decimal point character
19694    const char decimal_point = '\0';
19695
19696    /// string buffer
19697    std::array<char, 512> string_buffer{{}};
19698
19699    /// the indentation character
19700    const char indent_char;
19701    /// the indentation string
19702    string_t indent_string;
19703
19704    /// error_handler how to react on decoding errors
19705    const error_handler_t error_handler;
19706};
19707
19708}  // namespace detail
19709NLOHMANN_JSON_NAMESPACE_END
19710
19711// #include <nlohmann/detail/value_t.hpp>
19712
19713// #include <nlohmann/json_fwd.hpp>
19714
19715// #include <nlohmann/ordered_map.hpp>
19716//     __ _____ _____ _____
19717//  __|  |   __|     |   | |  JSON for Modern C++
19718// |  |  |__   |  |  | | | |  version 3.12.0
19719// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
19720//
19721// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
19722// SPDX-License-Identifier: MIT
19723
19724
19725
19726#include <functional> // equal_to, less
19727#include <initializer_list> // initializer_list
19728#include <iterator> // input_iterator_tag, iterator_traits
19729#include <memory> // allocator
19730#include <stdexcept> // for out_of_range
19731#include <type_traits> // enable_if, is_convertible
19732#include <utility> // pair
19733#include <vector> // vector
19734
19735// #include <nlohmann/detail/macro_scope.hpp>
19736
19737// #include <nlohmann/detail/meta/type_traits.hpp>
19738
19739
19740NLOHMANN_JSON_NAMESPACE_BEGIN
19741
19742/// ordered_map: a minimal map-like container that preserves insertion order
19743/// for use within nlohmann::basic_json<ordered_map>
19744template <class Key, class T, class IgnoredLess = std::less<Key>,
19745          class Allocator = std::allocator<std::pair<const Key, T>>>
19746              struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
19747{
19748    using key_type = Key;
19749    using mapped_type = T;
19750    using Container = std::vector<std::pair<const Key, T>, Allocator>;
19751    using iterator = typename Container::iterator;
19752    using const_iterator = typename Container::const_iterator;
19753    using size_type = typename Container::size_type;
19754    using value_type = typename Container::value_type;
19755#ifdef JSON_HAS_CPP_14
19756    using key_compare = std::equal_to<>;
19757#else
19758    using key_compare = std::equal_to<Key>;
19759#endif
19760
19761    // Explicit constructors instead of `using Container::Container`
19762    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
19763    ordered_map() noexcept(noexcept(Container())) : Container{} {}
19764    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
19765    template <class It>
19766    ordered_map(It first, It last, const Allocator& alloc = Allocator())
19767        : Container{first, last, alloc} {}
19768    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
19769        : Container{init, alloc} {}
19770
19771    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
19772    {
19773        for (auto it = this->begin(); it != this->end(); ++it)
19774        {
19775            if (m_compare(it->first, key))
19776            {
19777                return {it, false};
19778            }
19779        }
19780        Container::emplace_back(key, std::forward<T>(t));
19781        return {std::prev(this->end()), true};
19782    }
19783
19784    template<class KeyType, detail::enable_if_t<
19785                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19786    std::pair<iterator, bool> emplace(KeyType && key, T && t)
19787    {
19788        for (auto it = this->begin(); it != this->end(); ++it)
19789        {
19790            if (m_compare(it->first, key))
19791            {
19792                return {it, false};
19793            }
19794        }
19795        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
19796        return {std::prev(this->end()), true};
19797    }
19798
19799    T& operator[](const key_type& key)
19800    {
19801        return emplace(key, T{}).first->second;
19802    }
19803
19804    template<class KeyType, detail::enable_if_t<
19805                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19806    T & operator[](KeyType && key)
19807    {
19808        return emplace(std::forward<KeyType>(key), T{}).first->second;
19809    }
19810
19811    const T& operator[](const key_type& key) const
19812    {
19813        return at(key);
19814    }
19815
19816    template<class KeyType, detail::enable_if_t<
19817                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19818    const T & operator[](KeyType && key) const
19819    {
19820        return at(std::forward<KeyType>(key));
19821    }
19822
19823    T& at(const key_type& key)
19824    {
19825        for (auto it = this->begin(); it != this->end(); ++it)
19826        {
19827            if (m_compare(it->first, key))
19828            {
19829                return it->second;
19830            }
19831        }
19832
19833        JSON_THROW(std::out_of_range("key not found"));
19834    }
19835
19836    template<class KeyType, detail::enable_if_t<
19837                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19838    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
19839    {
19840        for (auto it = this->begin(); it != this->end(); ++it)
19841        {
19842            if (m_compare(it->first, key))
19843            {
19844                return it->second;
19845            }
19846        }
19847
19848        JSON_THROW(std::out_of_range("key not found"));
19849    }
19850
19851    const T& at(const key_type& key) const
19852    {
19853        for (auto it = this->begin(); it != this->end(); ++it)
19854        {
19855            if (m_compare(it->first, key))
19856            {
19857                return it->second;
19858            }
19859        }
19860
19861        JSON_THROW(std::out_of_range("key not found"));
19862    }
19863
19864    template<class KeyType, detail::enable_if_t<
19865                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19866    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
19867    {
19868        for (auto it = this->begin(); it != this->end(); ++it)
19869        {
19870            if (m_compare(it->first, key))
19871            {
19872                return it->second;
19873            }
19874        }
19875
19876        JSON_THROW(std::out_of_range("key not found"));
19877    }
19878
19879    size_type erase(const key_type& key)
19880    {
19881        for (auto it = this->begin(); it != this->end(); ++it)
19882        {
19883            if (m_compare(it->first, key))
19884            {
19885                // Since we cannot move const Keys, re-construct them in place
19886                for (auto next = it; ++next != this->end(); ++it)
19887                {
19888                    it->~value_type(); // Destroy but keep allocation
19889                    new (&*it) value_type{std::move(*next)};
19890                }
19891                Container::pop_back();
19892                return 1;
19893            }
19894        }
19895        return 0;
19896    }
19897
19898    template<class KeyType, detail::enable_if_t<
19899                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19900    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
19901    {
19902        for (auto it = this->begin(); it != this->end(); ++it)
19903        {
19904            if (m_compare(it->first, key))
19905            {
19906                // Since we cannot move const Keys, re-construct them in place
19907                for (auto next = it; ++next != this->end(); ++it)
19908                {
19909                    it->~value_type(); // Destroy but keep allocation
19910                    new (&*it) value_type{std::move(*next)};
19911                }
19912                Container::pop_back();
19913                return 1;
19914            }
19915        }
19916        return 0;
19917    }
19918
19919    iterator erase(iterator pos)
19920    {
19921        return erase(pos, std::next(pos));
19922    }
19923
19924    iterator erase(iterator first, iterator last)
19925    {
19926        if (first == last)
19927        {
19928            return first;
19929        }
19930
19931        const auto elements_affected = std::distance(first, last);
19932        const auto offset = std::distance(Container::begin(), first);
19933
19934        // This is the start situation. We need to delete elements_affected
19935        // elements (3 in this example: e, f, g), and need to return an
19936        // iterator past the last deleted element (h in this example).
19937        // Note that offset is the distance from the start of the vector
19938        // to first. We will need this later.
19939
19940        // [ a, b, c, d, e, f, g, h, i, j ]
19941        //               ^        ^
19942        //             first    last
19943
19944        // Since we cannot move const Keys, we re-construct them in place.
19945        // We start at first and re-construct (viz. copy) the elements from
19946        // the back of the vector. Example for first iteration:
19947
19948        //               ,--------.
19949        //               v        |   destroy e and re-construct with h
19950        // [ a, b, c, d, e, f, g, h, i, j ]
19951        //               ^        ^
19952        //               it       it + elements_affected
19953
19954        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
19955        {
19956            it->~value_type(); // destroy but keep allocation
19957            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
19958        }
19959
19960        // [ a, b, c, d, h, i, j, h, i, j ]
19961        //               ^        ^
19962        //             first    last
19963
19964        // remove the unneeded elements at the end of the vector
19965        Container::resize(this->size() - static_cast<size_type>(elements_affected));
19966
19967        // [ a, b, c, d, h, i, j ]
19968        //               ^        ^
19969        //             first    last
19970
19971        // first is now pointing past the last deleted element, but we cannot
19972        // use this iterator, because it may have been invalidated by the
19973        // resize call. Instead, we can return begin() + offset.
19974        return Container::begin() + offset;
19975    }
19976
19977    size_type count(const key_type& key) const
19978    {
19979        for (auto it = this->begin(); it != this->end(); ++it)
19980        {
19981            if (m_compare(it->first, key))
19982            {
19983                return 1;
19984            }
19985        }
19986        return 0;
19987    }
19988
19989    template<class KeyType, detail::enable_if_t<
19990                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
19991    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
19992    {
19993        for (auto it = this->begin(); it != this->end(); ++it)
19994        {
19995            if (m_compare(it->first, key))
19996            {
19997                return 1;
19998            }
19999        }
20000        return 0;
20001    }
20002
20003    iterator find(const key_type& key)
20004    {
20005        for (auto it = this->begin(); it != this->end(); ++it)
20006        {
20007            if (m_compare(it->first, key))
20008            {
20009                return it;
20010            }
20011        }
20012        return Container::end();
20013    }
20014
20015    template<class KeyType, detail::enable_if_t<
20016                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
20017    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
20018    {
20019        for (auto it = this->begin(); it != this->end(); ++it)
20020        {
20021            if (m_compare(it->first, key))
20022            {
20023                return it;
20024            }
20025        }
20026        return Container::end();
20027    }
20028
20029    const_iterator find(const key_type& key) const
20030    {
20031        for (auto it = this->begin(); it != this->end(); ++it)
20032        {
20033            if (m_compare(it->first, key))
20034            {
20035                return it;
20036            }
20037        }
20038        return Container::end();
20039    }
20040
20041    std::pair<iterator, bool> insert( value_type&& value )
20042    {
20043        return emplace(value.first, std::move(value.second));
20044    }
20045
20046    std::pair<iterator, bool> insert( const value_type& value )
20047    {
20048        for (auto it = this->begin(); it != this->end(); ++it)
20049        {
20050            if (m_compare(it->first, value.first))
20051            {
20052                return {it, false};
20053            }
20054        }
20055        Container::push_back(value);
20056        return {--this->end(), true};
20057    }
20058
20059    template<typename InputIt>
20060    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
20061        std::input_iterator_tag>::value>::type;
20062
20063    template<typename InputIt, typename = require_input_iter<InputIt>>
20064    void insert(InputIt first, InputIt last)
20065    {
20066        for (auto it = first; it != last; ++it)
20067        {
20068            insert(*it);
20069        }
20070    }
20071
20072private:
20073    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
20074};
20075
20076NLOHMANN_JSON_NAMESPACE_END
20077
20078
20079#if defined(JSON_HAS_CPP_17)
20080    #if JSON_HAS_STATIC_RTTI
20081        #include <any>
20082    #endif
20083    #include <string_view>
20084#endif
20085
20086/*!
20087@brief namespace for Niels Lohmann
20088@see https://github.com/nlohmann
20089@since version 1.0.0
20090*/
20091NLOHMANN_JSON_NAMESPACE_BEGIN
20092
20093/*!
20094@brief a class to store JSON values
20095
20096@internal
20097@invariant The member variables @a m_value and @a m_type have the following
20098relationship:
20099- If `m_type == value_t::object`, then `m_value.object != nullptr`.
20100- If `m_type == value_t::array`, then `m_value.array != nullptr`.
20101- If `m_type == value_t::string`, then `m_value.string != nullptr`.
20102The invariants are checked by member function assert_invariant().
20103
20104@note ObjectType trick from https://stackoverflow.com/a/9860911
20105@endinternal
20106
20107@since version 1.0.0
20108
20109@nosubgrouping
20110*/
20111NLOHMANN_BASIC_JSON_TPL_DECLARATION
20112class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
20113    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
20114{
20115  private:
20116    template<detail::value_t> friend struct detail::external_constructor;
20117
20118    template<typename>
20119    friend class ::nlohmann::json_pointer;
20120    // can be restored when json_pointer backwards compatibility is removed
20121    // friend ::nlohmann::json_pointer<StringType>;
20122
20123    template<typename BasicJsonType, typename InputType>
20124    friend class ::nlohmann::detail::parser;
20125    friend ::nlohmann::detail::serializer<basic_json>;
20126    template<typename BasicJsonType>
20127    friend class ::nlohmann::detail::iter_impl;
20128    template<typename BasicJsonType, typename CharType>
20129    friend class ::nlohmann::detail::binary_writer;
20130    template<typename BasicJsonType, typename InputType, typename SAX>
20131    friend class ::nlohmann::detail::binary_reader;
20132    template<typename BasicJsonType, typename InputAdapterType>
20133    friend class ::nlohmann::detail::json_sax_dom_parser;
20134    template<typename BasicJsonType, typename InputAdapterType>
20135    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
20136    friend class ::nlohmann::detail::exception;
20137
20138    /// workaround type for MSVC
20139    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
20140    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
20141
20142  JSON_PRIVATE_UNLESS_TESTED:
20143    // convenience aliases for types residing in namespace detail;
20144    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
20145
20146    template<typename InputAdapterType>
20147    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
20148        InputAdapterType adapter,
20149        detail::parser_callback_t<basic_json>cb = nullptr,
20150        const bool allow_exceptions = true,
20151        const bool ignore_comments = false
20152                                 )
20153    {
20154        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
20155            std::move(cb), allow_exceptions, ignore_comments);
20156    }
20157
20158  private:
20159    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
20160    template<typename BasicJsonType>
20161    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
20162    template<typename BasicJsonType>
20163    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
20164    template<typename Iterator>
20165    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
20166    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
20167
20168    template<typename CharType>
20169    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
20170
20171    template<typename InputType>
20172    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
20173    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
20174
20175  JSON_PRIVATE_UNLESS_TESTED:
20176    using serializer = ::nlohmann::detail::serializer<basic_json>;
20177
20178  public:
20179    using value_t = detail::value_t;
20180    /// JSON Pointer, see @ref nlohmann::json_pointer
20181    using json_pointer = ::nlohmann::json_pointer<StringType>;
20182    template<typename T, typename SFINAE>
20183    using json_serializer = JSONSerializer<T, SFINAE>;
20184    /// how to treat decoding errors
20185    using error_handler_t = detail::error_handler_t;
20186    /// how to treat CBOR tags
20187    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
20188    /// how to encode BJData
20189    using bjdata_version_t = detail::bjdata_version_t;
20190    /// helper type for initializer lists of basic_json values
20191    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
20192
20193    using input_format_t = detail::input_format_t;
20194    /// SAX interface type, see @ref nlohmann::json_sax
20195    using json_sax_t = json_sax<basic_json>;
20196
20197    ////////////////
20198    // exceptions //
20199    ////////////////
20200
20201    /// @name exceptions
20202    /// Classes to implement user-defined exceptions.
20203    /// @{
20204
20205    using exception = detail::exception;
20206    using parse_error = detail::parse_error;
20207    using invalid_iterator = detail::invalid_iterator;
20208    using type_error = detail::type_error;
20209    using out_of_range = detail::out_of_range;
20210    using other_error = detail::other_error;
20211
20212    /// @}
20213
20214    /////////////////////
20215    // container types //
20216    /////////////////////
20217
20218    /// @name container types
20219    /// The canonic container types to use @ref basic_json like any other STL
20220    /// container.
20221    /// @{
20222
20223    /// the type of elements in a basic_json container
20224    using value_type = basic_json;
20225
20226    /// the type of an element reference
20227    using reference = value_type&;
20228    /// the type of an element const reference
20229    using const_reference = const value_type&;
20230
20231    /// a type to represent differences between iterators
20232    using difference_type = std::ptrdiff_t;
20233    /// a type to represent container sizes
20234    using size_type = std::size_t;
20235
20236    /// the allocator type
20237    using allocator_type = AllocatorType<basic_json>;
20238
20239    /// the type of an element pointer
20240    using pointer = typename std::allocator_traits<allocator_type>::pointer;
20241    /// the type of an element const pointer
20242    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
20243
20244    /// an iterator for a basic_json container
20245    using iterator = iter_impl<basic_json>;
20246    /// a const iterator for a basic_json container
20247    using const_iterator = iter_impl<const basic_json>;
20248    /// a reverse iterator for a basic_json container
20249    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
20250    /// a const reverse iterator for a basic_json container
20251    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
20252
20253    /// @}
20254
20255    /// @brief returns the allocator associated with the container
20256    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
20257    static allocator_type get_allocator()
20258    {
20259        return allocator_type();
20260    }
20261
20262    /// @brief returns version information on the library
20263    /// @sa https://json.nlohmann.me/api/basic_json/meta/
20264    JSON_HEDLEY_WARN_UNUSED_RESULT
20265    static basic_json meta()
20266    {
20267        basic_json result;
20268
20269        result["copyright"] = "(C) 2013-2025 Niels Lohmann";
20270        result["name"] = "JSON for Modern C++";
20271        result["url"] = "https://github.com/nlohmann/json";
20272        result["version"]["string"] =
20273            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
20274                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
20275                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
20276        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
20277        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
20278        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
20279
20280#ifdef _WIN32
20281        result["platform"] = "win32";
20282#elif defined __linux__
20283        result["platform"] = "linux";
20284#elif defined __APPLE__
20285        result["platform"] = "apple";
20286#elif defined __unix__
20287        result["platform"] = "unix";
20288#else
20289        result["platform"] = "unknown";
20290#endif
20291
20292#if defined(__ICC) || defined(__INTEL_COMPILER)
20293        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
20294#elif defined(__clang__)
20295        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
20296#elif defined(__GNUC__) || defined(__GNUG__)
20297        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
20298                    std::to_string(__GNUC__), '.',
20299                    std::to_string(__GNUC_MINOR__), '.',
20300                    std::to_string(__GNUC_PATCHLEVEL__))
20301            }
20302        };
20303#elif defined(__HP_cc) || defined(__HP_aCC)
20304        result["compiler"] = "hp"
20305#elif defined(__IBMCPP__)
20306        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
20307#elif defined(_MSC_VER)
20308        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
20309#elif defined(__PGI)
20310        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
20311#elif defined(__SUNPRO_CC)
20312        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
20313#else
20314        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
20315#endif
20316
20317#if defined(_MSVC_LANG)
20318        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
20319#elif defined(__cplusplus)
20320        result["compiler"]["c++"] = std::to_string(__cplusplus);
20321#else
20322        result["compiler"]["c++"] = "unknown";
20323#endif
20324        return result;
20325    }
20326
20327    ///////////////////////////
20328    // JSON value data types //
20329    ///////////////////////////
20330
20331    /// @name JSON value data types
20332    /// The data types to store a JSON value. These types are derived from
20333    /// the template arguments passed to class @ref basic_json.
20334    /// @{
20335
20336    /// @brief default object key comparator type
20337    /// The actual object key comparator type (@ref object_comparator_t) may be
20338    /// different.
20339    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
20340#if defined(JSON_HAS_CPP_14)
20341    // use of transparent comparator avoids unnecessary repeated construction of temporaries
20342    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
20343    using default_object_comparator_t = std::less<>;
20344#else
20345    using default_object_comparator_t = std::less<StringType>;
20346#endif
20347
20348    /// @brief a type for an object
20349    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
20350    using object_t = ObjectType<StringType,
20351          basic_json,
20352          default_object_comparator_t,
20353          AllocatorType<std::pair<const StringType,
20354          basic_json>>>;
20355
20356    /// @brief a type for an array
20357    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
20358    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
20359
20360    /// @brief a type for a string
20361    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
20362    using string_t = StringType;
20363
20364    /// @brief a type for a boolean
20365    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
20366    using boolean_t = BooleanType;
20367
20368    /// @brief a type for a number (integer)
20369    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
20370    using number_integer_t = NumberIntegerType;
20371
20372    /// @brief a type for a number (unsigned)
20373    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
20374    using number_unsigned_t = NumberUnsignedType;
20375
20376    /// @brief a type for a number (floating-point)
20377    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
20378    using number_float_t = NumberFloatType;
20379
20380    /// @brief a type for a packed binary type
20381    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
20382    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
20383
20384    /// @brief object key comparator type
20385    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
20386    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
20387
20388    /// @}
20389
20390  private:
20391
20392    /// helper for exception-safe object creation
20393    template<typename T, typename... Args>
20394    JSON_HEDLEY_RETURNS_NON_NULL
20395    static T* create(Args&& ... args)
20396    {
20397        AllocatorType<T> alloc;
20398        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
20399
20400        auto deleter = [&](T * obj)
20401        {
20402            AllocatorTraits::deallocate(alloc, obj, 1);
20403        };
20404        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
20405        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
20406        JSON_ASSERT(obj != nullptr);
20407        return obj.release();
20408    }
20409
20410    ////////////////////////
20411    // JSON value storage //
20412    ////////////////////////
20413
20414  JSON_PRIVATE_UNLESS_TESTED:
20415    /*!
20416    @brief a JSON value
20417
20418    The actual storage for a JSON value of the @ref basic_json class. This
20419    union combines the different storage types for the JSON value types
20420    defined in @ref value_t.
20421
20422    JSON type | value_t type    | used type
20423    --------- | --------------- | ------------------------
20424    object    | object          | pointer to @ref object_t
20425    array     | array           | pointer to @ref array_t
20426    string    | string          | pointer to @ref string_t
20427    boolean   | boolean         | @ref boolean_t
20428    number    | number_integer  | @ref number_integer_t
20429    number    | number_unsigned | @ref number_unsigned_t
20430    number    | number_float    | @ref number_float_t
20431    binary    | binary          | pointer to @ref binary_t
20432    null      | null            | *no value is stored*
20433
20434    @note Variable-length types (objects, arrays, and strings) are stored as
20435    pointers. The size of the union should not exceed 64 bits if the default
20436    value types are used.
20437
20438    @since version 1.0.0
20439    */
20440    union json_value
20441    {
20442        /// object (stored with pointer to save storage)
20443        object_t* object;
20444        /// array (stored with pointer to save storage)
20445        array_t* array;
20446        /// string (stored with pointer to save storage)
20447        string_t* string;
20448        /// binary (stored with pointer to save storage)
20449        binary_t* binary;
20450        /// boolean
20451        boolean_t boolean;
20452        /// number (integer)
20453        number_integer_t number_integer;
20454        /// number (unsigned integer)
20455        number_unsigned_t number_unsigned;
20456        /// number (floating-point)
20457        number_float_t number_float;
20458
20459        /// default constructor (for null values)
20460        json_value() = default;
20461        /// constructor for booleans
20462        json_value(boolean_t v) noexcept : boolean(v) {}
20463        /// constructor for numbers (integer)
20464        json_value(number_integer_t v) noexcept : number_integer(v) {}
20465        /// constructor for numbers (unsigned)
20466        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
20467        /// constructor for numbers (floating-point)
20468        json_value(number_float_t v) noexcept : number_float(v) {}
20469        /// constructor for empty values of a given type
20470        json_value(value_t t)
20471        {
20472            switch (t)
20473            {
20474                case value_t::object:
20475                {
20476                    object = create<object_t>();
20477                    break;
20478                }
20479
20480                case value_t::array:
20481                {
20482                    array = create<array_t>();
20483                    break;
20484                }
20485
20486                case value_t::string:
20487                {
20488                    string = create<string_t>("");
20489                    break;
20490                }
20491
20492                case value_t::binary:
20493                {
20494                    binary = create<binary_t>();
20495                    break;
20496                }
20497
20498                case value_t::boolean:
20499                {
20500                    boolean = static_cast<boolean_t>(false);
20501                    break;
20502                }
20503
20504                case value_t::number_integer:
20505                {
20506                    number_integer = static_cast<number_integer_t>(0);
20507                    break;
20508                }
20509
20510                case value_t::number_unsigned:
20511                {
20512                    number_unsigned = static_cast<number_unsigned_t>(0);
20513                    break;
20514                }
20515
20516                case value_t::number_float:
20517                {
20518                    number_float = static_cast<number_float_t>(0.0);
20519                    break;
20520                }
20521
20522                case value_t::null:
20523                {
20524                    object = nullptr;  // silence warning, see #821
20525                    break;
20526                }
20527
20528                case value_t::discarded:
20529                default:
20530                {
20531                    object = nullptr;  // silence warning, see #821
20532                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
20533                    {
20534                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE
20535                    }
20536                    break;
20537                }
20538            }
20539        }
20540
20541        /// constructor for strings
20542        json_value(const string_t& value) : string(create<string_t>(value)) {}
20543
20544        /// constructor for rvalue strings
20545        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
20546
20547        /// constructor for objects
20548        json_value(const object_t& value) : object(create<object_t>(value)) {}
20549
20550        /// constructor for rvalue objects
20551        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
20552
20553        /// constructor for arrays
20554        json_value(const array_t& value) : array(create<array_t>(value)) {}
20555
20556        /// constructor for rvalue arrays
20557        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
20558
20559        /// constructor for binary arrays
20560        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
20561
20562        /// constructor for rvalue binary arrays
20563        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
20564
20565        /// constructor for binary arrays (internal type)
20566        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
20567
20568        /// constructor for rvalue binary arrays (internal type)
20569        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
20570
20571        void destroy(value_t t)
20572        {
20573            if (
20574                (t == value_t::object && object == nullptr) ||
20575                (t == value_t::array && array == nullptr) ||
20576                (t == value_t::string && string == nullptr) ||
20577                (t == value_t::binary && binary == nullptr)
20578            )
20579            {
20580                //not initialized (e.g. due to exception in the ctor)
20581                return;
20582            }
20583            if (t == value_t::array || t == value_t::object)
20584            {
20585                // flatten the current json_value to a heap-allocated stack
20586                std::vector<basic_json> stack;
20587
20588                // move the top-level items to stack
20589                if (t == value_t::array)
20590                {
20591                    stack.reserve(array->size());
20592                    std::move(array->begin(), array->end(), std::back_inserter(stack));
20593                }
20594                else
20595                {
20596                    stack.reserve(object->size());
20597                    for (auto&& it : *object)
20598                    {
20599                        stack.push_back(std::move(it.second));
20600                    }
20601                }
20602
20603                while (!stack.empty())
20604                {
20605                    // move the last item to local variable to be processed
20606                    basic_json current_item(std::move(stack.back()));
20607                    stack.pop_back();
20608
20609                    // if current_item is array/object, move
20610                    // its children to the stack to be processed later
20611                    if (current_item.is_array())
20612                    {
20613                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
20614
20615                        current_item.m_data.m_value.array->clear();
20616                    }
20617                    else if (current_item.is_object())
20618                    {
20619                        for (auto&& it : *current_item.m_data.m_value.object)
20620                        {
20621                            stack.push_back(std::move(it.second));
20622                        }
20623
20624                        current_item.m_data.m_value.object->clear();
20625                    }
20626
20627                    // it's now safe that current_item get destructed
20628                    // since it doesn't have any children
20629                }
20630            }
20631
20632            switch (t)
20633            {
20634                case value_t::object:
20635                {
20636                    AllocatorType<object_t> alloc;
20637                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
20638                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
20639                    break;
20640                }
20641
20642                case value_t::array:
20643                {
20644                    AllocatorType<array_t> alloc;
20645                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
20646                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
20647                    break;
20648                }
20649
20650                case value_t::string:
20651                {
20652                    AllocatorType<string_t> alloc;
20653                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
20654                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
20655                    break;
20656                }
20657
20658                case value_t::binary:
20659                {
20660                    AllocatorType<binary_t> alloc;
20661                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
20662                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
20663                    break;
20664                }
20665
20666                case value_t::null:
20667                case value_t::boolean:
20668                case value_t::number_integer:
20669                case value_t::number_unsigned:
20670                case value_t::number_float:
20671                case value_t::discarded:
20672                default:
20673                {
20674                    break;
20675                }
20676            }
20677        }
20678    };
20679
20680  private:
20681    /*!
20682    @brief checks the class invariants
20683
20684    This function asserts the class invariants. It needs to be called at the
20685    end of every constructor to make sure that created objects respect the
20686    invariant. Furthermore, it has to be called each time the type of a JSON
20687    value is changed, because the invariant expresses a relationship between
20688    @a m_type and @a m_value.
20689
20690    Furthermore, the parent relation is checked for arrays and objects: If
20691    @a check_parents true and the value is an array or object, then the
20692    container's elements must have the current value as parent.
20693
20694    @param[in] check_parents  whether the parent relation should be checked.
20695               The value is true by default and should only be set to false
20696               during destruction of objects when the invariant does not
20697               need to hold.
20698    */
20699    void assert_invariant(bool check_parents = true) const noexcept
20700    {
20701        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
20702        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
20703        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
20704        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
20705
20706#if JSON_DIAGNOSTICS
20707        JSON_TRY
20708        {
20709            // cppcheck-suppress assertWithSideEffect
20710            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
20711            {
20712                return j.m_parent == this;
20713            }));
20714        }
20715        JSON_CATCH(...) {} // LCOV_EXCL_LINE
20716#endif
20717        static_cast<void>(check_parents);
20718    }
20719
20720    void set_parents()
20721    {
20722#if JSON_DIAGNOSTICS
20723        switch (m_data.m_type)
20724        {
20725            case value_t::array:
20726            {
20727                for (auto& element : *m_data.m_value.array)
20728                {
20729                    element.m_parent = this;
20730                }
20731                break;
20732            }
20733
20734            case value_t::object:
20735            {
20736                for (auto& element : *m_data.m_value.object)
20737                {
20738                    element.second.m_parent = this;
20739                }
20740                break;
20741            }
20742
20743            case value_t::null:
20744            case value_t::string:
20745            case value_t::boolean:
20746            case value_t::number_integer:
20747            case value_t::number_unsigned:
20748            case value_t::number_float:
20749            case value_t::binary:
20750            case value_t::discarded:
20751            default:
20752                break;
20753        }
20754#endif
20755    }
20756
20757    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
20758    {
20759#if JSON_DIAGNOSTICS
20760        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
20761        {
20762            (it + i)->m_parent = this;
20763        }
20764#else
20765        static_cast<void>(count_set_parents);
20766#endif
20767        return it;
20768    }
20769
20770    reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())
20771    {
20772#if JSON_DIAGNOSTICS
20773        if (old_capacity != detail::unknown_size())
20774        {
20775            // see https://github.com/nlohmann/json/issues/2838
20776            JSON_ASSERT(type() == value_t::array);
20777            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
20778            {
20779                // capacity has changed: update all parents
20780                set_parents();
20781                return j;
20782            }
20783        }
20784
20785        // ordered_json uses a vector internally, so pointers could have
20786        // been invalidated; see https://github.com/nlohmann/json/issues/2962
20787#ifdef JSON_HEDLEY_MSVC_VERSION
20788#pragma warning(push )
20789#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
20790#endif
20791        if (detail::is_ordered_map<object_t>::value)
20792        {
20793            set_parents();
20794            return j;
20795        }
20796#ifdef JSON_HEDLEY_MSVC_VERSION
20797#pragma warning( pop )
20798#endif
20799
20800        j.m_parent = this;
20801#else
20802        static_cast<void>(j);
20803        static_cast<void>(old_capacity);
20804#endif
20805        return j;
20806    }
20807
20808  public:
20809    //////////////////////////
20810    // JSON parser callback //
20811    //////////////////////////
20812
20813    /// @brief parser event types
20814    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
20815    using parse_event_t = detail::parse_event_t;
20816
20817    /// @brief per-element parser callback type
20818    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
20819    using parser_callback_t = detail::parser_callback_t<basic_json>;
20820
20821    //////////////////
20822    // constructors //
20823    //////////////////
20824
20825    /// @name constructors and destructors
20826    /// Constructors of class @ref basic_json, copy/move constructor, copy
20827    /// assignment, static functions creating objects, and the destructor.
20828    /// @{
20829
20830    /// @brief create an empty value with a given type
20831    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
20832    basic_json(const value_t v)
20833        : m_data(v)
20834    {
20835        assert_invariant();
20836    }
20837
20838    /// @brief create a null object
20839    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
20840    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
20841        : basic_json(value_t::null)
20842    {
20843        assert_invariant();
20844    }
20845
20846    /// @brief create a JSON value from compatible types
20847    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
20848    template < typename CompatibleType,
20849               typename U = detail::uncvref_t<CompatibleType>,
20850               detail::enable_if_t <
20851                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
20852    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
20853            JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
20854                                       std::forward<CompatibleType>(val))))
20855    {
20856        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
20857        set_parents();
20858        assert_invariant();
20859    }
20860
20861    /// @brief create a JSON value from an existing one
20862    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
20863    template < typename BasicJsonType,
20864               detail::enable_if_t <
20865                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
20866    basic_json(const BasicJsonType& val)
20867#if JSON_DIAGNOSTIC_POSITIONS
20868        : start_position(val.start_pos()),
20869          end_position(val.end_pos())
20870#endif
20871    {
20872        using other_boolean_t = typename BasicJsonType::boolean_t;
20873        using other_number_float_t = typename BasicJsonType::number_float_t;
20874        using other_number_integer_t = typename BasicJsonType::number_integer_t;
20875        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
20876        using other_string_t = typename BasicJsonType::string_t;
20877        using other_object_t = typename BasicJsonType::object_t;
20878        using other_array_t = typename BasicJsonType::array_t;
20879        using other_binary_t = typename BasicJsonType::binary_t;
20880
20881        switch (val.type())
20882        {
20883            case value_t::boolean:
20884                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
20885                break;
20886            case value_t::number_float:
20887                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
20888                break;
20889            case value_t::number_integer:
20890                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
20891                break;
20892            case value_t::number_unsigned:
20893                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
20894                break;
20895            case value_t::string:
20896                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
20897                break;
20898            case value_t::object:
20899                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
20900                break;
20901            case value_t::array:
20902                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
20903                break;
20904            case value_t::binary:
20905                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
20906                break;
20907            case value_t::null:
20908                *this = nullptr;
20909                break;
20910            case value_t::discarded:
20911                m_data.m_type = value_t::discarded;
20912                break;
20913            default:            // LCOV_EXCL_LINE
20914                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
20915        }
20916        JSON_ASSERT(m_data.m_type == val.type());
20917
20918        set_parents();
20919        assert_invariant();
20920    }
20921
20922    /// @brief create a container (array or object) from an initializer list
20923    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
20924    basic_json(initializer_list_t init,
20925               bool type_deduction = true,
20926               value_t manual_type = value_t::array)
20927    {
20928        // check if each element is an array with two elements whose first
20929        // element is a string
20930        bool is_an_object = std::all_of(init.begin(), init.end(),
20931                                        [](const detail::json_ref<basic_json>& element_ref)
20932        {
20933            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
20934            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
20935            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
20936            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
20937        });
20938
20939        // adjust type if type deduction is not wanted
20940        if (!type_deduction)
20941        {
20942            // if array is wanted, do not create an object though possible
20943            if (manual_type == value_t::array)
20944            {
20945                is_an_object = false;
20946            }
20947
20948            // if object is wanted but impossible, throw an exception
20949            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
20950            {
20951                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
20952            }
20953        }
20954
20955        if (is_an_object)
20956        {
20957            // the initializer list is a list of pairs -> create object
20958            m_data.m_type = value_t::object;
20959            m_data.m_value = value_t::object;
20960
20961            for (auto& element_ref : init)
20962            {
20963                auto element = element_ref.moved_or_copied();
20964                m_data.m_value.object->emplace(
20965                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
20966                    std::move((*element.m_data.m_value.array)[1]));
20967            }
20968        }
20969        else
20970        {
20971            // the initializer list describes an array -> create array
20972            m_data.m_type = value_t::array;
20973            m_data.m_value.array = create<array_t>(init.begin(), init.end());
20974        }
20975
20976        set_parents();
20977        assert_invariant();
20978    }
20979
20980    /// @brief explicitly create a binary array (without subtype)
20981    /// @sa https://json.nlohmann.me/api/basic_json/binary/
20982    JSON_HEDLEY_WARN_UNUSED_RESULT
20983    static basic_json binary(const typename binary_t::container_type& init)
20984    {
20985        auto res = basic_json();
20986        res.m_data.m_type = value_t::binary;
20987        res.m_data.m_value = init;
20988        return res;
20989    }
20990
20991    /// @brief explicitly create a binary array (with subtype)
20992    /// @sa https://json.nlohmann.me/api/basic_json/binary/
20993    JSON_HEDLEY_WARN_UNUSED_RESULT
20994    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
20995    {
20996        auto res = basic_json();
20997        res.m_data.m_type = value_t::binary;
20998        res.m_data.m_value = binary_t(init, subtype);
20999        return res;
21000    }
21001
21002    /// @brief explicitly create a binary array
21003    /// @sa https://json.nlohmann.me/api/basic_json/binary/
21004    JSON_HEDLEY_WARN_UNUSED_RESULT
21005    static basic_json binary(typename binary_t::container_type&& init)
21006    {
21007        auto res = basic_json();
21008        res.m_data.m_type = value_t::binary;
21009        res.m_data.m_value = std::move(init);
21010        return res;
21011    }
21012
21013    /// @brief explicitly create a binary array (with subtype)
21014    /// @sa https://json.nlohmann.me/api/basic_json/binary/
21015    JSON_HEDLEY_WARN_UNUSED_RESULT
21016    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
21017    {
21018        auto res = basic_json();
21019        res.m_data.m_type = value_t::binary;
21020        res.m_data.m_value = binary_t(std::move(init), subtype);
21021        return res;
21022    }
21023
21024    /// @brief explicitly create an array from an initializer list
21025    /// @sa https://json.nlohmann.me/api/basic_json/array/
21026    JSON_HEDLEY_WARN_UNUSED_RESULT
21027    static basic_json array(initializer_list_t init = {})
21028    {
21029        return basic_json(init, false, value_t::array);
21030    }
21031
21032    /// @brief explicitly create an object from an initializer list
21033    /// @sa https://json.nlohmann.me/api/basic_json/object/
21034    JSON_HEDLEY_WARN_UNUSED_RESULT
21035    static basic_json object(initializer_list_t init = {})
21036    {
21037        return basic_json(init, false, value_t::object);
21038    }
21039
21040    /// @brief construct an array with count copies of given value
21041    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
21042    basic_json(size_type cnt, const basic_json& val):
21043        m_data{cnt, val}
21044    {
21045        set_parents();
21046        assert_invariant();
21047    }
21048
21049    /// @brief construct a JSON container given an iterator range
21050    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
21051    template < class InputIT, typename std::enable_if <
21052                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
21053                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
21054    basic_json(InputIT first, InputIT last) // NOLINT(performance-unnecessary-value-param)
21055    {
21056        JSON_ASSERT(first.m_object != nullptr);
21057        JSON_ASSERT(last.m_object != nullptr);
21058
21059        // make sure iterator fits the current value
21060        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
21061        {
21062            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
21063        }
21064
21065        // copy type from first iterator
21066        m_data.m_type = first.m_object->m_data.m_type;
21067
21068        // check if iterator range is complete for primitive values
21069        switch (m_data.m_type)
21070        {
21071            case value_t::boolean:
21072            case value_t::number_float:
21073            case value_t::number_integer:
21074            case value_t::number_unsigned:
21075            case value_t::string:
21076            {
21077                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
21078                                         || !last.m_it.primitive_iterator.is_end()))
21079                {
21080                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
21081                }
21082                break;
21083            }
21084
21085            case value_t::null:
21086            case value_t::object:
21087            case value_t::array:
21088            case value_t::binary:
21089            case value_t::discarded:
21090            default:
21091                break;
21092        }
21093
21094        switch (m_data.m_type)
21095        {
21096            case value_t::number_integer:
21097            {
21098                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
21099                break;
21100            }
21101
21102            case value_t::number_unsigned:
21103            {
21104                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
21105                break;
21106            }
21107
21108            case value_t::number_float:
21109            {
21110                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
21111                break;
21112            }
21113
21114            case value_t::boolean:
21115            {
21116                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
21117                break;
21118            }
21119
21120            case value_t::string:
21121            {
21122                m_data.m_value = *first.m_object->m_data.m_value.string;
21123                break;
21124            }
21125
21126            case value_t::object:
21127            {
21128                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
21129                                        last.m_it.object_iterator);
21130                break;
21131            }
21132
21133            case value_t::array:
21134            {
21135                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
21136                                                       last.m_it.array_iterator);
21137                break;
21138            }
21139
21140            case value_t::binary:
21141            {
21142                m_data.m_value = *first.m_object->m_data.m_value.binary;
21143                break;
21144            }
21145
21146            case value_t::null:
21147            case value_t::discarded:
21148            default:
21149                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
21150        }
21151
21152        set_parents();
21153        assert_invariant();
21154    }
21155
21156    ///////////////////////////////////////
21157    // other constructors and destructor //
21158    ///////////////////////////////////////
21159
21160    template<typename JsonRef,
21161             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
21162                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
21163    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
21164
21165    /// @brief copy constructor
21166    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
21167    basic_json(const basic_json& other)
21168        : json_base_class_t(other)
21169#if JSON_DIAGNOSTIC_POSITIONS
21170        , start_position(other.start_position)
21171        , end_position(other.end_position)
21172#endif
21173    {
21174        m_data.m_type = other.m_data.m_type;
21175        // check of passed value is valid
21176        other.assert_invariant();
21177
21178        switch (m_data.m_type)
21179        {
21180            case value_t::object:
21181            {
21182                m_data.m_value = *other.m_data.m_value.object;
21183                break;
21184            }
21185
21186            case value_t::array:
21187            {
21188                m_data.m_value = *other.m_data.m_value.array;
21189                break;
21190            }
21191
21192            case value_t::string:
21193            {
21194                m_data.m_value = *other.m_data.m_value.string;
21195                break;
21196            }
21197
21198            case value_t::boolean:
21199            {
21200                m_data.m_value = other.m_data.m_value.boolean;
21201                break;
21202            }
21203
21204            case value_t::number_integer:
21205            {
21206                m_data.m_value = other.m_data.m_value.number_integer;
21207                break;
21208            }
21209
21210            case value_t::number_unsigned:
21211            {
21212                m_data.m_value = other.m_data.m_value.number_unsigned;
21213                break;
21214            }
21215
21216            case value_t::number_float:
21217            {
21218                m_data.m_value = other.m_data.m_value.number_float;
21219                break;
21220            }
21221
21222            case value_t::binary:
21223            {
21224                m_data.m_value = *other.m_data.m_value.binary;
21225                break;
21226            }
21227
21228            case value_t::null:
21229            case value_t::discarded:
21230            default:
21231                break;
21232        }
21233
21234        set_parents();
21235        assert_invariant();
21236    }
21237
21238    /// @brief move constructor
21239    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
21240    basic_json(basic_json&& other) noexcept
21241        : json_base_class_t(std::forward<json_base_class_t>(other)),
21242          m_data(std::move(other.m_data)) // cppcheck-suppress[accessForwarded] TODO check
21243#if JSON_DIAGNOSTIC_POSITIONS
21244        , start_position(other.start_position) // cppcheck-suppress[accessForwarded] TODO check
21245        , end_position(other.end_position) // cppcheck-suppress[accessForwarded] TODO check
21246#endif
21247    {
21248        // check that passed value is valid
21249        other.assert_invariant(false); // cppcheck-suppress[accessForwarded]
21250
21251        // invalidate payload
21252        other.m_data.m_type = value_t::null;
21253        other.m_data.m_value = {};
21254
21255#if JSON_DIAGNOSTIC_POSITIONS
21256        other.start_position = std::string::npos;
21257        other.end_position = std::string::npos;
21258#endif
21259
21260        set_parents();
21261        assert_invariant();
21262    }
21263
21264    /// @brief copy assignment
21265    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
21266    basic_json& operator=(basic_json other) noexcept (
21267        std::is_nothrow_move_constructible<value_t>::value&&
21268        std::is_nothrow_move_assignable<value_t>::value&&
21269        std::is_nothrow_move_constructible<json_value>::value&&
21270        std::is_nothrow_move_assignable<json_value>::value&&
21271        std::is_nothrow_move_assignable<json_base_class_t>::value
21272    )
21273    {
21274        // check that passed value is valid
21275        other.assert_invariant();
21276
21277        using std::swap;
21278        swap(m_data.m_type, other.m_data.m_type);
21279        swap(m_data.m_value, other.m_data.m_value);
21280
21281#if JSON_DIAGNOSTIC_POSITIONS
21282        swap(start_position, other.start_position);
21283        swap(end_position, other.end_position);
21284#endif
21285
21286        json_base_class_t::operator=(std::move(other));
21287
21288        set_parents();
21289        assert_invariant();
21290        return *this;
21291    }
21292
21293    /// @brief destructor
21294    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
21295    ~basic_json() noexcept
21296    {
21297        assert_invariant(false);
21298    }
21299
21300    /// @}
21301
21302  public:
21303    ///////////////////////
21304    // object inspection //
21305    ///////////////////////
21306
21307    /// @name object inspection
21308    /// Functions to inspect the type of a JSON value.
21309    /// @{
21310
21311    /// @brief serialization
21312    /// @sa https://json.nlohmann.me/api/basic_json/dump/
21313    string_t dump(const int indent = -1,
21314                  const char indent_char = ' ',
21315                  const bool ensure_ascii = false,
21316                  const error_handler_t error_handler = error_handler_t::strict) const
21317    {
21318        string_t result;
21319        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
21320
21321        if (indent >= 0)
21322        {
21323            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
21324        }
21325        else
21326        {
21327            s.dump(*this, false, ensure_ascii, 0);
21328        }
21329
21330        return result;
21331    }
21332
21333    /// @brief return the type of the JSON value (explicit)
21334    /// @sa https://json.nlohmann.me/api/basic_json/type/
21335    constexpr value_t type() const noexcept
21336    {
21337        return m_data.m_type;
21338    }
21339
21340    /// @brief return whether type is primitive
21341    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
21342    constexpr bool is_primitive() const noexcept
21343    {
21344        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
21345    }
21346
21347    /// @brief return whether type is structured
21348    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
21349    constexpr bool is_structured() const noexcept
21350    {
21351        return is_array() || is_object();
21352    }
21353
21354    /// @brief return whether value is null
21355    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
21356    constexpr bool is_null() const noexcept
21357    {
21358        return m_data.m_type == value_t::null;
21359    }
21360
21361    /// @brief return whether value is a boolean
21362    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
21363    constexpr bool is_boolean() const noexcept
21364    {
21365        return m_data.m_type == value_t::boolean;
21366    }
21367
21368    /// @brief return whether value is a number
21369    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
21370    constexpr bool is_number() const noexcept
21371    {
21372        return is_number_integer() || is_number_float();
21373    }
21374
21375    /// @brief return whether value is an integer number
21376    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
21377    constexpr bool is_number_integer() const noexcept
21378    {
21379        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
21380    }
21381
21382    /// @brief return whether value is an unsigned integer number
21383    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
21384    constexpr bool is_number_unsigned() const noexcept
21385    {
21386        return m_data.m_type == value_t::number_unsigned;
21387    }
21388
21389    /// @brief return whether value is a floating-point number
21390    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
21391    constexpr bool is_number_float() const noexcept
21392    {
21393        return m_data.m_type == value_t::number_float;
21394    }
21395
21396    /// @brief return whether value is an object
21397    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
21398    constexpr bool is_object() const noexcept
21399    {
21400        return m_data.m_type == value_t::object;
21401    }
21402
21403    /// @brief return whether value is an array
21404    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
21405    constexpr bool is_array() const noexcept
21406    {
21407        return m_data.m_type == value_t::array;
21408    }
21409
21410    /// @brief return whether value is a string
21411    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
21412    constexpr bool is_string() const noexcept
21413    {
21414        return m_data.m_type == value_t::string;
21415    }
21416
21417    /// @brief return whether value is a binary array
21418    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
21419    constexpr bool is_binary() const noexcept
21420    {
21421        return m_data.m_type == value_t::binary;
21422    }
21423
21424    /// @brief return whether value is discarded
21425    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
21426    constexpr bool is_discarded() const noexcept
21427    {
21428        return m_data.m_type == value_t::discarded;
21429    }
21430
21431    /// @brief return the type of the JSON value (implicit)
21432    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
21433    constexpr operator value_t() const noexcept
21434    {
21435        return m_data.m_type;
21436    }
21437
21438    /// @}
21439
21440  private:
21441    //////////////////
21442    // value access //
21443    //////////////////
21444
21445    /// get a boolean (explicit)
21446    boolean_t get_impl(boolean_t* /*unused*/) const
21447    {
21448        if (JSON_HEDLEY_LIKELY(is_boolean()))
21449        {
21450            return m_data.m_value.boolean;
21451        }
21452
21453        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
21454    }
21455
21456    /// get a pointer to the value (object)
21457    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
21458    {
21459        return is_object() ? m_data.m_value.object : nullptr;
21460    }
21461
21462    /// get a pointer to the value (object)
21463    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
21464    {
21465        return is_object() ? m_data.m_value.object : nullptr;
21466    }
21467
21468    /// get a pointer to the value (array)
21469    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
21470    {
21471        return is_array() ? m_data.m_value.array : nullptr;
21472    }
21473
21474    /// get a pointer to the value (array)
21475    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
21476    {
21477        return is_array() ? m_data.m_value.array : nullptr;
21478    }
21479
21480    /// get a pointer to the value (string)
21481    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
21482    {
21483        return is_string() ? m_data.m_value.string : nullptr;
21484    }
21485
21486    /// get a pointer to the value (string)
21487    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
21488    {
21489        return is_string() ? m_data.m_value.string : nullptr;
21490    }
21491
21492    /// get a pointer to the value (boolean)
21493    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
21494    {
21495        return is_boolean() ? &m_data.m_value.boolean : nullptr;
21496    }
21497
21498    /// get a pointer to the value (boolean)
21499    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
21500    {
21501        return is_boolean() ? &m_data.m_value.boolean : nullptr;
21502    }
21503
21504    /// get a pointer to the value (integer number)
21505    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
21506    {
21507        return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr;
21508    }
21509
21510    /// get a pointer to the value (integer number)
21511    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
21512    {
21513        return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr;
21514    }
21515
21516    /// get a pointer to the value (unsigned number)
21517    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
21518    {
21519        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
21520    }
21521
21522    /// get a pointer to the value (unsigned number)
21523    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
21524    {
21525        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
21526    }
21527
21528    /// get a pointer to the value (floating-point number)
21529    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
21530    {
21531        return is_number_float() ? &m_data.m_value.number_float : nullptr;
21532    }
21533
21534    /// get a pointer to the value (floating-point number)
21535    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
21536    {
21537        return is_number_float() ? &m_data.m_value.number_float : nullptr;
21538    }
21539
21540    /// get a pointer to the value (binary)
21541    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
21542    {
21543        return is_binary() ? m_data.m_value.binary : nullptr;
21544    }
21545
21546    /// get a pointer to the value (binary)
21547    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
21548    {
21549        return is_binary() ? m_data.m_value.binary : nullptr;
21550    }
21551
21552    /*!
21553    @brief helper function to implement get_ref()
21554
21555    This function helps to implement get_ref() without code duplication for
21556    const and non-const overloads
21557
21558    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
21559
21560    @throw type_error.303 if ReferenceType does not match underlying value
21561    type of the current JSON
21562    */
21563    template<typename ReferenceType, typename ThisType>
21564    static ReferenceType get_ref_impl(ThisType& obj)
21565    {
21566        // delegate the call to get_ptr<>()
21567        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
21568
21569        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
21570        {
21571            return *ptr;
21572        }
21573
21574        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
21575    }
21576
21577  public:
21578    /// @name value access
21579    /// Direct access to the stored value of a JSON value.
21580    /// @{
21581
21582    /// @brief get a pointer value (implicit)
21583    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
21584    template<typename PointerType, typename std::enable_if<
21585                 std::is_pointer<PointerType>::value, int>::type = 0>
21586    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
21587    {
21588        // delegate the call to get_impl_ptr<>()
21589        return get_impl_ptr(static_cast<PointerType>(nullptr));
21590    }
21591
21592    /// @brief get a pointer value (implicit)
21593    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
21594    template < typename PointerType, typename std::enable_if <
21595                   std::is_pointer<PointerType>::value&&
21596                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
21597    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
21598    {
21599        // delegate the call to get_impl_ptr<>() const
21600        return get_impl_ptr(static_cast<PointerType>(nullptr));
21601    }
21602
21603  private:
21604    /*!
21605    @brief get a value (explicit)
21606
21607    Explicit type conversion between the JSON value and a compatible value
21608    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
21609    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
21610    The value is converted by calling the @ref json_serializer<ValueType>
21611    `from_json()` method.
21612
21613    The function is equivalent to executing
21614    @code {.cpp}
21615    ValueType ret;
21616    JSONSerializer<ValueType>::from_json(*this, ret);
21617    return ret;
21618    @endcode
21619
21620    This overloads is chosen if:
21621    - @a ValueType is not @ref basic_json,
21622    - @ref json_serializer<ValueType> has a `from_json()` method of the form
21623      `void from_json(const basic_json&, ValueType&)`, and
21624    - @ref json_serializer<ValueType> does not have a `from_json()` method of
21625      the form `ValueType from_json(const basic_json&)`
21626
21627    @tparam ValueType the returned value type
21628
21629    @return copy of the JSON value, converted to @a ValueType
21630
21631    @throw what @ref json_serializer<ValueType> `from_json()` method throws
21632
21633    @liveexample{The example below shows several conversions from JSON values
21634    to other types. There a few things to note: (1) Floating-point numbers can
21635    be converted to integers\, (2) A JSON array can be converted to a standard
21636    `std::vector<short>`\, (3) A JSON object can be converted to C++
21637    associative containers such as `std::unordered_map<std::string\,
21638    json>`.,get__ValueType_const}
21639
21640    @since version 2.1.0
21641    */
21642    template < typename ValueType,
21643               detail::enable_if_t <
21644                   detail::is_default_constructible<ValueType>::value&&
21645                   detail::has_from_json<basic_json_t, ValueType>::value,
21646                   int > = 0 >
21647    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
21648            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
21649    {
21650        auto ret = ValueType();
21651        JSONSerializer<ValueType>::from_json(*this, ret);
21652        return ret;
21653    }
21654
21655    /*!
21656    @brief get a value (explicit); special case
21657
21658    Explicit type conversion between the JSON value and a compatible value
21659    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
21660    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
21661    The value is converted by calling the @ref json_serializer<ValueType>
21662    `from_json()` method.
21663
21664    The function is equivalent to executing
21665    @code {.cpp}
21666    return JSONSerializer<ValueType>::from_json(*this);
21667    @endcode
21668
21669    This overloads is chosen if:
21670    - @a ValueType is not @ref basic_json and
21671    - @ref json_serializer<ValueType> has a `from_json()` method of the form
21672      `ValueType from_json(const basic_json&)`
21673
21674    @note If @ref json_serializer<ValueType> has both overloads of
21675    `from_json()`, this one is chosen.
21676
21677    @tparam ValueType the returned value type
21678
21679    @return copy of the JSON value, converted to @a ValueType
21680
21681    @throw what @ref json_serializer<ValueType> `from_json()` method throws
21682
21683    @since version 2.1.0
21684    */
21685    template < typename ValueType,
21686               detail::enable_if_t <
21687                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
21688                   int > = 0 >
21689    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
21690            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
21691    {
21692        return JSONSerializer<ValueType>::from_json(*this);
21693    }
21694
21695    /*!
21696    @brief get special-case overload
21697
21698    This overloads converts the current @ref basic_json in a different
21699    @ref basic_json type
21700
21701    @tparam BasicJsonType == @ref basic_json
21702
21703    @return a copy of *this, converted into @a BasicJsonType
21704
21705    @complexity Depending on the implementation of the called `from_json()`
21706                method.
21707
21708    @since version 3.2.0
21709    */
21710    template < typename BasicJsonType,
21711               detail::enable_if_t <
21712                   detail::is_basic_json<BasicJsonType>::value,
21713                   int > = 0 >
21714    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
21715    {
21716        return *this;
21717    }
21718
21719    /*!
21720    @brief get special-case overload
21721
21722    This overloads avoids a lot of template boilerplate, it can be seen as the
21723    identity method
21724
21725    @tparam BasicJsonType == @ref basic_json
21726
21727    @return a copy of *this
21728
21729    @complexity Constant.
21730
21731    @since version 2.1.0
21732    */
21733    template<typename BasicJsonType,
21734             detail::enable_if_t<
21735                 std::is_same<BasicJsonType, basic_json_t>::value,
21736                 int> = 0>
21737    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
21738    {
21739        return *this;
21740    }
21741
21742    /*!
21743    @brief get a pointer value (explicit)
21744    @copydoc get()
21745    */
21746    template<typename PointerType,
21747             detail::enable_if_t<
21748                 std::is_pointer<PointerType>::value,
21749                 int> = 0>
21750    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
21751    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
21752    {
21753        // delegate the call to get_ptr
21754        return get_ptr<PointerType>();
21755    }
21756
21757  public:
21758    /*!
21759    @brief get a (pointer) value (explicit)
21760
21761    Performs explicit type conversion between the JSON value and a compatible value if required.
21762
21763    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
21764    No copies are made.
21765
21766    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
21767    from the current @ref basic_json.
21768
21769    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
21770    method.
21771
21772    @tparam ValueTypeCV the provided value type
21773    @tparam ValueType the returned value type
21774
21775    @return copy of the JSON value, converted to @tparam ValueType if necessary
21776
21777    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
21778
21779    @since version 2.1.0
21780    */
21781    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
21782#if defined(JSON_HAS_CPP_14)
21783    constexpr
21784#endif
21785    auto get() const noexcept(
21786    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
21787    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
21788    {
21789        // we cannot static_assert on ValueTypeCV being non-const, because
21790        // there is support for get<const basic_json_t>(), which is why we
21791        // still need the uncvref
21792        static_assert(!std::is_reference<ValueTypeCV>::value,
21793                      "get() cannot be used with reference types, you might want to use get_ref()");
21794        return get_impl<ValueType>(detail::priority_tag<4> {});
21795    }
21796
21797    /*!
21798    @brief get a pointer value (explicit)
21799
21800    Explicit pointer access to the internally stored JSON value. No copies are
21801    made.
21802
21803    @warning The pointer becomes invalid if the underlying JSON object
21804    changes.
21805
21806    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
21807    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
21808    @ref number_unsigned_t, or @ref number_float_t.
21809
21810    @return pointer to the internally stored JSON value if the requested
21811    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
21812
21813    @complexity Constant.
21814
21815    @liveexample{The example below shows how pointers to internal values of a
21816    JSON value can be requested. Note that no type conversions are made and a
21817    `nullptr` is returned if the value and the requested pointer type does not
21818    match.,get__PointerType}
21819
21820    @sa see @ref get_ptr() for explicit pointer-member access
21821
21822    @since version 1.0.0
21823    */
21824    template<typename PointerType, typename std::enable_if<
21825                 std::is_pointer<PointerType>::value, int>::type = 0>
21826    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
21827    {
21828        // delegate the call to get_ptr
21829        return get_ptr<PointerType>();
21830    }
21831
21832    /// @brief get a value (explicit)
21833    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
21834    template < typename ValueType,
21835               detail::enable_if_t <
21836                   !detail::is_basic_json<ValueType>::value&&
21837                   detail::has_from_json<basic_json_t, ValueType>::value,
21838                   int > = 0 >
21839    ValueType & get_to(ValueType& v) const noexcept(noexcept(
21840            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
21841    {
21842        JSONSerializer<ValueType>::from_json(*this, v);
21843        return v;
21844    }
21845
21846    // specialization to allow calling get_to with a basic_json value
21847    // see https://github.com/nlohmann/json/issues/2175
21848    template<typename ValueType,
21849             detail::enable_if_t <
21850                 detail::is_basic_json<ValueType>::value,
21851                 int> = 0>
21852    ValueType & get_to(ValueType& v) const
21853    {
21854        v = *this;
21855        return v;
21856    }
21857
21858    template <
21859        typename T, std::size_t N,
21860        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
21861        detail::enable_if_t <
21862            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
21863    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
21864    noexcept(noexcept(JSONSerializer<Array>::from_json(
21865                          std::declval<const basic_json_t&>(), v)))
21866    {
21867        JSONSerializer<Array>::from_json(*this, v);
21868        return v;
21869    }
21870
21871    /// @brief get a reference value (implicit)
21872    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
21873    template<typename ReferenceType, typename std::enable_if<
21874                 std::is_reference<ReferenceType>::value, int>::type = 0>
21875    ReferenceType get_ref()
21876    {
21877        // delegate call to get_ref_impl
21878        return get_ref_impl<ReferenceType>(*this);
21879    }
21880
21881    /// @brief get a reference value (implicit)
21882    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
21883    template < typename ReferenceType, typename std::enable_if <
21884                   std::is_reference<ReferenceType>::value&&
21885                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
21886    ReferenceType get_ref() const
21887    {
21888        // delegate call to get_ref_impl
21889        return get_ref_impl<ReferenceType>(*this);
21890    }
21891
21892    /*!
21893    @brief get a value (implicit)
21894
21895    Implicit type conversion between the JSON value and a compatible value.
21896    The call is realized by calling @ref get() const.
21897
21898    @tparam ValueType non-pointer type compatible to the JSON value, for
21899    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
21900    `std::vector` types for JSON arrays. The character type of @ref string_t
21901    as well as an initializer list of this type is excluded to avoid
21902    ambiguities as these types implicitly convert to `std::string`.
21903
21904    @return copy of the JSON value, converted to type @a ValueType
21905
21906    @throw type_error.302 in case passed type @a ValueType is incompatible
21907    to the JSON value type (e.g., the JSON value is of type boolean, but a
21908    string is requested); see example below
21909
21910    @complexity Linear in the size of the JSON value.
21911
21912    @liveexample{The example below shows several conversions from JSON values
21913    to other types. There a few things to note: (1) Floating-point numbers can
21914    be converted to integers\, (2) A JSON array can be converted to a standard
21915    `std::vector<short>`\, (3) A JSON object can be converted to C++
21916    associative containers such as `std::unordered_map<std::string\,
21917    json>`.,operator__ValueType}
21918
21919    @since version 1.0.0
21920    */
21921    template < typename ValueType, typename std::enable_if <
21922                   detail::conjunction <
21923                       detail::negation<std::is_pointer<ValueType>>,
21924                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
21925                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
21926                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
21927                                        detail::negation<detail::is_basic_json<ValueType>>,
21928                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
21929#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
21930                                                detail::negation<std::is_same<ValueType, std::string_view>>,
21931#endif
21932#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
21933                                                detail::negation<std::is_same<ValueType, std::any>>,
21934#endif
21935                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
21936                                                >::value, int >::type = 0 >
21937                                        JSON_EXPLICIT operator ValueType() const
21938    {
21939        // delegate the call to get<>() const
21940        return get<ValueType>();
21941    }
21942
21943    /// @brief get a binary value
21944    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
21945    binary_t& get_binary()
21946    {
21947        if (!is_binary())
21948        {
21949            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
21950        }
21951
21952        return *get_ptr<binary_t*>();
21953    }
21954
21955    /// @brief get a binary value
21956    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
21957    const binary_t& get_binary() const
21958    {
21959        if (!is_binary())
21960        {
21961            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
21962        }
21963
21964        return *get_ptr<const binary_t*>();
21965    }
21966
21967    /// @}
21968
21969    ////////////////////
21970    // element access //
21971    ////////////////////
21972
21973    /// @name element access
21974    /// Access to the JSON value.
21975    /// @{
21976
21977    /// @brief access specified array element with bounds checking
21978    /// @sa https://json.nlohmann.me/api/basic_json/at/
21979    reference at(size_type idx)
21980    {
21981        // at only works for arrays
21982        if (JSON_HEDLEY_LIKELY(is_array()))
21983        {
21984            JSON_TRY
21985            {
21986                return set_parent(m_data.m_value.array->at(idx));
21987            }
21988            JSON_CATCH (std::out_of_range&)
21989            {
21990                // create better exception explanation
21991                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21992            } // cppcheck-suppress[missingReturn]
21993        }
21994        else
21995        {
21996            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
21997        }
21998    }
21999
22000    /// @brief access specified array element with bounds checking
22001    /// @sa https://json.nlohmann.me/api/basic_json/at/
22002    const_reference at(size_type idx) const
22003    {
22004        // at only works for arrays
22005        if (JSON_HEDLEY_LIKELY(is_array()))
22006        {
22007            JSON_TRY
22008            {
22009                return m_data.m_value.array->at(idx);
22010            }
22011            JSON_CATCH (std::out_of_range&)
22012            {
22013                // create better exception explanation
22014                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
22015            } // cppcheck-suppress[missingReturn]
22016        }
22017        else
22018        {
22019            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
22020        }
22021    }
22022
22023    /// @brief access specified object element with bounds checking
22024    /// @sa https://json.nlohmann.me/api/basic_json/at/
22025    reference at(const typename object_t::key_type& key)
22026    {
22027        // at only works for objects
22028        if (JSON_HEDLEY_UNLIKELY(!is_object()))
22029        {
22030            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
22031        }
22032
22033        auto it = m_data.m_value.object->find(key);
22034        if (it == m_data.m_value.object->end())
22035        {
22036            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
22037        }
22038        return set_parent(it->second);
22039    }
22040
22041    /// @brief access specified object element with bounds checking
22042    /// @sa https://json.nlohmann.me/api/basic_json/at/
22043    template<class KeyType, detail::enable_if_t<
22044                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22045    reference at(KeyType && key)
22046    {
22047        // at only works for objects
22048        if (JSON_HEDLEY_UNLIKELY(!is_object()))
22049        {
22050            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
22051        }
22052
22053        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
22054        if (it == m_data.m_value.object->end())
22055        {
22056            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
22057        }
22058        return set_parent(it->second);
22059    }
22060
22061    /// @brief access specified object element with bounds checking
22062    /// @sa https://json.nlohmann.me/api/basic_json/at/
22063    const_reference at(const typename object_t::key_type& key) const
22064    {
22065        // at only works for objects
22066        if (JSON_HEDLEY_UNLIKELY(!is_object()))
22067        {
22068            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
22069        }
22070
22071        auto it = m_data.m_value.object->find(key);
22072        if (it == m_data.m_value.object->end())
22073        {
22074            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
22075        }
22076        return it->second;
22077    }
22078
22079    /// @brief access specified object element with bounds checking
22080    /// @sa https://json.nlohmann.me/api/basic_json/at/
22081    template<class KeyType, detail::enable_if_t<
22082                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22083    const_reference at(KeyType && key) const
22084    {
22085        // at only works for objects
22086        if (JSON_HEDLEY_UNLIKELY(!is_object()))
22087        {
22088            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
22089        }
22090
22091        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
22092        if (it == m_data.m_value.object->end())
22093        {
22094            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
22095        }
22096        return it->second;
22097    }
22098
22099    /// @brief access specified array element
22100    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
22101    reference operator[](size_type idx)
22102    {
22103        // implicitly convert null value to an empty array
22104        if (is_null())
22105        {
22106            m_data.m_type = value_t::array;
22107            m_data.m_value.array = create<array_t>();
22108            assert_invariant();
22109        }
22110
22111        // operator[] only works for arrays
22112        if (JSON_HEDLEY_LIKELY(is_array()))
22113        {
22114            // fill up array with null values if given idx is outside range
22115            if (idx >= m_data.m_value.array->size())
22116            {
22117#if JSON_DIAGNOSTICS
22118                // remember array size & capacity before resizing
22119                const auto old_size = m_data.m_value.array->size();
22120                const auto old_capacity = m_data.m_value.array->capacity();
22121#endif
22122                m_data.m_value.array->resize(idx + 1);
22123
22124#if JSON_DIAGNOSTICS
22125                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
22126                {
22127                    // capacity has changed: update all parents
22128                    set_parents();
22129                }
22130                else
22131                {
22132                    // set parent for values added above
22133                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
22134                }
22135#endif
22136                assert_invariant();
22137            }
22138
22139            return m_data.m_value.array->operator[](idx);
22140        }
22141
22142        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
22143    }
22144
22145    /// @brief access specified array element
22146    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
22147    const_reference operator[](size_type idx) const
22148    {
22149        // const operator[] only works for arrays
22150        if (JSON_HEDLEY_LIKELY(is_array()))
22151        {
22152            return m_data.m_value.array->operator[](idx);
22153        }
22154
22155        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
22156    }
22157
22158    /// @brief access specified object element
22159    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
22160    reference operator[](typename object_t::key_type key) // NOLINT(performance-unnecessary-value-param)
22161    {
22162        // implicitly convert null value to an empty object
22163        if (is_null())
22164        {
22165            m_data.m_type = value_t::object;
22166            m_data.m_value.object = create<object_t>();
22167            assert_invariant();
22168        }
22169
22170        // operator[] only works for objects
22171        if (JSON_HEDLEY_LIKELY(is_object()))
22172        {
22173            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
22174            return set_parent(result.first->second);
22175        }
22176
22177        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
22178    }
22179
22180    /// @brief access specified object element
22181    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
22182    const_reference operator[](const typename object_t::key_type& key) const
22183    {
22184        // const operator[] only works for objects
22185        if (JSON_HEDLEY_LIKELY(is_object()))
22186        {
22187            auto it = m_data.m_value.object->find(key);
22188            JSON_ASSERT(it != m_data.m_value.object->end());
22189            return it->second;
22190        }
22191
22192        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
22193    }
22194
22195    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
22196    // (they seemingly cannot be constrained to resolve the ambiguity)
22197    template<typename T>
22198    reference operator[](T* key)
22199    {
22200        return operator[](typename object_t::key_type(key));
22201    }
22202
22203    template<typename T>
22204    const_reference operator[](T* key) const
22205    {
22206        return operator[](typename object_t::key_type(key));
22207    }
22208
22209    /// @brief access specified object element
22210    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
22211    template<class KeyType, detail::enable_if_t<
22212                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
22213    reference operator[](KeyType && key)
22214    {
22215        // implicitly convert null value to an empty object
22216        if (is_null())
22217        {
22218            m_data.m_type = value_t::object;
22219            m_data.m_value.object = create<object_t>();
22220            assert_invariant();
22221        }
22222
22223        // operator[] only works for objects
22224        if (JSON_HEDLEY_LIKELY(is_object()))
22225        {
22226            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
22227            return set_parent(result.first->second);
22228        }
22229
22230        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
22231    }
22232
22233    /// @brief access specified object element
22234    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
22235    template<class KeyType, detail::enable_if_t<
22236                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
22237    const_reference operator[](KeyType && key) const
22238    {
22239        // const operator[] only works for objects
22240        if (JSON_HEDLEY_LIKELY(is_object()))
22241        {
22242            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
22243            JSON_ASSERT(it != m_data.m_value.object->end());
22244            return it->second;
22245        }
22246
22247        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
22248    }
22249
22250  private:
22251    template<typename KeyType>
22252    using is_comparable_with_object_key = detail::is_comparable <
22253        object_comparator_t, const typename object_t::key_type&, KeyType >;
22254
22255    template<typename ValueType>
22256    using value_return_type = std::conditional <
22257        detail::is_c_string_uncvref<ValueType>::value,
22258        string_t, typename std::decay<ValueType>::type >;
22259
22260  public:
22261    /// @brief access specified object element with default value
22262    /// @sa https://json.nlohmann.me/api/basic_json/value/
22263    template < class ValueType, detail::enable_if_t <
22264                   !detail::is_transparent<object_comparator_t>::value
22265                   && detail::is_getable<basic_json_t, ValueType>::value
22266                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22267    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
22268    {
22269        // value only works for objects
22270        if (JSON_HEDLEY_LIKELY(is_object()))
22271        {
22272            // if key is found, return value and given default value otherwise
22273            const auto it = find(key);
22274            if (it != end())
22275            {
22276                return it->template get<ValueType>();
22277            }
22278
22279            return default_value;
22280        }
22281
22282        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
22283    }
22284
22285    /// @brief access specified object element with default value
22286    /// @sa https://json.nlohmann.me/api/basic_json/value/
22287    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
22288               detail::enable_if_t <
22289                   !detail::is_transparent<object_comparator_t>::value
22290                   && detail::is_getable<basic_json_t, ReturnType>::value
22291                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22292    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
22293    {
22294        // value only works for objects
22295        if (JSON_HEDLEY_LIKELY(is_object()))
22296        {
22297            // if key is found, return value and given default value otherwise
22298            const auto it = find(key);
22299            if (it != end())
22300            {
22301                return it->template get<ReturnType>();
22302            }
22303
22304            return std::forward<ValueType>(default_value);
22305        }
22306
22307        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
22308    }
22309
22310    /// @brief access specified object element with default value
22311    /// @sa https://json.nlohmann.me/api/basic_json/value/
22312    template < class ValueType, class KeyType, detail::enable_if_t <
22313                   detail::is_transparent<object_comparator_t>::value
22314                   && !detail::is_json_pointer<KeyType>::value
22315                   && is_comparable_with_object_key<KeyType>::value
22316                   && detail::is_getable<basic_json_t, ValueType>::value
22317                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22318    ValueType value(KeyType && key, const ValueType& default_value) const
22319    {
22320        // value only works for objects
22321        if (JSON_HEDLEY_LIKELY(is_object()))
22322        {
22323            // if key is found, return value and given default value otherwise
22324            const auto it = find(std::forward<KeyType>(key));
22325            if (it != end())
22326            {
22327                return it->template get<ValueType>();
22328            }
22329
22330            return default_value;
22331        }
22332
22333        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
22334    }
22335
22336    /// @brief access specified object element via JSON Pointer with default value
22337    /// @sa https://json.nlohmann.me/api/basic_json/value/
22338    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
22339               detail::enable_if_t <
22340                   detail::is_transparent<object_comparator_t>::value
22341                   && !detail::is_json_pointer<KeyType>::value
22342                   && is_comparable_with_object_key<KeyType>::value
22343                   && detail::is_getable<basic_json_t, ReturnType>::value
22344                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22345    ReturnType value(KeyType && key, ValueType && default_value) const
22346    {
22347        // value only works for objects
22348        if (JSON_HEDLEY_LIKELY(is_object()))
22349        {
22350            // if key is found, return value and given default value otherwise
22351            const auto it = find(std::forward<KeyType>(key));
22352            if (it != end())
22353            {
22354                return it->template get<ReturnType>();
22355            }
22356
22357            return std::forward<ValueType>(default_value);
22358        }
22359
22360        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
22361    }
22362
22363    /// @brief access specified object element via JSON Pointer with default value
22364    /// @sa https://json.nlohmann.me/api/basic_json/value/
22365    template < class ValueType, detail::enable_if_t <
22366                   detail::is_getable<basic_json_t, ValueType>::value
22367                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22368    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
22369    {
22370        // value only works for objects
22371        if (JSON_HEDLEY_LIKELY(is_object()))
22372        {
22373            // if pointer resolves a value, return it or use default value
22374            JSON_TRY
22375            {
22376                return ptr.get_checked(this).template get<ValueType>();
22377            }
22378            JSON_INTERNAL_CATCH (out_of_range&)
22379            {
22380                return default_value;
22381            }
22382        }
22383
22384        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
22385    }
22386
22387    /// @brief access specified object element via JSON Pointer with default value
22388    /// @sa https://json.nlohmann.me/api/basic_json/value/
22389    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
22390               detail::enable_if_t <
22391                   detail::is_getable<basic_json_t, ReturnType>::value
22392                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22393    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
22394    {
22395        // value only works for objects
22396        if (JSON_HEDLEY_LIKELY(is_object()))
22397        {
22398            // if pointer resolves a value, return it or use default value
22399            JSON_TRY
22400            {
22401                return ptr.get_checked(this).template get<ReturnType>();
22402            }
22403            JSON_INTERNAL_CATCH (out_of_range&)
22404            {
22405                return std::forward<ValueType>(default_value);
22406            }
22407        }
22408
22409        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
22410    }
22411
22412    template < class ValueType, class BasicJsonType, detail::enable_if_t <
22413                   detail::is_basic_json<BasicJsonType>::value
22414                   && detail::is_getable<basic_json_t, ValueType>::value
22415                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22416    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
22417    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
22418    {
22419        return value(ptr.convert(), default_value);
22420    }
22421
22422    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
22423               detail::enable_if_t <
22424                   detail::is_basic_json<BasicJsonType>::value
22425                   && detail::is_getable<basic_json_t, ReturnType>::value
22426                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
22427    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
22428    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
22429    {
22430        return value(ptr.convert(), std::forward<ValueType>(default_value));
22431    }
22432
22433    /// @brief access the first element
22434    /// @sa https://json.nlohmann.me/api/basic_json/front/
22435    reference front()
22436    {
22437        return *begin();
22438    }
22439
22440    /// @brief access the first element
22441    /// @sa https://json.nlohmann.me/api/basic_json/front/
22442    const_reference front() const
22443    {
22444        return *cbegin();
22445    }
22446
22447    /// @brief access the last element
22448    /// @sa https://json.nlohmann.me/api/basic_json/back/
22449    reference back()
22450    {
22451        auto tmp = end();
22452        --tmp;
22453        return *tmp;
22454    }
22455
22456    /// @brief access the last element
22457    /// @sa https://json.nlohmann.me/api/basic_json/back/
22458    const_reference back() const
22459    {
22460        auto tmp = cend();
22461        --tmp;
22462        return *tmp;
22463    }
22464
22465    /// @brief remove element given an iterator
22466    /// @sa https://json.nlohmann.me/api/basic_json/erase/
22467    template < class IteratorType, detail::enable_if_t <
22468                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
22469                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
22470    IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
22471    {
22472        // make sure iterator fits the current value
22473        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
22474        {
22475            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
22476        }
22477
22478        IteratorType result = end();
22479
22480        switch (m_data.m_type)
22481        {
22482            case value_t::boolean:
22483            case value_t::number_float:
22484            case value_t::number_integer:
22485            case value_t::number_unsigned:
22486            case value_t::string:
22487            case value_t::binary:
22488            {
22489                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
22490                {
22491                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
22492                }
22493
22494                if (is_string())
22495                {
22496                    AllocatorType<string_t> alloc;
22497                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
22498                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
22499                    m_data.m_value.string = nullptr;
22500                }
22501                else if (is_binary())
22502                {
22503                    AllocatorType<binary_t> alloc;
22504                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
22505                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
22506                    m_data.m_value.binary = nullptr;
22507                }
22508
22509                m_data.m_type = value_t::null;
22510                assert_invariant();
22511                break;
22512            }
22513
22514            case value_t::object:
22515            {
22516                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
22517                break;
22518            }
22519
22520            case value_t::array:
22521            {
22522                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
22523                break;
22524            }
22525
22526            case value_t::null:
22527            case value_t::discarded:
22528            default:
22529                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
22530        }
22531
22532        return result;
22533    }
22534
22535    /// @brief remove elements given an iterator range
22536    /// @sa https://json.nlohmann.me/api/basic_json/erase/
22537    template < class IteratorType, detail::enable_if_t <
22538                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
22539                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
22540    IteratorType erase(IteratorType first, IteratorType last) // NOLINT(performance-unnecessary-value-param)
22541    {
22542        // make sure iterator fits the current value
22543        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
22544        {
22545            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
22546        }
22547
22548        IteratorType result = end();
22549
22550        switch (m_data.m_type)
22551        {
22552            case value_t::boolean:
22553            case value_t::number_float:
22554            case value_t::number_integer:
22555            case value_t::number_unsigned:
22556            case value_t::string:
22557            case value_t::binary:
22558            {
22559                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
22560                                       || !last.m_it.primitive_iterator.is_end()))
22561                {
22562                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
22563                }
22564
22565                if (is_string())
22566                {
22567                    AllocatorType<string_t> alloc;
22568                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
22569                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
22570                    m_data.m_value.string = nullptr;
22571                }
22572                else if (is_binary())
22573                {
22574                    AllocatorType<binary_t> alloc;
22575                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
22576                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
22577                    m_data.m_value.binary = nullptr;
22578                }
22579
22580                m_data.m_type = value_t::null;
22581                assert_invariant();
22582                break;
22583            }
22584
22585            case value_t::object:
22586            {
22587                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
22588                                              last.m_it.object_iterator);
22589                break;
22590            }
22591
22592            case value_t::array:
22593            {
22594                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
22595                                             last.m_it.array_iterator);
22596                break;
22597            }
22598
22599            case value_t::null:
22600            case value_t::discarded:
22601            default:
22602                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
22603        }
22604
22605        return result;
22606    }
22607
22608  private:
22609    template < typename KeyType, detail::enable_if_t <
22610                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
22611    size_type erase_internal(KeyType && key)
22612    {
22613        // this erase only works for objects
22614        if (JSON_HEDLEY_UNLIKELY(!is_object()))
22615        {
22616            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
22617        }
22618
22619        return m_data.m_value.object->erase(std::forward<KeyType>(key));
22620    }
22621
22622    template < typename KeyType, detail::enable_if_t <
22623                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
22624    size_type erase_internal(KeyType && key)
22625    {
22626        // this erase only works for objects
22627        if (JSON_HEDLEY_UNLIKELY(!is_object()))
22628        {
22629            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
22630        }
22631
22632        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
22633        if (it != m_data.m_value.object->end())
22634        {
22635            m_data.m_value.object->erase(it);
22636            return 1;
22637        }
22638        return 0;
22639    }
22640
22641  public:
22642
22643    /// @brief remove element from a JSON object given a key
22644    /// @sa https://json.nlohmann.me/api/basic_json/erase/
22645    size_type erase(const typename object_t::key_type& key)
22646    {
22647        // the indirection via erase_internal() is added to avoid making this
22648        // function a template and thus de-rank it during overload resolution
22649        return erase_internal(key);
22650    }
22651
22652    /// @brief remove element from a JSON object given a key
22653    /// @sa https://json.nlohmann.me/api/basic_json/erase/
22654    template<class KeyType, detail::enable_if_t<
22655                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22656    size_type erase(KeyType && key)
22657    {
22658        return erase_internal(std::forward<KeyType>(key));
22659    }
22660
22661    /// @brief remove element from a JSON array given an index
22662    /// @sa https://json.nlohmann.me/api/basic_json/erase/
22663    void erase(const size_type idx)
22664    {
22665        // this erase only works for arrays
22666        if (JSON_HEDLEY_LIKELY(is_array()))
22667        {
22668            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
22669            {
22670                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
22671            }
22672
22673            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
22674        }
22675        else
22676        {
22677            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
22678        }
22679    }
22680
22681    /// @}
22682
22683    ////////////
22684    // lookup //
22685    ////////////
22686
22687    /// @name lookup
22688    /// @{
22689
22690    /// @brief find an element in a JSON object
22691    /// @sa https://json.nlohmann.me/api/basic_json/find/
22692    iterator find(const typename object_t::key_type& key)
22693    {
22694        auto result = end();
22695
22696        if (is_object())
22697        {
22698            result.m_it.object_iterator = m_data.m_value.object->find(key);
22699        }
22700
22701        return result;
22702    }
22703
22704    /// @brief find an element in a JSON object
22705    /// @sa https://json.nlohmann.me/api/basic_json/find/
22706    const_iterator find(const typename object_t::key_type& key) const
22707    {
22708        auto result = cend();
22709
22710        if (is_object())
22711        {
22712            result.m_it.object_iterator = m_data.m_value.object->find(key);
22713        }
22714
22715        return result;
22716    }
22717
22718    /// @brief find an element in a JSON object
22719    /// @sa https://json.nlohmann.me/api/basic_json/find/
22720    template<class KeyType, detail::enable_if_t<
22721                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22722    iterator find(KeyType && key)
22723    {
22724        auto result = end();
22725
22726        if (is_object())
22727        {
22728            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
22729        }
22730
22731        return result;
22732    }
22733
22734    /// @brief find an element in a JSON object
22735    /// @sa https://json.nlohmann.me/api/basic_json/find/
22736    template<class KeyType, detail::enable_if_t<
22737                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22738    const_iterator find(KeyType && key) const
22739    {
22740        auto result = cend();
22741
22742        if (is_object())
22743        {
22744            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
22745        }
22746
22747        return result;
22748    }
22749
22750    /// @brief returns the number of occurrences of a key in a JSON object
22751    /// @sa https://json.nlohmann.me/api/basic_json/count/
22752    size_type count(const typename object_t::key_type& key) const
22753    {
22754        // return 0 for all nonobject types
22755        return is_object() ? m_data.m_value.object->count(key) : 0;
22756    }
22757
22758    /// @brief returns the number of occurrences of a key in a JSON object
22759    /// @sa https://json.nlohmann.me/api/basic_json/count/
22760    template<class KeyType, detail::enable_if_t<
22761                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22762    size_type count(KeyType && key) const
22763    {
22764        // return 0 for all nonobject types
22765        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
22766    }
22767
22768    /// @brief check the existence of an element in a JSON object
22769    /// @sa https://json.nlohmann.me/api/basic_json/contains/
22770    bool contains(const typename object_t::key_type& key) const
22771    {
22772        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
22773    }
22774
22775    /// @brief check the existence of an element in a JSON object
22776    /// @sa https://json.nlohmann.me/api/basic_json/contains/
22777    template<class KeyType, detail::enable_if_t<
22778                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
22779    bool contains(KeyType && key) const
22780    {
22781        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
22782    }
22783
22784    /// @brief check the existence of an element in a JSON object given a JSON pointer
22785    /// @sa https://json.nlohmann.me/api/basic_json/contains/
22786    bool contains(const json_pointer& ptr) const
22787    {
22788        return ptr.contains(this);
22789    }
22790
22791    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
22792    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
22793    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
22794    {
22795        return ptr.contains(this);
22796    }
22797
22798    /// @}
22799
22800    ///////////////
22801    // iterators //
22802    ///////////////
22803
22804    /// @name iterators
22805    /// @{
22806
22807    /// @brief returns an iterator to the first element
22808    /// @sa https://json.nlohmann.me/api/basic_json/begin/
22809    iterator begin() noexcept
22810    {
22811        iterator result(this);
22812        result.set_begin();
22813        return result;
22814    }
22815
22816    /// @brief returns an iterator to the first element
22817    /// @sa https://json.nlohmann.me/api/basic_json/begin/
22818    const_iterator begin() const noexcept
22819    {
22820        return cbegin();
22821    }
22822
22823    /// @brief returns a const iterator to the first element
22824    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
22825    const_iterator cbegin() const noexcept
22826    {
22827        const_iterator result(this);
22828        result.set_begin();
22829        return result;
22830    }
22831
22832    /// @brief returns an iterator to one past the last element
22833    /// @sa https://json.nlohmann.me/api/basic_json/end/
22834    iterator end() noexcept
22835    {
22836        iterator result(this);
22837        result.set_end();
22838        return result;
22839    }
22840
22841    /// @brief returns an iterator to one past the last element
22842    /// @sa https://json.nlohmann.me/api/basic_json/end/
22843    const_iterator end() const noexcept
22844    {
22845        return cend();
22846    }
22847
22848    /// @brief returns an iterator to one past the last element
22849    /// @sa https://json.nlohmann.me/api/basic_json/cend/
22850    const_iterator cend() const noexcept
22851    {
22852        const_iterator result(this);
22853        result.set_end();
22854        return result;
22855    }
22856
22857    /// @brief returns an iterator to the reverse-beginning
22858    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
22859    reverse_iterator rbegin() noexcept
22860    {
22861        return reverse_iterator(end());
22862    }
22863
22864    /// @brief returns an iterator to the reverse-beginning
22865    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
22866    const_reverse_iterator rbegin() const noexcept
22867    {
22868        return crbegin();
22869    }
22870
22871    /// @brief returns an iterator to the reverse-end
22872    /// @sa https://json.nlohmann.me/api/basic_json/rend/
22873    reverse_iterator rend() noexcept
22874    {
22875        return reverse_iterator(begin());
22876    }
22877
22878    /// @brief returns an iterator to the reverse-end
22879    /// @sa https://json.nlohmann.me/api/basic_json/rend/
22880    const_reverse_iterator rend() const noexcept
22881    {
22882        return crend();
22883    }
22884
22885    /// @brief returns a const reverse iterator to the last element
22886    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
22887    const_reverse_iterator crbegin() const noexcept
22888    {
22889        return const_reverse_iterator(cend());
22890    }
22891
22892    /// @brief returns a const reverse iterator to one before the first
22893    /// @sa https://json.nlohmann.me/api/basic_json/crend/
22894    const_reverse_iterator crend() const noexcept
22895    {
22896        return const_reverse_iterator(cbegin());
22897    }
22898
22899  public:
22900    /// @brief wrapper to access iterator member functions in range-based for
22901    /// @sa https://json.nlohmann.me/api/basic_json/items/
22902    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
22903    ///             version 4.0.0 of the library. Please use @ref items() instead;
22904    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
22905    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
22906    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
22907    {
22908        return ref.items();
22909    }
22910
22911    /// @brief wrapper to access iterator member functions in range-based for
22912    /// @sa https://json.nlohmann.me/api/basic_json/items/
22913    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
22914    ///         version 4.0.0 of the library. Please use @ref items() instead;
22915    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
22916    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
22917    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
22918    {
22919        return ref.items();
22920    }
22921
22922    /// @brief helper to access iterator member functions in range-based for
22923    /// @sa https://json.nlohmann.me/api/basic_json/items/
22924    iteration_proxy<iterator> items() noexcept
22925    {
22926        return iteration_proxy<iterator>(*this);
22927    }
22928
22929    /// @brief helper to access iterator member functions in range-based for
22930    /// @sa https://json.nlohmann.me/api/basic_json/items/
22931    iteration_proxy<const_iterator> items() const noexcept
22932    {
22933        return iteration_proxy<const_iterator>(*this);
22934    }
22935
22936    /// @}
22937
22938    //////////////
22939    // capacity //
22940    //////////////
22941
22942    /// @name capacity
22943    /// @{
22944
22945    /// @brief checks whether the container is empty.
22946    /// @sa https://json.nlohmann.me/api/basic_json/empty/
22947    bool empty() const noexcept
22948    {
22949        switch (m_data.m_type)
22950        {
22951            case value_t::null:
22952            {
22953                // null values are empty
22954                return true;
22955            }
22956
22957            case value_t::array:
22958            {
22959                // delegate call to array_t::empty()
22960                return m_data.m_value.array->empty();
22961            }
22962
22963            case value_t::object:
22964            {
22965                // delegate call to object_t::empty()
22966                return m_data.m_value.object->empty();
22967            }
22968
22969            case value_t::string:
22970            case value_t::boolean:
22971            case value_t::number_integer:
22972            case value_t::number_unsigned:
22973            case value_t::number_float:
22974            case value_t::binary:
22975            case value_t::discarded:
22976            default:
22977            {
22978                // all other types are nonempty
22979                return false;
22980            }
22981        }
22982    }
22983
22984    /// @brief returns the number of elements
22985    /// @sa https://json.nlohmann.me/api/basic_json/size/
22986    size_type size() const noexcept
22987    {
22988        switch (m_data.m_type)
22989        {
22990            case value_t::null:
22991            {
22992                // null values are empty
22993                return 0;
22994            }
22995
22996            case value_t::array:
22997            {
22998                // delegate call to array_t::size()
22999                return m_data.m_value.array->size();
23000            }
23001
23002            case value_t::object:
23003            {
23004                // delegate call to object_t::size()
23005                return m_data.m_value.object->size();
23006            }
23007
23008            case value_t::string:
23009            case value_t::boolean:
23010            case value_t::number_integer:
23011            case value_t::number_unsigned:
23012            case value_t::number_float:
23013            case value_t::binary:
23014            case value_t::discarded:
23015            default:
23016            {
23017                // all other types have size 1
23018                return 1;
23019            }
23020        }
23021    }
23022
23023    /// @brief returns the maximum possible number of elements
23024    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
23025    size_type max_size() const noexcept
23026    {
23027        switch (m_data.m_type)
23028        {
23029            case value_t::array:
23030            {
23031                // delegate call to array_t::max_size()
23032                return m_data.m_value.array->max_size();
23033            }
23034
23035            case value_t::object:
23036            {
23037                // delegate call to object_t::max_size()
23038                return m_data.m_value.object->max_size();
23039            }
23040
23041            case value_t::null:
23042            case value_t::string:
23043            case value_t::boolean:
23044            case value_t::number_integer:
23045            case value_t::number_unsigned:
23046            case value_t::number_float:
23047            case value_t::binary:
23048            case value_t::discarded:
23049            default:
23050            {
23051                // all other types have max_size() == size()
23052                return size();
23053            }
23054        }
23055    }
23056
23057    /// @}
23058
23059    ///////////////
23060    // modifiers //
23061    ///////////////
23062
23063    /// @name modifiers
23064    /// @{
23065
23066    /// @brief clears the contents
23067    /// @sa https://json.nlohmann.me/api/basic_json/clear/
23068    void clear() noexcept
23069    {
23070        switch (m_data.m_type)
23071        {
23072            case value_t::number_integer:
23073            {
23074                m_data.m_value.number_integer = 0;
23075                break;
23076            }
23077
23078            case value_t::number_unsigned:
23079            {
23080                m_data.m_value.number_unsigned = 0;
23081                break;
23082            }
23083
23084            case value_t::number_float:
23085            {
23086                m_data.m_value.number_float = 0.0;
23087                break;
23088            }
23089
23090            case value_t::boolean:
23091            {
23092                m_data.m_value.boolean = false;
23093                break;
23094            }
23095
23096            case value_t::string:
23097            {
23098                m_data.m_value.string->clear();
23099                break;
23100            }
23101
23102            case value_t::binary:
23103            {
23104                m_data.m_value.binary->clear();
23105                break;
23106            }
23107
23108            case value_t::array:
23109            {
23110                m_data.m_value.array->clear();
23111                break;
23112            }
23113
23114            case value_t::object:
23115            {
23116                m_data.m_value.object->clear();
23117                break;
23118            }
23119
23120            case value_t::null:
23121            case value_t::discarded:
23122            default:
23123                break;
23124        }
23125    }
23126
23127    /// @brief add an object to an array
23128    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
23129    void push_back(basic_json&& val)
23130    {
23131        // push_back only works for null objects or arrays
23132        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
23133        {
23134            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
23135        }
23136
23137        // transform null object into an array
23138        if (is_null())
23139        {
23140            m_data.m_type = value_t::array;
23141            m_data.m_value = value_t::array;
23142            assert_invariant();
23143        }
23144
23145        // add element to array (move semantics)
23146        const auto old_capacity = m_data.m_value.array->capacity();
23147        m_data.m_value.array->push_back(std::move(val));
23148        set_parent(m_data.m_value.array->back(), old_capacity);
23149        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
23150    }
23151
23152    /// @brief add an object to an array
23153    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
23154    reference operator+=(basic_json&& val)
23155    {
23156        push_back(std::move(val));
23157        return *this;
23158    }
23159
23160    /// @brief add an object to an array
23161    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
23162    void push_back(const basic_json& val)
23163    {
23164        // push_back only works for null objects or arrays
23165        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
23166        {
23167            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
23168        }
23169
23170        // transform null object into an array
23171        if (is_null())
23172        {
23173            m_data.m_type = value_t::array;
23174            m_data.m_value = value_t::array;
23175            assert_invariant();
23176        }
23177
23178        // add element to array
23179        const auto old_capacity = m_data.m_value.array->capacity();
23180        m_data.m_value.array->push_back(val);
23181        set_parent(m_data.m_value.array->back(), old_capacity);
23182    }
23183
23184    /// @brief add an object to an array
23185    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
23186    reference operator+=(const basic_json& val)
23187    {
23188        push_back(val);
23189        return *this;
23190    }
23191
23192    /// @brief add an object to an object
23193    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
23194    void push_back(const typename object_t::value_type& val)
23195    {
23196        // push_back only works for null objects or objects
23197        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
23198        {
23199            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
23200        }
23201
23202        // transform null object into an object
23203        if (is_null())
23204        {
23205            m_data.m_type = value_t::object;
23206            m_data.m_value = value_t::object;
23207            assert_invariant();
23208        }
23209
23210        // add element to object
23211        auto res = m_data.m_value.object->insert(val);
23212        set_parent(res.first->second);
23213    }
23214
23215    /// @brief add an object to an object
23216    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
23217    reference operator+=(const typename object_t::value_type& val)
23218    {
23219        push_back(val);
23220        return *this;
23221    }
23222
23223    /// @brief add an object to an object
23224    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
23225    void push_back(initializer_list_t init)
23226    {
23227        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
23228        {
23229            basic_json&& key = init.begin()->moved_or_copied();
23230            push_back(typename object_t::value_type(
23231                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
23232        }
23233        else
23234        {
23235            push_back(basic_json(init));
23236        }
23237    }
23238
23239    /// @brief add an object to an object
23240    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
23241    reference operator+=(initializer_list_t init)
23242    {
23243        push_back(init);
23244        return *this;
23245    }
23246
23247    /// @brief add an object to an array
23248    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
23249    template<class... Args>
23250    reference emplace_back(Args&& ... args)
23251    {
23252        // emplace_back only works for null objects or arrays
23253        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
23254        {
23255            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
23256        }
23257
23258        // transform null object into an array
23259        if (is_null())
23260        {
23261            m_data.m_type = value_t::array;
23262            m_data.m_value = value_t::array;
23263            assert_invariant();
23264        }
23265
23266        // add element to array (perfect forwarding)
23267        const auto old_capacity = m_data.m_value.array->capacity();
23268        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
23269        return set_parent(m_data.m_value.array->back(), old_capacity);
23270    }
23271
23272    /// @brief add an object to an object if key does not exist
23273    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
23274    template<class... Args>
23275    std::pair<iterator, bool> emplace(Args&& ... args)
23276    {
23277        // emplace only works for null objects or arrays
23278        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
23279        {
23280            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
23281        }
23282
23283        // transform null object into an object
23284        if (is_null())
23285        {
23286            m_data.m_type = value_t::object;
23287            m_data.m_value = value_t::object;
23288            assert_invariant();
23289        }
23290
23291        // add element to array (perfect forwarding)
23292        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
23293        set_parent(res.first->second);
23294
23295        // create result iterator and set iterator to the result of emplace
23296        auto it = begin();
23297        it.m_it.object_iterator = res.first;
23298
23299        // return pair of iterator and boolean
23300        return {it, res.second};
23301    }
23302
23303    /// Helper for insertion of an iterator
23304    /// @note: This uses std::distance to support GCC 4.8,
23305    ///        see https://github.com/nlohmann/json/pull/1257
23306    template<typename... Args>
23307    iterator insert_iterator(const_iterator pos, Args&& ... args) // NOLINT(performance-unnecessary-value-param)
23308    {
23309        iterator result(this);
23310        JSON_ASSERT(m_data.m_value.array != nullptr);
23311
23312        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
23313        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
23314        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
23315
23316        // This could have been written as:
23317        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
23318        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
23319
23320        set_parents();
23321        return result;
23322    }
23323
23324    /// @brief inserts element into array
23325    /// @sa https://json.nlohmann.me/api/basic_json/insert/
23326    iterator insert(const_iterator pos, const basic_json& val) // NOLINT(performance-unnecessary-value-param)
23327    {
23328        // insert only works for arrays
23329        if (JSON_HEDLEY_LIKELY(is_array()))
23330        {
23331            // check if iterator pos fits to this JSON value
23332            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
23333            {
23334                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
23335            }
23336
23337            // insert to array and return iterator
23338            return insert_iterator(pos, val);
23339        }
23340
23341        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
23342    }
23343
23344    /// @brief inserts element into array
23345    /// @sa https://json.nlohmann.me/api/basic_json/insert/
23346    iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performance-unnecessary-value-param)
23347    {
23348        return insert(pos, val);
23349    }
23350
23351    /// @brief inserts copies of element into array
23352    /// @sa https://json.nlohmann.me/api/basic_json/insert/
23353    iterator insert(const_iterator pos, size_type cnt, const basic_json& val) // NOLINT(performance-unnecessary-value-param)
23354    {
23355        // insert only works for arrays
23356        if (JSON_HEDLEY_LIKELY(is_array()))
23357        {
23358            // check if iterator pos fits to this JSON value
23359            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
23360            {
23361                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
23362            }
23363
23364            // insert to array and return iterator
23365            return insert_iterator(pos, cnt, val);
23366        }
23367
23368        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
23369    }
23370
23371    /// @brief inserts range of elements into array
23372    /// @sa https://json.nlohmann.me/api/basic_json/insert/
23373    iterator insert(const_iterator pos, const_iterator first, const_iterator last) // NOLINT(performance-unnecessary-value-param)
23374    {
23375        // insert only works for arrays
23376        if (JSON_HEDLEY_UNLIKELY(!is_array()))
23377        {
23378            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
23379        }
23380
23381        // check if iterator pos fits to this JSON value
23382        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
23383        {
23384            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
23385        }
23386
23387        // check if range iterators belong to the same JSON object
23388        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23389        {
23390            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
23391        }
23392
23393        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
23394        {
23395            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
23396        }
23397
23398        // insert to array and return iterator
23399        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
23400    }
23401
23402    /// @brief inserts elements from initializer list into array
23403    /// @sa https://json.nlohmann.me/api/basic_json/insert/
23404    iterator insert(const_iterator pos, initializer_list_t ilist) // NOLINT(performance-unnecessary-value-param)
23405    {
23406        // insert only works for arrays
23407        if (JSON_HEDLEY_UNLIKELY(!is_array()))
23408        {
23409            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
23410        }
23411
23412        // check if iterator pos fits to this JSON value
23413        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
23414        {
23415            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
23416        }
23417
23418        // insert to array and return iterator
23419        return insert_iterator(pos, ilist.begin(), ilist.end());
23420    }
23421
23422    /// @brief inserts range of elements into object
23423    /// @sa https://json.nlohmann.me/api/basic_json/insert/
23424    void insert(const_iterator first, const_iterator last) // NOLINT(performance-unnecessary-value-param)
23425    {
23426        // insert only works for objects
23427        if (JSON_HEDLEY_UNLIKELY(!is_object()))
23428        {
23429            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
23430        }
23431
23432        // check if range iterators belong to the same JSON object
23433        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23434        {
23435            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
23436        }
23437
23438        // passed iterators must belong to objects
23439        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
23440        {
23441            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
23442        }
23443
23444        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
23445        set_parents();
23446    }
23447
23448    /// @brief updates a JSON object from another object, overwriting existing keys
23449    /// @sa https://json.nlohmann.me/api/basic_json/update/
23450    void update(const_reference j, bool merge_objects = false)
23451    {
23452        update(j.begin(), j.end(), merge_objects);
23453    }
23454
23455    /// @brief updates a JSON object from another object, overwriting existing keys
23456    /// @sa https://json.nlohmann.me/api/basic_json/update/
23457    void update(const_iterator first, const_iterator last, bool merge_objects = false) // NOLINT(performance-unnecessary-value-param)
23458    {
23459        // implicitly convert null value to an empty object
23460        if (is_null())
23461        {
23462            m_data.m_type = value_t::object;
23463            m_data.m_value.object = create<object_t>();
23464            assert_invariant();
23465        }
23466
23467        if (JSON_HEDLEY_UNLIKELY(!is_object()))
23468        {
23469            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
23470        }
23471
23472        // check if range iterators belong to the same JSON object
23473        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23474        {
23475            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
23476        }
23477
23478        // passed iterators must belong to objects
23479        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
23480        {
23481            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
23482        }
23483
23484        for (auto it = first; it != last; ++it)
23485        {
23486            if (merge_objects && it.value().is_object())
23487            {
23488                auto it2 = m_data.m_value.object->find(it.key());
23489                if (it2 != m_data.m_value.object->end())
23490                {
23491                    it2->second.update(it.value(), true);
23492                    continue;
23493                }
23494            }
23495            m_data.m_value.object->operator[](it.key()) = it.value();
23496#if JSON_DIAGNOSTICS
23497            m_data.m_value.object->operator[](it.key()).m_parent = this;
23498#endif
23499        }
23500    }
23501
23502    /// @brief exchanges the values
23503    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23504    void swap(reference other) noexcept (
23505        std::is_nothrow_move_constructible<value_t>::value&&
23506        std::is_nothrow_move_assignable<value_t>::value&&
23507        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
23508        std::is_nothrow_move_assignable<json_value>::value
23509    )
23510    {
23511        std::swap(m_data.m_type, other.m_data.m_type);
23512        std::swap(m_data.m_value, other.m_data.m_value);
23513
23514        set_parents();
23515        other.set_parents();
23516        assert_invariant();
23517    }
23518
23519    /// @brief exchanges the values
23520    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23521    friend void swap(reference left, reference right) noexcept (
23522        std::is_nothrow_move_constructible<value_t>::value&&
23523        std::is_nothrow_move_assignable<value_t>::value&&
23524        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
23525        std::is_nothrow_move_assignable<json_value>::value
23526    )
23527    {
23528        left.swap(right);
23529    }
23530
23531    /// @brief exchanges the values
23532    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23533    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
23534    {
23535        // swap only works for arrays
23536        if (JSON_HEDLEY_LIKELY(is_array()))
23537        {
23538            using std::swap;
23539            swap(*(m_data.m_value.array), other);
23540        }
23541        else
23542        {
23543            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
23544        }
23545    }
23546
23547    /// @brief exchanges the values
23548    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23549    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
23550    {
23551        // swap only works for objects
23552        if (JSON_HEDLEY_LIKELY(is_object()))
23553        {
23554            using std::swap;
23555            swap(*(m_data.m_value.object), other);
23556        }
23557        else
23558        {
23559            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
23560        }
23561    }
23562
23563    /// @brief exchanges the values
23564    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23565    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
23566    {
23567        // swap only works for strings
23568        if (JSON_HEDLEY_LIKELY(is_string()))
23569        {
23570            using std::swap;
23571            swap(*(m_data.m_value.string), other);
23572        }
23573        else
23574        {
23575            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
23576        }
23577    }
23578
23579    /// @brief exchanges the values
23580    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23581    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
23582    {
23583        // swap only works for strings
23584        if (JSON_HEDLEY_LIKELY(is_binary()))
23585        {
23586            using std::swap;
23587            swap(*(m_data.m_value.binary), other);
23588        }
23589        else
23590        {
23591            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
23592        }
23593    }
23594
23595    /// @brief exchanges the values
23596    /// @sa https://json.nlohmann.me/api/basic_json/swap/
23597    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
23598    {
23599        // swap only works for strings
23600        if (JSON_HEDLEY_LIKELY(is_binary()))
23601        {
23602            using std::swap;
23603            swap(*(m_data.m_value.binary), other);
23604        }
23605        else
23606        {
23607            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
23608        }
23609    }
23610
23611    /// @}
23612
23613    //////////////////////////////////////////
23614    // lexicographical comparison operators //
23615    //////////////////////////////////////////
23616
23617    /// @name lexicographical comparison operators
23618    /// @{
23619
23620    // note parentheses around operands are necessary; see
23621    // https://github.com/nlohmann/json/issues/1530
23622#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
23623    const auto lhs_type = lhs.type();                                                                    \
23624    const auto rhs_type = rhs.type();                                                                    \
23625    \
23626    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
23627    {                                                                                                    \
23628        switch (lhs_type)                                                                                \
23629        {                                                                                                \
23630            case value_t::array:                                                                         \
23631                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
23632                \
23633            case value_t::object:                                                                        \
23634                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
23635                \
23636            case value_t::null:                                                                          \
23637                return (null_result);                                                                    \
23638                \
23639            case value_t::string:                                                                        \
23640                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
23641                \
23642            case value_t::boolean:                                                                       \
23643                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
23644                \
23645            case value_t::number_integer:                                                                \
23646                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
23647                \
23648            case value_t::number_unsigned:                                                               \
23649                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
23650                \
23651            case value_t::number_float:                                                                  \
23652                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
23653                \
23654            case value_t::binary:                                                                        \
23655                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
23656                \
23657            case value_t::discarded:                                                                     \
23658            default:                                                                                     \
23659                return (unordered_result);                                                               \
23660        }                                                                                                \
23661    }                                                                                                    \
23662    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
23663    {                                                                                                    \
23664        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
23665    }                                                                                                    \
23666    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
23667    {                                                                                                    \
23668        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
23669    }                                                                                                    \
23670    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
23671    {                                                                                                    \
23672        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
23673    }                                                                                                    \
23674    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
23675    {                                                                                                    \
23676        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
23677    }                                                                                                    \
23678    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
23679    {                                                                                                    \
23680        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
23681    }                                                                                                    \
23682    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
23683    {                                                                                                    \
23684        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
23685    }                                                                                                    \
23686    else if(compares_unordered(lhs, rhs))\
23687    {\
23688        return (unordered_result);\
23689    }\
23690    \
23691    return (default_result);
23692
23693  JSON_PRIVATE_UNLESS_TESTED:
23694    // returns true if:
23695    // - any operand is NaN and the other operand is of number type
23696    // - any operand is discarded
23697    // in legacy mode, discarded values are considered ordered if
23698    // an operation is computed as an odd number of inverses of others
23699    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
23700    {
23701        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
23702                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
23703        {
23704            return true;
23705        }
23706#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
23707        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
23708#else
23709        static_cast<void>(inverse);
23710        return lhs.is_discarded() || rhs.is_discarded();
23711#endif
23712    }
23713
23714  private:
23715    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
23716    {
23717        return compares_unordered(*this, rhs, inverse);
23718    }
23719
23720  public:
23721#if JSON_HAS_THREE_WAY_COMPARISON
23722    /// @brief comparison: equal
23723    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
23724    bool operator==(const_reference rhs) const noexcept
23725    {
23726#ifdef __GNUC__
23727#pragma GCC diagnostic push
23728#pragma GCC diagnostic ignored "-Wfloat-equal"
23729#endif
23730        const_reference lhs = *this;
23731        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
23732#ifdef __GNUC__
23733#pragma GCC diagnostic pop
23734#endif
23735    }
23736
23737    /// @brief comparison: equal
23738    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
23739    template<typename ScalarType>
23740    requires std::is_scalar_v<ScalarType>
23741    bool operator==(ScalarType rhs) const noexcept
23742    {
23743        return *this == basic_json(rhs);
23744    }
23745
23746    /// @brief comparison: not equal
23747    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
23748    bool operator!=(const_reference rhs) const noexcept
23749    {
23750        if (compares_unordered(rhs, true))
23751        {
23752            return false;
23753        }
23754        return !operator==(rhs);
23755    }
23756
23757    /// @brief comparison: 3-way
23758    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
23759    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
23760    {
23761        const_reference lhs = *this;
23762        // default_result is used if we cannot compare values. In that case,
23763        // we compare types.
23764        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
23765                                std::partial_ordering::equivalent,
23766                                std::partial_ordering::unordered,
23767                                lhs_type <=> rhs_type) // *NOPAD*
23768    }
23769
23770    /// @brief comparison: 3-way
23771    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
23772    template<typename ScalarType>
23773    requires std::is_scalar_v<ScalarType>
23774    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
23775    {
23776        return *this <=> basic_json(rhs); // *NOPAD*
23777    }
23778
23779#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
23780    // all operators that are computed as an odd number of inverses of others
23781    // need to be overloaded to emulate the legacy comparison behavior
23782
23783    /// @brief comparison: less than or equal
23784    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
23785    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
23786    bool operator<=(const_reference rhs) const noexcept
23787    {
23788        if (compares_unordered(rhs, true))
23789        {
23790            return false;
23791        }
23792        return !(rhs < *this);
23793    }
23794
23795    /// @brief comparison: less than or equal
23796    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
23797    template<typename ScalarType>
23798    requires std::is_scalar_v<ScalarType>
23799    bool operator<=(ScalarType rhs) const noexcept
23800    {
23801        return *this <= basic_json(rhs);
23802    }
23803
23804    /// @brief comparison: greater than or equal
23805    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
23806    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
23807    bool operator>=(const_reference rhs) const noexcept
23808    {
23809        if (compares_unordered(rhs, true))
23810        {
23811            return false;
23812        }
23813        return !(*this < rhs);
23814    }
23815
23816    /// @brief comparison: greater than or equal
23817    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
23818    template<typename ScalarType>
23819    requires std::is_scalar_v<ScalarType>
23820    bool operator>=(ScalarType rhs) const noexcept
23821    {
23822        return *this >= basic_json(rhs);
23823    }
23824#endif
23825#else
23826    /// @brief comparison: equal
23827    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
23828    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
23829    {
23830#ifdef __GNUC__
23831#pragma GCC diagnostic push
23832#pragma GCC diagnostic ignored "-Wfloat-equal"
23833#endif
23834        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
23835#ifdef __GNUC__
23836#pragma GCC diagnostic pop
23837#endif
23838    }
23839
23840    /// @brief comparison: equal
23841    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
23842    template<typename ScalarType, typename std::enable_if<
23843                 std::is_scalar<ScalarType>::value, int>::type = 0>
23844    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
23845    {
23846        return lhs == basic_json(rhs);
23847    }
23848
23849    /// @brief comparison: equal
23850    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
23851    template<typename ScalarType, typename std::enable_if<
23852                 std::is_scalar<ScalarType>::value, int>::type = 0>
23853    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
23854    {
23855        return basic_json(lhs) == rhs;
23856    }
23857
23858    /// @brief comparison: not equal
23859    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
23860    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
23861    {
23862        if (compares_unordered(lhs, rhs, true))
23863        {
23864            return false;
23865        }
23866        return !(lhs == rhs);
23867    }
23868
23869    /// @brief comparison: not equal
23870    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
23871    template<typename ScalarType, typename std::enable_if<
23872                 std::is_scalar<ScalarType>::value, int>::type = 0>
23873    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
23874    {
23875        return lhs != basic_json(rhs);
23876    }
23877
23878    /// @brief comparison: not equal
23879    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
23880    template<typename ScalarType, typename std::enable_if<
23881                 std::is_scalar<ScalarType>::value, int>::type = 0>
23882    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
23883    {
23884        return basic_json(lhs) != rhs;
23885    }
23886
23887    /// @brief comparison: less than
23888    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
23889    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
23890    {
23891        // default_result is used if we cannot compare values. In that case,
23892        // we compare types. Note we have to call the operator explicitly,
23893        // because MSVC has problems otherwise.
23894        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
23895    }
23896
23897    /// @brief comparison: less than
23898    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
23899    template<typename ScalarType, typename std::enable_if<
23900                 std::is_scalar<ScalarType>::value, int>::type = 0>
23901    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
23902    {
23903        return lhs < basic_json(rhs);
23904    }
23905
23906    /// @brief comparison: less than
23907    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
23908    template<typename ScalarType, typename std::enable_if<
23909                 std::is_scalar<ScalarType>::value, int>::type = 0>
23910    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
23911    {
23912        return basic_json(lhs) < rhs;
23913    }
23914
23915    /// @brief comparison: less than or equal
23916    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
23917    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
23918    {
23919        if (compares_unordered(lhs, rhs, true))
23920        {
23921            return false;
23922        }
23923        return !(rhs < lhs);
23924    }
23925
23926    /// @brief comparison: less than or equal
23927    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
23928    template<typename ScalarType, typename std::enable_if<
23929                 std::is_scalar<ScalarType>::value, int>::type = 0>
23930    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
23931    {
23932        return lhs <= basic_json(rhs);
23933    }
23934
23935    /// @brief comparison: less than or equal
23936    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
23937    template<typename ScalarType, typename std::enable_if<
23938                 std::is_scalar<ScalarType>::value, int>::type = 0>
23939    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
23940    {
23941        return basic_json(lhs) <= rhs;
23942    }
23943
23944    /// @brief comparison: greater than
23945    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
23946    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
23947    {
23948        // double inverse
23949        if (compares_unordered(lhs, rhs))
23950        {
23951            return false;
23952        }
23953        return !(lhs <= rhs);
23954    }
23955
23956    /// @brief comparison: greater than
23957    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
23958    template<typename ScalarType, typename std::enable_if<
23959                 std::is_scalar<ScalarType>::value, int>::type = 0>
23960    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
23961    {
23962        return lhs > basic_json(rhs);
23963    }
23964
23965    /// @brief comparison: greater than
23966    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
23967    template<typename ScalarType, typename std::enable_if<
23968                 std::is_scalar<ScalarType>::value, int>::type = 0>
23969    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
23970    {
23971        return basic_json(lhs) > rhs;
23972    }
23973
23974    /// @brief comparison: greater than or equal
23975    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
23976    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
23977    {
23978        if (compares_unordered(lhs, rhs, true))
23979        {
23980            return false;
23981        }
23982        return !(lhs < rhs);
23983    }
23984
23985    /// @brief comparison: greater than or equal
23986    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
23987    template<typename ScalarType, typename std::enable_if<
23988                 std::is_scalar<ScalarType>::value, int>::type = 0>
23989    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
23990    {
23991        return lhs >= basic_json(rhs);
23992    }
23993
23994    /// @brief comparison: greater than or equal
23995    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
23996    template<typename ScalarType, typename std::enable_if<
23997                 std::is_scalar<ScalarType>::value, int>::type = 0>
23998    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
23999    {
24000        return basic_json(lhs) >= rhs;
24001    }
24002#endif
24003
24004#undef JSON_IMPLEMENT_OPERATOR
24005
24006    /// @}
24007
24008    ///////////////////
24009    // serialization //
24010    ///////////////////
24011
24012    /// @name serialization
24013    /// @{
24014#ifndef JSON_NO_IO
24015    /// @brief serialize to stream
24016    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
24017    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
24018    {
24019        // read width member and use it as indentation parameter if nonzero
24020        const bool pretty_print = o.width() > 0;
24021        const auto indentation = pretty_print ? o.width() : 0;
24022
24023        // reset width to 0 for subsequent calls to this stream
24024        o.width(0);
24025
24026        // do the actual serialization
24027        serializer s(detail::output_adapter<char>(o), o.fill());
24028        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
24029        return o;
24030    }
24031
24032    /// @brief serialize to stream
24033    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
24034    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
24035    ///             version 4.0.0 of the library. Please use
24036    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
24037    ///             replace calls like `j >> o;` with `o << j;`.
24038    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
24039    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
24040    {
24041        return o << j;
24042    }
24043#endif  // JSON_NO_IO
24044    /// @}
24045
24046    /////////////////////
24047    // deserialization //
24048    /////////////////////
24049
24050    /// @name deserialization
24051    /// @{
24052
24053    /// @brief deserialize from a compatible input
24054    /// @sa https://json.nlohmann.me/api/basic_json/parse/
24055    template<typename InputType>
24056    JSON_HEDLEY_WARN_UNUSED_RESULT
24057    static basic_json parse(InputType&& i,
24058                            parser_callback_t cb = nullptr,
24059                            const bool allow_exceptions = true,
24060                            const bool ignore_comments = false)
24061    {
24062        basic_json result;
24063        parser(detail::input_adapter(std::forward<InputType>(i)), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved,accessForwarded]
24064        return result;
24065    }
24066
24067    /// @brief deserialize from a pair of character iterators
24068    /// @sa https://json.nlohmann.me/api/basic_json/parse/
24069    template<typename IteratorType>
24070    JSON_HEDLEY_WARN_UNUSED_RESULT
24071    static basic_json parse(IteratorType first,
24072                            IteratorType last,
24073                            parser_callback_t cb = nullptr,
24074                            const bool allow_exceptions = true,
24075                            const bool ignore_comments = false)
24076    {
24077        basic_json result;
24078        parser(detail::input_adapter(std::move(first), std::move(last)), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved]
24079        return result;
24080    }
24081
24082    JSON_HEDLEY_WARN_UNUSED_RESULT
24083    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
24084    static basic_json parse(detail::span_input_adapter&& i,
24085                            parser_callback_t cb = nullptr,
24086                            const bool allow_exceptions = true,
24087                            const bool ignore_comments = false)
24088    {
24089        basic_json result;
24090        parser(i.get(), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved]
24091        return result;
24092    }
24093
24094    /// @brief check if the input is valid JSON
24095    /// @sa https://json.nlohmann.me/api/basic_json/accept/
24096    template<typename InputType>
24097    static bool accept(InputType&& i,
24098                       const bool ignore_comments = false)
24099    {
24100        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
24101    }
24102
24103    /// @brief check if the input is valid JSON
24104    /// @sa https://json.nlohmann.me/api/basic_json/accept/
24105    template<typename IteratorType>
24106    static bool accept(IteratorType first, IteratorType last,
24107                       const bool ignore_comments = false)
24108    {
24109        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
24110    }
24111
24112    JSON_HEDLEY_WARN_UNUSED_RESULT
24113    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
24114    static bool accept(detail::span_input_adapter&& i,
24115                       const bool ignore_comments = false)
24116    {
24117        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
24118    }
24119
24120    /// @brief generate SAX events
24121    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
24122    template <typename InputType, typename SAX>
24123    JSON_HEDLEY_NON_NULL(2)
24124    static bool sax_parse(InputType&& i, SAX* sax,
24125                          input_format_t format = input_format_t::json,
24126                          const bool strict = true,
24127                          const bool ignore_comments = false)
24128    {
24129        auto ia = detail::input_adapter(std::forward<InputType>(i));
24130        return format == input_format_t::json
24131               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
24132               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
24133    }
24134
24135    /// @brief generate SAX events
24136    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
24137    template<class IteratorType, class SAX>
24138    JSON_HEDLEY_NON_NULL(3)
24139    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
24140                          input_format_t format = input_format_t::json,
24141                          const bool strict = true,
24142                          const bool ignore_comments = false)
24143    {
24144        auto ia = detail::input_adapter(std::move(first), std::move(last));
24145        return format == input_format_t::json
24146               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
24147               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
24148    }
24149
24150    /// @brief generate SAX events
24151    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
24152    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
24153    ///             version 4.0.0 of the library. Please use
24154    ///             sax_parse(ptr, ptr + len) instead.
24155    template <typename SAX>
24156    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
24157    JSON_HEDLEY_NON_NULL(2)
24158    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
24159                          input_format_t format = input_format_t::json,
24160                          const bool strict = true,
24161                          const bool ignore_comments = false)
24162    {
24163        auto ia = i.get();
24164        return format == input_format_t::json
24165               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
24166               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
24167               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
24168               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
24169    }
24170#ifndef JSON_NO_IO
24171    /// @brief deserialize from stream
24172    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
24173    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
24174    ///             version 4.0.0 of the library. Please use
24175    ///             operator>>(std::istream&, basic_json&) instead; that is,
24176    ///             replace calls like `j << i;` with `i >> j;`.
24177    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
24178    friend std::istream& operator<<(basic_json& j, std::istream& i)
24179    {
24180        return operator>>(i, j);
24181    }
24182
24183    /// @brief deserialize from stream
24184    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
24185    friend std::istream& operator>>(std::istream& i, basic_json& j)
24186    {
24187        parser(detail::input_adapter(i)).parse(false, j);
24188        return i;
24189    }
24190#endif  // JSON_NO_IO
24191    /// @}
24192
24193    ///////////////////////////
24194    // convenience functions //
24195    ///////////////////////////
24196
24197    /// @brief return the type as string
24198    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
24199    JSON_HEDLEY_RETURNS_NON_NULL
24200    const char* type_name() const noexcept
24201    {
24202        switch (m_data.m_type)
24203        {
24204            case value_t::null:
24205                return "null";
24206            case value_t::object:
24207                return "object";
24208            case value_t::array:
24209                return "array";
24210            case value_t::string:
24211                return "string";
24212            case value_t::boolean:
24213                return "boolean";
24214            case value_t::binary:
24215                return "binary";
24216            case value_t::discarded:
24217                return "discarded";
24218            case value_t::number_integer:
24219            case value_t::number_unsigned:
24220            case value_t::number_float:
24221            default:
24222                return "number";
24223        }
24224    }
24225
24226  JSON_PRIVATE_UNLESS_TESTED:
24227    //////////////////////
24228    // member variables //
24229    //////////////////////
24230
24231    struct data
24232    {
24233        /// the type of the current element
24234        value_t m_type = value_t::null;
24235
24236        /// the value of the current element
24237        json_value m_value = {};
24238
24239        data(const value_t v)
24240            : m_type(v), m_value(v)
24241        {
24242        }
24243
24244        data(size_type cnt, const basic_json& val)
24245            : m_type(value_t::array)
24246        {
24247            m_value.array = create<array_t>(cnt, val);
24248        }
24249
24250        data() noexcept = default;
24251        data(data&&) noexcept = default;
24252        data(const data&) noexcept = delete;
24253        data& operator=(data&&) noexcept = delete;
24254        data& operator=(const data&) noexcept = delete;
24255
24256        ~data() noexcept
24257        {
24258            m_value.destroy(m_type);
24259        }
24260    };
24261
24262    data m_data = {};
24263
24264#if JSON_DIAGNOSTICS
24265    /// a pointer to a parent value (for debugging purposes)
24266    basic_json* m_parent = nullptr;
24267#endif
24268
24269#if JSON_DIAGNOSTIC_POSITIONS
24270    /// the start position of the value
24271    std::size_t start_position = std::string::npos;
24272    /// the end position of the value
24273    std::size_t end_position = std::string::npos;
24274  public:
24275    constexpr std::size_t start_pos() const noexcept
24276    {
24277        return start_position;
24278    }
24279
24280    constexpr std::size_t end_pos() const noexcept
24281    {
24282        return end_position;
24283    }
24284#endif
24285
24286    //////////////////////////////////////////
24287    // binary serialization/deserialization //
24288    //////////////////////////////////////////
24289
24290    /// @name binary serialization/deserialization support
24291    /// @{
24292
24293  public:
24294    /// @brief create a CBOR serialization of a given JSON value
24295    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
24296    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
24297    {
24298        std::vector<std::uint8_t> result;
24299        to_cbor(j, result);
24300        return result;
24301    }
24302
24303    /// @brief create a CBOR serialization of a given JSON value
24304    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
24305    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
24306    {
24307        binary_writer<std::uint8_t>(o).write_cbor(j);
24308    }
24309
24310    /// @brief create a CBOR serialization of a given JSON value
24311    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
24312    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
24313    {
24314        binary_writer<char>(o).write_cbor(j);
24315    }
24316
24317    /// @brief create a MessagePack serialization of a given JSON value
24318    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
24319    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
24320    {
24321        std::vector<std::uint8_t> result;
24322        to_msgpack(j, result);
24323        return result;
24324    }
24325
24326    /// @brief create a MessagePack serialization of a given JSON value
24327    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
24328    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
24329    {
24330        binary_writer<std::uint8_t>(o).write_msgpack(j);
24331    }
24332
24333    /// @brief create a MessagePack serialization of a given JSON value
24334    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
24335    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
24336    {
24337        binary_writer<char>(o).write_msgpack(j);
24338    }
24339
24340    /// @brief create a UBJSON serialization of a given JSON value
24341    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
24342    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
24343            const bool use_size = false,
24344            const bool use_type = false)
24345    {
24346        std::vector<std::uint8_t> result;
24347        to_ubjson(j, result, use_size, use_type);
24348        return result;
24349    }
24350
24351    /// @brief create a UBJSON serialization of a given JSON value
24352    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
24353    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
24354                          const bool use_size = false, const bool use_type = false)
24355    {
24356        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
24357    }
24358
24359    /// @brief create a UBJSON serialization of a given JSON value
24360    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
24361    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
24362                          const bool use_size = false, const bool use_type = false)
24363    {
24364        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
24365    }
24366
24367    /// @brief create a BJData serialization of a given JSON value
24368    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
24369    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
24370            const bool use_size = false,
24371            const bool use_type = false,
24372            const bjdata_version_t version = bjdata_version_t::draft2)
24373    {
24374        std::vector<std::uint8_t> result;
24375        to_bjdata(j, result, use_size, use_type, version);
24376        return result;
24377    }
24378
24379    /// @brief create a BJData serialization of a given JSON value
24380    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
24381    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
24382                          const bool use_size = false, const bool use_type = false,
24383                          const bjdata_version_t version = bjdata_version_t::draft2)
24384    {
24385        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true, version);
24386    }
24387
24388    /// @brief create a BJData serialization of a given JSON value
24389    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
24390    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
24391                          const bool use_size = false, const bool use_type = false,
24392                          const bjdata_version_t version = bjdata_version_t::draft2)
24393    {
24394        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true, version);
24395    }
24396
24397    /// @brief create a BSON serialization of a given JSON value
24398    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
24399    static std::vector<std::uint8_t> to_bson(const basic_json& j)
24400    {
24401        std::vector<std::uint8_t> result;
24402        to_bson(j, result);
24403        return result;
24404    }
24405
24406    /// @brief create a BSON serialization of a given JSON value
24407    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
24408    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
24409    {
24410        binary_writer<std::uint8_t>(o).write_bson(j);
24411    }
24412
24413    /// @brief create a BSON serialization of a given JSON value
24414    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
24415    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
24416    {
24417        binary_writer<char>(o).write_bson(j);
24418    }
24419
24420    /// @brief create a JSON value from an input in CBOR format
24421    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
24422    template<typename InputType>
24423    JSON_HEDLEY_WARN_UNUSED_RESULT
24424    static basic_json from_cbor(InputType&& i,
24425                                const bool strict = true,
24426                                const bool allow_exceptions = true,
24427                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24428    {
24429        basic_json result;
24430        auto ia = detail::input_adapter(std::forward<InputType>(i));
24431        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24432        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
24433        return res ? result : basic_json(value_t::discarded);
24434    }
24435
24436    /// @brief create a JSON value from an input in CBOR format
24437    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
24438    template<typename IteratorType>
24439    JSON_HEDLEY_WARN_UNUSED_RESULT
24440    static basic_json from_cbor(IteratorType first, IteratorType last,
24441                                const bool strict = true,
24442                                const bool allow_exceptions = true,
24443                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24444    {
24445        basic_json result;
24446        auto ia = detail::input_adapter(std::move(first), std::move(last));
24447        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24448        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
24449        return res ? result : basic_json(value_t::discarded);
24450    }
24451
24452    template<typename T>
24453    JSON_HEDLEY_WARN_UNUSED_RESULT
24454    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
24455    static basic_json from_cbor(const T* ptr, std::size_t len,
24456                                const bool strict = true,
24457                                const bool allow_exceptions = true,
24458                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24459    {
24460        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
24461    }
24462
24463    JSON_HEDLEY_WARN_UNUSED_RESULT
24464    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
24465    static basic_json from_cbor(detail::span_input_adapter&& i,
24466                                const bool strict = true,
24467                                const bool allow_exceptions = true,
24468                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24469    {
24470        basic_json result;
24471        auto ia = i.get();
24472        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24473        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
24474        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
24475        return res ? result : basic_json(value_t::discarded);
24476    }
24477
24478    /// @brief create a JSON value from an input in MessagePack format
24479    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
24480    template<typename InputType>
24481    JSON_HEDLEY_WARN_UNUSED_RESULT
24482    static basic_json from_msgpack(InputType&& i,
24483                                   const bool strict = true,
24484                                   const bool allow_exceptions = true)
24485    {
24486        basic_json result;
24487        auto ia = detail::input_adapter(std::forward<InputType>(i));
24488        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24489        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
24490        return res ? result : basic_json(value_t::discarded);
24491    }
24492
24493    /// @brief create a JSON value from an input in MessagePack format
24494    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
24495    template<typename IteratorType>
24496    JSON_HEDLEY_WARN_UNUSED_RESULT
24497    static basic_json from_msgpack(IteratorType first, IteratorType last,
24498                                   const bool strict = true,
24499                                   const bool allow_exceptions = true)
24500    {
24501        basic_json result;
24502        auto ia = detail::input_adapter(std::move(first), std::move(last));
24503        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24504        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
24505        return res ? result : basic_json(value_t::discarded);
24506    }
24507
24508    template<typename T>
24509    JSON_HEDLEY_WARN_UNUSED_RESULT
24510    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
24511    static basic_json from_msgpack(const T* ptr, std::size_t len,
24512                                   const bool strict = true,
24513                                   const bool allow_exceptions = true)
24514    {
24515        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
24516    }
24517
24518    JSON_HEDLEY_WARN_UNUSED_RESULT
24519    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
24520    static basic_json from_msgpack(detail::span_input_adapter&& i,
24521                                   const bool strict = true,
24522                                   const bool allow_exceptions = true)
24523    {
24524        basic_json result;
24525        auto ia = i.get();
24526        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24527        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
24528        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
24529        return res ? result : basic_json(value_t::discarded);
24530    }
24531
24532    /// @brief create a JSON value from an input in UBJSON format
24533    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
24534    template<typename InputType>
24535    JSON_HEDLEY_WARN_UNUSED_RESULT
24536    static basic_json from_ubjson(InputType&& i,
24537                                  const bool strict = true,
24538                                  const bool allow_exceptions = true)
24539    {
24540        basic_json result;
24541        auto ia = detail::input_adapter(std::forward<InputType>(i));
24542        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24543        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
24544        return res ? result : basic_json(value_t::discarded);
24545    }
24546
24547    /// @brief create a JSON value from an input in UBJSON format
24548    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
24549    template<typename IteratorType>
24550    JSON_HEDLEY_WARN_UNUSED_RESULT
24551    static basic_json from_ubjson(IteratorType first, IteratorType last,
24552                                  const bool strict = true,
24553                                  const bool allow_exceptions = true)
24554    {
24555        basic_json result;
24556        auto ia = detail::input_adapter(std::move(first), std::move(last));
24557        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24558        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
24559        return res ? result : basic_json(value_t::discarded);
24560    }
24561
24562    template<typename T>
24563    JSON_HEDLEY_WARN_UNUSED_RESULT
24564    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
24565    static basic_json from_ubjson(const T* ptr, std::size_t len,
24566                                  const bool strict = true,
24567                                  const bool allow_exceptions = true)
24568    {
24569        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
24570    }
24571
24572    JSON_HEDLEY_WARN_UNUSED_RESULT
24573    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
24574    static basic_json from_ubjson(detail::span_input_adapter&& i,
24575                                  const bool strict = true,
24576                                  const bool allow_exceptions = true)
24577    {
24578        basic_json result;
24579        auto ia = i.get();
24580        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24581        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
24582        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
24583        return res ? result : basic_json(value_t::discarded);
24584    }
24585
24586    /// @brief create a JSON value from an input in BJData format
24587    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
24588    template<typename InputType>
24589    JSON_HEDLEY_WARN_UNUSED_RESULT
24590    static basic_json from_bjdata(InputType&& i,
24591                                  const bool strict = true,
24592                                  const bool allow_exceptions = true)
24593    {
24594        basic_json result;
24595        auto ia = detail::input_adapter(std::forward<InputType>(i));
24596        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24597        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
24598        return res ? result : basic_json(value_t::discarded);
24599    }
24600
24601    /// @brief create a JSON value from an input in BJData format
24602    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
24603    template<typename IteratorType>
24604    JSON_HEDLEY_WARN_UNUSED_RESULT
24605    static basic_json from_bjdata(IteratorType first, IteratorType last,
24606                                  const bool strict = true,
24607                                  const bool allow_exceptions = true)
24608    {
24609        basic_json result;
24610        auto ia = detail::input_adapter(std::move(first), std::move(last));
24611        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24612        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
24613        return res ? result : basic_json(value_t::discarded);
24614    }
24615
24616    /// @brief create a JSON value from an input in BSON format
24617    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
24618    template<typename InputType>
24619    JSON_HEDLEY_WARN_UNUSED_RESULT
24620    static basic_json from_bson(InputType&& i,
24621                                const bool strict = true,
24622                                const bool allow_exceptions = true)
24623    {
24624        basic_json result;
24625        auto ia = detail::input_adapter(std::forward<InputType>(i));
24626        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24627        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
24628        return res ? result : basic_json(value_t::discarded);
24629    }
24630
24631    /// @brief create a JSON value from an input in BSON format
24632    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
24633    template<typename IteratorType>
24634    JSON_HEDLEY_WARN_UNUSED_RESULT
24635    static basic_json from_bson(IteratorType first, IteratorType last,
24636                                const bool strict = true,
24637                                const bool allow_exceptions = true)
24638    {
24639        basic_json result;
24640        auto ia = detail::input_adapter(std::move(first), std::move(last));
24641        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24642        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
24643        return res ? result : basic_json(value_t::discarded);
24644    }
24645
24646    template<typename T>
24647    JSON_HEDLEY_WARN_UNUSED_RESULT
24648    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
24649    static basic_json from_bson(const T* ptr, std::size_t len,
24650                                const bool strict = true,
24651                                const bool allow_exceptions = true)
24652    {
24653        return from_bson(ptr, ptr + len, strict, allow_exceptions);
24654    }
24655
24656    JSON_HEDLEY_WARN_UNUSED_RESULT
24657    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
24658    static basic_json from_bson(detail::span_input_adapter&& i,
24659                                const bool strict = true,
24660                                const bool allow_exceptions = true)
24661    {
24662        basic_json result;
24663        auto ia = i.get();
24664        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
24665        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
24666        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
24667        return res ? result : basic_json(value_t::discarded);
24668    }
24669    /// @}
24670
24671    //////////////////////////
24672    // JSON Pointer support //
24673    //////////////////////////
24674
24675    /// @name JSON Pointer functions
24676    /// @{
24677
24678    /// @brief access specified element via JSON Pointer
24679    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
24680    reference operator[](const json_pointer& ptr)
24681    {
24682        return ptr.get_unchecked(this);
24683    }
24684
24685    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
24686    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
24687    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
24688    {
24689        return ptr.get_unchecked(this);
24690    }
24691
24692    /// @brief access specified element via JSON Pointer
24693    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
24694    const_reference operator[](const json_pointer& ptr) const
24695    {
24696        return ptr.get_unchecked(this);
24697    }
24698
24699    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
24700    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
24701    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
24702    {
24703        return ptr.get_unchecked(this);
24704    }
24705
24706    /// @brief access specified element via JSON Pointer
24707    /// @sa https://json.nlohmann.me/api/basic_json/at/
24708    reference at(const json_pointer& ptr)
24709    {
24710        return ptr.get_checked(this);
24711    }
24712
24713    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
24714    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
24715    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
24716    {
24717        return ptr.get_checked(this);
24718    }
24719
24720    /// @brief access specified element via JSON Pointer
24721    /// @sa https://json.nlohmann.me/api/basic_json/at/
24722    const_reference at(const json_pointer& ptr) const
24723    {
24724        return ptr.get_checked(this);
24725    }
24726
24727    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
24728    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
24729    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
24730    {
24731        return ptr.get_checked(this);
24732    }
24733
24734    /// @brief return flattened JSON value
24735    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
24736    basic_json flatten() const
24737    {
24738        basic_json result(value_t::object);
24739        json_pointer::flatten("", *this, result);
24740        return result;
24741    }
24742
24743    /// @brief unflatten a previously flattened JSON value
24744    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
24745    basic_json unflatten() const
24746    {
24747        return json_pointer::unflatten(*this);
24748    }
24749
24750    /// @}
24751
24752    //////////////////////////
24753    // JSON Patch functions //
24754    //////////////////////////
24755
24756    /// @name JSON Patch functions
24757    /// @{
24758
24759    /// @brief applies a JSON patch in-place without copying the object
24760    /// @sa https://json.nlohmann.me/api/basic_json/patch/
24761    void patch_inplace(const basic_json& json_patch)
24762    {
24763        basic_json& result = *this;
24764        // the valid JSON Patch operations
24765        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
24766
24767        const auto get_op = [](const string_t& op)
24768        {
24769            if (op == "add")
24770            {
24771                return patch_operations::add;
24772            }
24773            if (op == "remove")
24774            {
24775                return patch_operations::remove;
24776            }
24777            if (op == "replace")
24778            {
24779                return patch_operations::replace;
24780            }
24781            if (op == "move")
24782            {
24783                return patch_operations::move;
24784            }
24785            if (op == "copy")
24786            {
24787                return patch_operations::copy;
24788            }
24789            if (op == "test")
24790            {
24791                return patch_operations::test;
24792            }
24793
24794            return patch_operations::invalid;
24795        };
24796
24797        // wrapper for "add" operation; add value at ptr
24798        const auto operation_add = [&result](json_pointer & ptr, const basic_json & val)
24799        {
24800            // adding to the root of the target document means replacing it
24801            if (ptr.empty())
24802            {
24803                result = val;
24804                return;
24805            }
24806
24807            // make sure the top element of the pointer exists
24808            json_pointer const top_pointer = ptr.top();
24809            if (top_pointer != ptr)
24810            {
24811                result.at(top_pointer);
24812            }
24813
24814            // get reference to parent of JSON pointer ptr
24815            const auto last_path = ptr.back();
24816            ptr.pop_back();
24817            // parent must exist when performing patch add per RFC6902 specs
24818            basic_json& parent = result.at(ptr);
24819
24820            switch (parent.m_data.m_type)
24821            {
24822                case value_t::null:
24823                case value_t::object:
24824                {
24825                    // use operator[] to add value
24826                    parent[last_path] = val;
24827                    break;
24828                }
24829
24830                case value_t::array:
24831                {
24832                    if (last_path == "-")
24833                    {
24834                        // special case: append to back
24835                        parent.push_back(val);
24836                    }
24837                    else
24838                    {
24839                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
24840                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
24841                        {
24842                            // avoid undefined behavior
24843                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
24844                        }
24845
24846                        // default case: insert add offset
24847                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
24848                    }
24849                    break;
24850                }
24851
24852                // if there exists a parent it cannot be primitive
24853                case value_t::string: // LCOV_EXCL_LINE
24854                case value_t::boolean: // LCOV_EXCL_LINE
24855                case value_t::number_integer: // LCOV_EXCL_LINE
24856                case value_t::number_unsigned: // LCOV_EXCL_LINE
24857                case value_t::number_float: // LCOV_EXCL_LINE
24858                case value_t::binary: // LCOV_EXCL_LINE
24859                case value_t::discarded: // LCOV_EXCL_LINE
24860                default:            // LCOV_EXCL_LINE
24861                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
24862            }
24863        };
24864
24865        // wrapper for "remove" operation; remove value at ptr
24866        const auto operation_remove = [this, & result](json_pointer & ptr)
24867        {
24868            // get reference to parent of JSON pointer ptr
24869            const auto last_path = ptr.back();
24870            ptr.pop_back();
24871            basic_json& parent = result.at(ptr);
24872
24873            // remove child
24874            if (parent.is_object())
24875            {
24876                // perform range check
24877                auto it = parent.find(last_path);
24878                if (JSON_HEDLEY_LIKELY(it != parent.end()))
24879                {
24880                    parent.erase(it);
24881                }
24882                else
24883                {
24884                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
24885                }
24886            }
24887            else if (parent.is_array())
24888            {
24889                // note erase performs range check
24890                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
24891            }
24892        };
24893
24894        // type check: top level value must be an array
24895        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
24896        {
24897            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
24898        }
24899
24900        // iterate and apply the operations
24901        for (const auto& val : json_patch)
24902        {
24903            // wrapper to get a value for an operation
24904            const auto get_value = [&val](const string_t& op,
24905                                          const string_t& member,
24906                                          bool string_type) -> basic_json &
24907            {
24908                // find value
24909                auto it = val.m_data.m_value.object->find(member);
24910
24911                // context-sensitive error message
24912                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\''); // NOLINT(bugprone-unused-local-non-trivial-variable)
24913
24914                // check if desired value is present
24915                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
24916                {
24917                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
24918                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
24919                }
24920
24921                // check if result is of type string
24922                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
24923                {
24924                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
24925                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
24926                }
24927
24928                // no error: return value
24929                return it->second;
24930            };
24931
24932            // type check: every element of the array must be an object
24933            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
24934            {
24935                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
24936            }
24937
24938            // collect mandatory members
24939            const auto op = get_value("op", "op", true).template get<string_t>();
24940            const auto path = get_value(op, "path", true).template get<string_t>();
24941            json_pointer ptr(path);
24942
24943            switch (get_op(op))
24944            {
24945                case patch_operations::add:
24946                {
24947                    operation_add(ptr, get_value("add", "value", false));
24948                    break;
24949                }
24950
24951                case patch_operations::remove:
24952                {
24953                    operation_remove(ptr);
24954                    break;
24955                }
24956
24957                case patch_operations::replace:
24958                {
24959                    // the "path" location must exist - use at()
24960                    result.at(ptr) = get_value("replace", "value", false);
24961                    break;
24962                }
24963
24964                case patch_operations::move:
24965                {
24966                    const auto from_path = get_value("move", "from", true).template get<string_t>();
24967                    json_pointer from_ptr(from_path);
24968
24969                    // the "from" location must exist - use at()
24970                    basic_json const v = result.at(from_ptr);
24971
24972                    // The move operation is functionally identical to a
24973                    // "remove" operation on the "from" location, followed
24974                    // immediately by an "add" operation at the target
24975                    // location with the value that was just removed.
24976                    operation_remove(from_ptr);
24977                    operation_add(ptr, v);
24978                    break;
24979                }
24980
24981                case patch_operations::copy:
24982                {
24983                    const auto from_path = get_value("copy", "from", true).template get<string_t>();
24984                    const json_pointer from_ptr(from_path);
24985
24986                    // the "from" location must exist - use at()
24987                    basic_json const v = result.at(from_ptr);
24988
24989                    // The copy is functionally identical to an "add"
24990                    // operation at the target location using the value
24991                    // specified in the "from" member.
24992                    operation_add(ptr, v);
24993                    break;
24994                }
24995
24996                case patch_operations::test:
24997                {
24998                    bool success = false;
24999                    JSON_TRY
25000                    {
25001                        // check if "value" matches the one at "path"
25002                        // the "path" location must exist - use at()
25003                        success = (result.at(ptr) == get_value("test", "value", false));
25004                    }
25005                    JSON_INTERNAL_CATCH (out_of_range&)
25006                    {
25007                        // ignore out of range errors: success remains false
25008                    }
25009
25010                    // throw an exception if test fails
25011                    if (JSON_HEDLEY_UNLIKELY(!success))
25012                    {
25013                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
25014                    }
25015
25016                    break;
25017                }
25018
25019                case patch_operations::invalid:
25020                default:
25021                {
25022                    // op must be "add", "remove", "replace", "move", "copy", or
25023                    // "test"
25024                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
25025                }
25026            }
25027        }
25028    }
25029
25030    /// @brief applies a JSON patch to a copy of the current object
25031    /// @sa https://json.nlohmann.me/api/basic_json/patch/
25032    basic_json patch(const basic_json& json_patch) const
25033    {
25034        basic_json result = *this;
25035        result.patch_inplace(json_patch);
25036        return result;
25037    }
25038
25039    /// @brief creates a diff as a JSON patch
25040    /// @sa https://json.nlohmann.me/api/basic_json/diff/
25041    JSON_HEDLEY_WARN_UNUSED_RESULT
25042    static basic_json diff(const basic_json& source, const basic_json& target,
25043                           const string_t& path = "")
25044    {
25045        // the patch
25046        basic_json result(value_t::array);
25047
25048        // if the values are the same, return empty patch
25049        if (source == target)
25050        {
25051            return result;
25052        }
25053
25054        if (source.type() != target.type())
25055        {
25056            // different types: replace value
25057            result.push_back(
25058            {
25059                {"op", "replace"}, {"path", path}, {"value", target}
25060            });
25061            return result;
25062        }
25063
25064        switch (source.type())
25065        {
25066            case value_t::array:
25067            {
25068                // first pass: traverse common elements
25069                std::size_t i = 0;
25070                while (i < source.size() && i < target.size())
25071                {
25072                    // recursive call to compare array values at index i
25073                    auto temp_diff = diff(source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)));
25074                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
25075                    ++i;
25076                }
25077
25078                // We now reached the end of at least one array
25079                // in a second pass, traverse the remaining elements
25080
25081                // remove my remaining elements
25082                const auto end_index = static_cast<difference_type>(result.size());
25083                while (i < source.size())
25084                {
25085                    // add operations in reverse order to avoid invalid
25086                    // indices
25087                    result.insert(result.begin() + end_index, object(
25088                    {
25089                        {"op", "remove"},
25090                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(i))}
25091                    }));
25092                    ++i;
25093                }
25094
25095                // add other remaining elements
25096                while (i < target.size())
25097                {
25098                    result.push_back(
25099                    {
25100                        {"op", "add"},
25101                        {"path", detail::concat<string_t>(path, "/-")},
25102                        {"value", target[i]}
25103                    });
25104                    ++i;
25105                }
25106
25107                break;
25108            }
25109
25110            case value_t::object:
25111            {
25112                // first pass: traverse this object's elements
25113                for (auto it = source.cbegin(); it != source.cend(); ++it)
25114                {
25115                    // escape the key name to be used in a JSON patch
25116                    const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
25117
25118                    if (target.find(it.key()) != target.end())
25119                    {
25120                        // recursive call to compare object values at key it
25121                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
25122                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
25123                    }
25124                    else
25125                    {
25126                        // found a key that is not in o -> remove it
25127                        result.push_back(object(
25128                        {
25129                            {"op", "remove"}, {"path", path_key}
25130                        }));
25131                    }
25132                }
25133
25134                // second pass: traverse other object's elements
25135                for (auto it = target.cbegin(); it != target.cend(); ++it)
25136                {
25137                    if (source.find(it.key()) == source.end())
25138                    {
25139                        // found a key that is not in this -> add it
25140                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
25141                        result.push_back(
25142                        {
25143                            {"op", "add"}, {"path", path_key},
25144                            {"value", it.value()}
25145                        });
25146                    }
25147                }
25148
25149                break;
25150            }
25151
25152            case value_t::null:
25153            case value_t::string:
25154            case value_t::boolean:
25155            case value_t::number_integer:
25156            case value_t::number_unsigned:
25157            case value_t::number_float:
25158            case value_t::binary:
25159            case value_t::discarded:
25160            default:
25161            {
25162                // both primitive type: replace value
25163                result.push_back(
25164                {
25165                    {"op", "replace"}, {"path", path}, {"value", target}
25166                });
25167                break;
25168            }
25169        }
25170
25171        return result;
25172    }
25173    /// @}
25174
25175    ////////////////////////////////
25176    // JSON Merge Patch functions //
25177    ////////////////////////////////
25178
25179    /// @name JSON Merge Patch functions
25180    /// @{
25181
25182    /// @brief applies a JSON Merge Patch
25183    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
25184    void merge_patch(const basic_json& apply_patch)
25185    {
25186        if (apply_patch.is_object())
25187        {
25188            if (!is_object())
25189            {
25190                *this = object();
25191            }
25192            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
25193            {
25194                if (it.value().is_null())
25195                {
25196                    erase(it.key());
25197                }
25198                else
25199                {
25200                    operator[](it.key()).merge_patch(it.value());
25201                }
25202            }
25203        }
25204        else
25205        {
25206            *this = apply_patch;
25207        }
25208    }
25209
25210    /// @}
25211};
25212
25213/// @brief user-defined to_string function for JSON values
25214/// @sa https://json.nlohmann.me/api/basic_json/to_string/
25215NLOHMANN_BASIC_JSON_TPL_DECLARATION
25216std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
25217{
25218    return j.dump();
25219}
25220
25221inline namespace literals
25222{
25223inline namespace json_literals
25224{
25225
25226/// @brief user-defined string literal for JSON values
25227/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
25228JSON_HEDLEY_NON_NULL(1)
25229#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
25230    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
25231#else
25232    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
25233#endif
25234{
25235    return nlohmann::json::parse(s, s + n);
25236}
25237
25238/// @brief user-defined string literal for JSON pointer
25239/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
25240JSON_HEDLEY_NON_NULL(1)
25241#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
25242    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
25243#else
25244    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
25245#endif
25246{
25247    return nlohmann::json::json_pointer(std::string(s, n));
25248}
25249
25250}  // namespace json_literals
25251}  // namespace literals
25252NLOHMANN_JSON_NAMESPACE_END
25253
25254///////////////////////
25255// nonmember support //
25256///////////////////////
25257
25258namespace std // NOLINT(cert-dcl58-cpp)
25259{
25260
25261/// @brief hash value for JSON objects
25262/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
25263NLOHMANN_BASIC_JSON_TPL_DECLARATION
25264struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
25265{
25266    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
25267    {
25268        return nlohmann::detail::hash(j);
25269    }
25270};
25271
25272// specialization for std::less<value_t>
25273template<>
25274struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
25275{
25276    /*!
25277    @brief compare two value_t enum values
25278    @since version 3.0.0
25279    */
25280    bool operator()(::nlohmann::detail::value_t lhs,
25281                    ::nlohmann::detail::value_t rhs) const noexcept
25282    {
25283#if JSON_HAS_THREE_WAY_COMPARISON
25284        return std::is_lt(lhs <=> rhs); // *NOPAD*
25285#else
25286        return ::nlohmann::detail::operator<(lhs, rhs);
25287#endif
25288    }
25289};
25290
25291// C++20 prohibit function specialization in the std namespace.
25292#ifndef JSON_HAS_CPP_20
25293
25294/// @brief exchanges the values of two JSON objects
25295/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
25296NLOHMANN_BASIC_JSON_TPL_DECLARATION
25297inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
25298    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
25299    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
25300{
25301    j1.swap(j2);
25302}
25303
25304#endif
25305
25306}  // namespace std
25307
25308#if JSON_USE_GLOBAL_UDLS
25309    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
25310        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
25311        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
25312    #else
25313        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
25314        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
25315    #endif
25316#endif
25317
25318// #include <nlohmann/detail/macro_unscope.hpp>
25319//     __ _____ _____ _____
25320//  __|  |   __|     |   | |  JSON for Modern C++
25321// |  |  |__   |  |  | | | |  version 3.12.0
25322// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
25323//
25324// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
25325// SPDX-License-Identifier: MIT
25326
25327
25328
25329// restore clang diagnostic settings
25330#if defined(__clang__)
25331    #pragma clang diagnostic pop
25332#endif
25333
25334// clean up
25335#undef JSON_ASSERT
25336#undef JSON_INTERNAL_CATCH
25337#undef JSON_THROW
25338#undef JSON_PRIVATE_UNLESS_TESTED
25339#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
25340#undef NLOHMANN_BASIC_JSON_TPL
25341#undef JSON_EXPLICIT
25342#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
25343#undef JSON_INLINE_VARIABLE
25344#undef JSON_NO_UNIQUE_ADDRESS
25345#undef JSON_DISABLE_ENUM_SERIALIZATION
25346#undef JSON_USE_GLOBAL_UDLS
25347
25348#ifndef JSON_TEST_KEEP_MACROS
25349    #undef JSON_CATCH
25350    #undef JSON_TRY
25351    #undef JSON_HAS_CPP_11
25352    #undef JSON_HAS_CPP_14
25353    #undef JSON_HAS_CPP_17
25354    #undef JSON_HAS_CPP_20
25355    #undef JSON_HAS_CPP_23
25356    #undef JSON_HAS_FILESYSTEM
25357    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
25358    #undef JSON_HAS_THREE_WAY_COMPARISON
25359    #undef JSON_HAS_RANGES
25360    #undef JSON_HAS_STATIC_RTTI
25361    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
25362#endif
25363
25364// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
25365//     __ _____ _____ _____
25366//  __|  |   __|     |   | |  JSON for Modern C++
25367// |  |  |__   |  |  | | | |  version 3.12.0
25368// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
25369//
25370// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
25371// SPDX-License-Identifier: MIT
25372
25373
25374
25375#undef JSON_HEDLEY_ALWAYS_INLINE
25376#undef JSON_HEDLEY_ARM_VERSION
25377#undef JSON_HEDLEY_ARM_VERSION_CHECK
25378#undef JSON_HEDLEY_ARRAY_PARAM
25379#undef JSON_HEDLEY_ASSUME
25380#undef JSON_HEDLEY_BEGIN_C_DECLS
25381#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
25382#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
25383#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
25384#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
25385#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
25386#undef JSON_HEDLEY_CLANG_HAS_FEATURE
25387#undef JSON_HEDLEY_CLANG_HAS_WARNING
25388#undef JSON_HEDLEY_COMPCERT_VERSION
25389#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
25390#undef JSON_HEDLEY_CONCAT
25391#undef JSON_HEDLEY_CONCAT3
25392#undef JSON_HEDLEY_CONCAT3_EX
25393#undef JSON_HEDLEY_CONCAT_EX
25394#undef JSON_HEDLEY_CONST
25395#undef JSON_HEDLEY_CONSTEXPR
25396#undef JSON_HEDLEY_CONST_CAST
25397#undef JSON_HEDLEY_CPP_CAST
25398#undef JSON_HEDLEY_CRAY_VERSION
25399#undef JSON_HEDLEY_CRAY_VERSION_CHECK
25400#undef JSON_HEDLEY_C_DECL
25401#undef JSON_HEDLEY_DEPRECATED
25402#undef JSON_HEDLEY_DEPRECATED_FOR
25403#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
25404#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
25405#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
25406#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
25407#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
25408#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
25409#undef JSON_HEDLEY_DIAGNOSTIC_POP
25410#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
25411#undef JSON_HEDLEY_DMC_VERSION
25412#undef JSON_HEDLEY_DMC_VERSION_CHECK
25413#undef JSON_HEDLEY_EMPTY_BASES
25414#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
25415#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
25416#undef JSON_HEDLEY_END_C_DECLS
25417#undef JSON_HEDLEY_FLAGS
25418#undef JSON_HEDLEY_FLAGS_CAST
25419#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
25420#undef JSON_HEDLEY_GCC_HAS_BUILTIN
25421#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
25422#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
25423#undef JSON_HEDLEY_GCC_HAS_EXTENSION
25424#undef JSON_HEDLEY_GCC_HAS_FEATURE
25425#undef JSON_HEDLEY_GCC_HAS_WARNING
25426#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
25427#undef JSON_HEDLEY_GCC_VERSION
25428#undef JSON_HEDLEY_GCC_VERSION_CHECK
25429#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
25430#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
25431#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
25432#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
25433#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
25434#undef JSON_HEDLEY_GNUC_HAS_FEATURE
25435#undef JSON_HEDLEY_GNUC_HAS_WARNING
25436#undef JSON_HEDLEY_GNUC_VERSION
25437#undef JSON_HEDLEY_GNUC_VERSION_CHECK
25438#undef JSON_HEDLEY_HAS_ATTRIBUTE
25439#undef JSON_HEDLEY_HAS_BUILTIN
25440#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
25441#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
25442#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
25443#undef JSON_HEDLEY_HAS_EXTENSION
25444#undef JSON_HEDLEY_HAS_FEATURE
25445#undef JSON_HEDLEY_HAS_WARNING
25446#undef JSON_HEDLEY_IAR_VERSION
25447#undef JSON_HEDLEY_IAR_VERSION_CHECK
25448#undef JSON_HEDLEY_IBM_VERSION
25449#undef JSON_HEDLEY_IBM_VERSION_CHECK
25450#undef JSON_HEDLEY_IMPORT
25451#undef JSON_HEDLEY_INLINE
25452#undef JSON_HEDLEY_INTEL_CL_VERSION
25453#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
25454#undef JSON_HEDLEY_INTEL_VERSION
25455#undef JSON_HEDLEY_INTEL_VERSION_CHECK
25456#undef JSON_HEDLEY_IS_CONSTANT
25457#undef JSON_HEDLEY_IS_CONSTEXPR_
25458#undef JSON_HEDLEY_LIKELY
25459#undef JSON_HEDLEY_MALLOC
25460#undef JSON_HEDLEY_MCST_LCC_VERSION
25461#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
25462#undef JSON_HEDLEY_MESSAGE
25463#undef JSON_HEDLEY_MSVC_VERSION
25464#undef JSON_HEDLEY_MSVC_VERSION_CHECK
25465#undef JSON_HEDLEY_NEVER_INLINE
25466#undef JSON_HEDLEY_NON_NULL
25467#undef JSON_HEDLEY_NO_ESCAPE
25468#undef JSON_HEDLEY_NO_RETURN
25469#undef JSON_HEDLEY_NO_THROW
25470#undef JSON_HEDLEY_NULL
25471#undef JSON_HEDLEY_PELLES_VERSION
25472#undef JSON_HEDLEY_PELLES_VERSION_CHECK
25473#undef JSON_HEDLEY_PGI_VERSION
25474#undef JSON_HEDLEY_PGI_VERSION_CHECK
25475#undef JSON_HEDLEY_PREDICT
25476#undef JSON_HEDLEY_PRINTF_FORMAT
25477#undef JSON_HEDLEY_PRIVATE
25478#undef JSON_HEDLEY_PUBLIC
25479#undef JSON_HEDLEY_PURE
25480#undef JSON_HEDLEY_REINTERPRET_CAST
25481#undef JSON_HEDLEY_REQUIRE
25482#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
25483#undef JSON_HEDLEY_REQUIRE_MSG
25484#undef JSON_HEDLEY_RESTRICT
25485#undef JSON_HEDLEY_RETURNS_NON_NULL
25486#undef JSON_HEDLEY_SENTINEL
25487#undef JSON_HEDLEY_STATIC_ASSERT
25488#undef JSON_HEDLEY_STATIC_CAST
25489#undef JSON_HEDLEY_STRINGIFY
25490#undef JSON_HEDLEY_STRINGIFY_EX
25491#undef JSON_HEDLEY_SUNPRO_VERSION
25492#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
25493#undef JSON_HEDLEY_TINYC_VERSION
25494#undef JSON_HEDLEY_TINYC_VERSION_CHECK
25495#undef JSON_HEDLEY_TI_ARMCL_VERSION
25496#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
25497#undef JSON_HEDLEY_TI_CL2000_VERSION
25498#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
25499#undef JSON_HEDLEY_TI_CL430_VERSION
25500#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
25501#undef JSON_HEDLEY_TI_CL6X_VERSION
25502#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
25503#undef JSON_HEDLEY_TI_CL7X_VERSION
25504#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
25505#undef JSON_HEDLEY_TI_CLPRU_VERSION
25506#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
25507#undef JSON_HEDLEY_TI_VERSION
25508#undef JSON_HEDLEY_TI_VERSION_CHECK
25509#undef JSON_HEDLEY_UNAVAILABLE
25510#undef JSON_HEDLEY_UNLIKELY
25511#undef JSON_HEDLEY_UNPREDICTABLE
25512#undef JSON_HEDLEY_UNREACHABLE
25513#undef JSON_HEDLEY_UNREACHABLE_RETURN
25514#undef JSON_HEDLEY_VERSION
25515#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
25516#undef JSON_HEDLEY_VERSION_DECODE_MINOR
25517#undef JSON_HEDLEY_VERSION_DECODE_REVISION
25518#undef JSON_HEDLEY_VERSION_ENCODE
25519#undef JSON_HEDLEY_WARNING
25520#undef JSON_HEDLEY_WARN_UNUSED_RESULT
25521#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
25522#undef JSON_HEDLEY_FALL_THROUGH
25523
25524
25525
25526#endif  // INCLUDE_NLOHMANN_JSON_HPP_