Coverage Report

Created: 2024-02-11 06:05

/src/json/single_include/nlohmann/json.hpp
Line
Count
Source (jump to first uncovered line)
1
//     __ _____ _____ _____
2
//  __|  |   __|     |   | |  JSON for Modern C++
3
// |  |  |__   |  |  | | | |  version 3.11.3
4
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
5
//
6
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
7
// SPDX-License-Identifier: MIT
8
9
/****************************************************************************\
10
 * Note on documentation: The source files contain links to the online      *
11
 * documentation of the public API at https://json.nlohmann.me. This URL    *
12
 * contains the most recent documentation and should also be applicable to  *
13
 * previous versions; documentation for deprecated functions is not         *
14
 * removed, but marked deprecated. See "Generate documentation" section in  *
15
 * file docs/README.md.                                                     *
16
\****************************************************************************/
17
18
#ifndef INCLUDE_NLOHMANN_JSON_HPP_
19
#define INCLUDE_NLOHMANN_JSON_HPP_
20
21
#include <algorithm> // all_of, find, for_each
22
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
23
#include <functional> // hash, less
24
#include <initializer_list> // initializer_list
25
#ifndef JSON_NO_IO
26
    #include <iosfwd> // istream, ostream
27
#endif  // JSON_NO_IO
28
#include <iterator> // random_access_iterator_tag
29
#include <memory> // unique_ptr
30
#include <string> // string, stoi, to_string
31
#include <utility> // declval, forward, move, pair, swap
32
#include <vector> // vector
33
34
// #include <nlohmann/adl_serializer.hpp>
35
//     __ _____ _____ _____
36
//  __|  |   __|     |   | |  JSON for Modern C++
37
// |  |  |__   |  |  | | | |  version 3.11.3
38
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
39
//
40
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
41
// SPDX-License-Identifier: MIT
42
43
44
45
#include <utility>
46
47
// #include <nlohmann/detail/abi_macros.hpp>
48
//     __ _____ _____ _____
49
//  __|  |   __|     |   | |  JSON for Modern C++
50
// |  |  |__   |  |  | | | |  version 3.11.3
51
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
52
//
53
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
54
// SPDX-License-Identifier: MIT
55
56
57
58
// This file contains all macro definitions affecting or depending on the ABI
59
60
#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
61
    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
62
        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
63
            #warning "Already included a different version of the library!"
64
        #endif
65
    #endif
66
#endif
67
68
#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
69
#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
70
#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
71
72
#ifndef JSON_DIAGNOSTICS
73
    #define JSON_DIAGNOSTICS 0
74
#endif
75
76
#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
77
    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
78
#endif
79
80
#if JSON_DIAGNOSTICS
81
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
82
#else
83
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
84
#endif
85
86
#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
87
    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
88
#else
89
    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
90
#endif
91
92
#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
93
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
94
#endif
95
96
// Construct the namespace ABI tags component
97
#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
98
#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
99
    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
100
101
#define NLOHMANN_JSON_ABI_TAGS                                       \
102
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
103
            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
104
            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
105
106
// Construct the namespace version component
107
#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
108
    _v ## major ## _ ## minor ## _ ## patch
109
#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
110
    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
111
112
#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
113
#define NLOHMANN_JSON_NAMESPACE_VERSION
114
#else
115
#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
116
    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
117
                                           NLOHMANN_JSON_VERSION_MINOR, \
118
                                           NLOHMANN_JSON_VERSION_PATCH)
119
#endif
120
121
// Combine namespace components
122
#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
123
#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
124
    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
125
126
#ifndef NLOHMANN_JSON_NAMESPACE
127
#define NLOHMANN_JSON_NAMESPACE               \
128
    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
129
            NLOHMANN_JSON_ABI_TAGS,           \
130
            NLOHMANN_JSON_NAMESPACE_VERSION)
131
#endif
132
133
#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
134
#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
135
    namespace nlohmann                               \
136
    {                                                \
137
    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
138
                NLOHMANN_JSON_ABI_TAGS,              \
139
                NLOHMANN_JSON_NAMESPACE_VERSION)     \
140
    {
141
#endif
142
143
#ifndef NLOHMANN_JSON_NAMESPACE_END
144
#define NLOHMANN_JSON_NAMESPACE_END                                     \
145
    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
146
    }  // namespace nlohmann
147
#endif
148
149
// #include <nlohmann/detail/conversions/from_json.hpp>
150
//     __ _____ _____ _____
151
//  __|  |   __|     |   | |  JSON for Modern C++
152
// |  |  |__   |  |  | | | |  version 3.11.3
153
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
154
//
155
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
156
// SPDX-License-Identifier: MIT
157
158
159
160
#include <algorithm> // transform
161
#include <array> // array
162
#include <forward_list> // forward_list
163
#include <iterator> // inserter, front_inserter, end
164
#include <map> // map
165
#include <string> // string
166
#include <tuple> // tuple, make_tuple
167
#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
168
#include <unordered_map> // unordered_map
169
#include <utility> // pair, declval
170
#include <valarray> // valarray
171
172
// #include <nlohmann/detail/exceptions.hpp>
173
//     __ _____ _____ _____
174
//  __|  |   __|     |   | |  JSON for Modern C++
175
// |  |  |__   |  |  | | | |  version 3.11.3
176
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
177
//
178
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
179
// SPDX-License-Identifier: MIT
180
181
182
183
#include <cstddef> // nullptr_t
184
#include <exception> // exception
185
#if JSON_DIAGNOSTICS
186
    #include <numeric> // accumulate
187
#endif
188
#include <stdexcept> // runtime_error
189
#include <string> // to_string
190
#include <vector> // vector
191
192
// #include <nlohmann/detail/value_t.hpp>
193
//     __ _____ _____ _____
194
//  __|  |   __|     |   | |  JSON for Modern C++
195
// |  |  |__   |  |  | | | |  version 3.11.3
196
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
197
//
198
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
199
// SPDX-License-Identifier: MIT
200
201
202
203
#include <array> // array
204
#include <cstddef> // size_t
205
#include <cstdint> // uint8_t
206
#include <string> // string
207
208
// #include <nlohmann/detail/macro_scope.hpp>
209
//     __ _____ _____ _____
210
//  __|  |   __|     |   | |  JSON for Modern C++
211
// |  |  |__   |  |  | | | |  version 3.11.3
212
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
213
//
214
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
215
// SPDX-License-Identifier: MIT
216
217
218
219
#include <utility> // declval, pair
220
// #include <nlohmann/detail/meta/detected.hpp>
221
//     __ _____ _____ _____
222
//  __|  |   __|     |   | |  JSON for Modern C++
223
// |  |  |__   |  |  | | | |  version 3.11.3
224
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
225
//
226
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
227
// SPDX-License-Identifier: MIT
228
229
230
231
#include <type_traits>
232
233
// #include <nlohmann/detail/meta/void_t.hpp>
234
//     __ _____ _____ _____
235
//  __|  |   __|     |   | |  JSON for Modern C++
236
// |  |  |__   |  |  | | | |  version 3.11.3
237
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
238
//
239
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
240
// SPDX-License-Identifier: MIT
241
242
243
244
// #include <nlohmann/detail/abi_macros.hpp>
245
246
247
NLOHMANN_JSON_NAMESPACE_BEGIN
248
namespace detail
249
{
250
251
template<typename ...Ts> struct make_void
252
{
253
    using type = void;
254
};
255
template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
256
257
}  // namespace detail
258
NLOHMANN_JSON_NAMESPACE_END
259
260
261
NLOHMANN_JSON_NAMESPACE_BEGIN
262
namespace detail
263
{
264
265
// https://en.cppreference.com/w/cpp/experimental/is_detected
266
struct nonesuch
267
{
268
    nonesuch() = delete;
269
    ~nonesuch() = delete;
270
    nonesuch(nonesuch const&) = delete;
271
    nonesuch(nonesuch const&&) = delete;
272
    void operator=(nonesuch const&) = delete;
273
    void operator=(nonesuch&&) = delete;
274
};
275
276
template<class Default,
277
         class AlwaysVoid,
278
         template<class...> class Op,
279
         class... Args>
280
struct detector
281
{
282
    using value_t = std::false_type;
283
    using type = Default;
284
};
285
286
template<class Default, template<class...> class Op, class... Args>
287
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
288
{
289
    using value_t = std::true_type;
290
    using type = Op<Args...>;
291
};
292
293
template<template<class...> class Op, class... Args>
294
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
295
296
template<template<class...> class Op, class... Args>
297
struct is_detected_lazy : is_detected<Op, Args...> { };
298
299
template<template<class...> class Op, class... Args>
300
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
301
302
template<class Default, template<class...> class Op, class... Args>
303
using detected_or = detector<Default, void, Op, Args...>;
304
305
template<class Default, template<class...> class Op, class... Args>
306
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
307
308
template<class Expected, template<class...> class Op, class... Args>
309
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
310
311
template<class To, template<class...> class Op, class... Args>
312
using is_detected_convertible =
313
    std::is_convertible<detected_t<Op, Args...>, To>;
314
315
}  // namespace detail
316
NLOHMANN_JSON_NAMESPACE_END
317
318
// #include <nlohmann/thirdparty/hedley/hedley.hpp>
319
320
321
//     __ _____ _____ _____
322
//  __|  |   __|     |   | |  JSON for Modern C++
323
// |  |  |__   |  |  | | | |  version 3.11.3
324
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
325
//
326
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
327
// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
328
// SPDX-License-Identifier: MIT
329
330
/* Hedley - https://nemequ.github.io/hedley
331
 * Created by Evan Nemerson <evan@nemerson.com>
332
 */
333
334
#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
335
#if defined(JSON_HEDLEY_VERSION)
336
    #undef JSON_HEDLEY_VERSION
337
#endif
338
#define JSON_HEDLEY_VERSION 15
339
340
#if defined(JSON_HEDLEY_STRINGIFY_EX)
341
    #undef JSON_HEDLEY_STRINGIFY_EX
342
#endif
343
#define JSON_HEDLEY_STRINGIFY_EX(x) #x
344
345
#if defined(JSON_HEDLEY_STRINGIFY)
346
    #undef JSON_HEDLEY_STRINGIFY
347
#endif
348
#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
349
350
#if defined(JSON_HEDLEY_CONCAT_EX)
351
    #undef JSON_HEDLEY_CONCAT_EX
352
#endif
353
#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
354
355
#if defined(JSON_HEDLEY_CONCAT)
356
    #undef JSON_HEDLEY_CONCAT
357
#endif
358
#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
359
360
#if defined(JSON_HEDLEY_CONCAT3_EX)
361
    #undef JSON_HEDLEY_CONCAT3_EX
362
#endif
363
#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
364
365
#if defined(JSON_HEDLEY_CONCAT3)
366
    #undef JSON_HEDLEY_CONCAT3
367
#endif
368
#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
369
370
#if defined(JSON_HEDLEY_VERSION_ENCODE)
371
    #undef JSON_HEDLEY_VERSION_ENCODE
372
#endif
373
#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
374
375
#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
376
    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
377
#endif
378
#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
379
380
#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
381
    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
382
#endif
383
#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
384
385
#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
386
    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
387
#endif
388
#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
389
390
#if defined(JSON_HEDLEY_GNUC_VERSION)
391
    #undef JSON_HEDLEY_GNUC_VERSION
392
#endif
393
#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
394
    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
395
#elif defined(__GNUC__)
396
    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
397
#endif
398
399
#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
400
    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
401
#endif
402
#if defined(JSON_HEDLEY_GNUC_VERSION)
403
    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
404
#else
405
    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
406
#endif
407
408
#if defined(JSON_HEDLEY_MSVC_VERSION)
409
    #undef JSON_HEDLEY_MSVC_VERSION
410
#endif
411
#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
412
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
413
#elif defined(_MSC_FULL_VER) && !defined(__ICL)
414
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
415
#elif defined(_MSC_VER) && !defined(__ICL)
416
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
417
#endif
418
419
#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
420
    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
421
#endif
422
#if !defined(JSON_HEDLEY_MSVC_VERSION)
423
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
424
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
425
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
426
#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
427
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
428
#else
429
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
430
#endif
431
432
#if defined(JSON_HEDLEY_INTEL_VERSION)
433
    #undef JSON_HEDLEY_INTEL_VERSION
434
#endif
435
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
436
    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
437
#elif defined(__INTEL_COMPILER) && !defined(__ICL)
438
    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
439
#endif
440
441
#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
442
    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
443
#endif
444
#if defined(JSON_HEDLEY_INTEL_VERSION)
445
    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
446
#else
447
    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
448
#endif
449
450
#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
451
    #undef JSON_HEDLEY_INTEL_CL_VERSION
452
#endif
453
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
454
    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
455
#endif
456
457
#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
458
    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
459
#endif
460
#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
461
    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
462
#else
463
    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
464
#endif
465
466
#if defined(JSON_HEDLEY_PGI_VERSION)
467
    #undef JSON_HEDLEY_PGI_VERSION
468
#endif
469
#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
470
    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
471
#endif
472
473
#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
474
    #undef JSON_HEDLEY_PGI_VERSION_CHECK
475
#endif
476
#if defined(JSON_HEDLEY_PGI_VERSION)
477
    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
478
#else
479
    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
480
#endif
481
482
#if defined(JSON_HEDLEY_SUNPRO_VERSION)
483
    #undef JSON_HEDLEY_SUNPRO_VERSION
484
#endif
485
#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
486
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
487
#elif defined(__SUNPRO_C)
488
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
489
#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
490
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
491
#elif defined(__SUNPRO_CC)
492
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
493
#endif
494
495
#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
496
    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
497
#endif
498
#if defined(JSON_HEDLEY_SUNPRO_VERSION)
499
    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
500
#else
501
    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
502
#endif
503
504
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
505
    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
506
#endif
507
#if defined(__EMSCRIPTEN__)
508
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
509
#endif
510
511
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
512
    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
513
#endif
514
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
515
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
516
#else
517
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
518
#endif
519
520
#if defined(JSON_HEDLEY_ARM_VERSION)
521
    #undef JSON_HEDLEY_ARM_VERSION
522
#endif
523
#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
524
    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
525
#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
526
    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
527
#endif
528
529
#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
530
    #undef JSON_HEDLEY_ARM_VERSION_CHECK
531
#endif
532
#if defined(JSON_HEDLEY_ARM_VERSION)
533
    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
534
#else
535
    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
536
#endif
537
538
#if defined(JSON_HEDLEY_IBM_VERSION)
539
    #undef JSON_HEDLEY_IBM_VERSION
540
#endif
541
#if defined(__ibmxl__)
542
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
543
#elif defined(__xlC__) && defined(__xlC_ver__)
544
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
545
#elif defined(__xlC__)
546
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
547
#endif
548
549
#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
550
    #undef JSON_HEDLEY_IBM_VERSION_CHECK
551
#endif
552
#if defined(JSON_HEDLEY_IBM_VERSION)
553
    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
554
#else
555
    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
556
#endif
557
558
#if defined(JSON_HEDLEY_TI_VERSION)
559
    #undef JSON_HEDLEY_TI_VERSION
560
#endif
561
#if \
562
    defined(__TI_COMPILER_VERSION__) && \
563
    ( \
564
      defined(__TMS470__) || defined(__TI_ARM__) || \
565
      defined(__MSP430__) || \
566
      defined(__TMS320C2000__) \
567
    )
568
#if (__TI_COMPILER_VERSION__ >= 16000000)
569
    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
570
#endif
571
#endif
572
573
#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
574
    #undef JSON_HEDLEY_TI_VERSION_CHECK
575
#endif
576
#if defined(JSON_HEDLEY_TI_VERSION)
577
    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
578
#else
579
    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
580
#endif
581
582
#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
583
    #undef JSON_HEDLEY_TI_CL2000_VERSION
584
#endif
585
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
586
    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
587
#endif
588
589
#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
590
    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
591
#endif
592
#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
593
    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
594
#else
595
    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
596
#endif
597
598
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
599
    #undef JSON_HEDLEY_TI_CL430_VERSION
600
#endif
601
#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
602
    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
603
#endif
604
605
#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
606
    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
607
#endif
608
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
609
    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
610
#else
611
    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
612
#endif
613
614
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
615
    #undef JSON_HEDLEY_TI_ARMCL_VERSION
616
#endif
617
#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
618
    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
619
#endif
620
621
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
622
    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
623
#endif
624
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
625
    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
626
#else
627
    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
628
#endif
629
630
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
631
    #undef JSON_HEDLEY_TI_CL6X_VERSION
632
#endif
633
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
634
    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
635
#endif
636
637
#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
638
    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
639
#endif
640
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
641
    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
642
#else
643
    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
644
#endif
645
646
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
647
    #undef JSON_HEDLEY_TI_CL7X_VERSION
648
#endif
649
#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
650
    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
651
#endif
652
653
#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
654
    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
655
#endif
656
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
657
    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
658
#else
659
    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
660
#endif
661
662
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
663
    #undef JSON_HEDLEY_TI_CLPRU_VERSION
664
#endif
665
#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
666
    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
667
#endif
668
669
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
670
    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
671
#endif
672
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
673
    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
674
#else
675
    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
676
#endif
677
678
#if defined(JSON_HEDLEY_CRAY_VERSION)
679
    #undef JSON_HEDLEY_CRAY_VERSION
680
#endif
681
#if defined(_CRAYC)
682
    #if defined(_RELEASE_PATCHLEVEL)
683
        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
684
    #else
685
        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
686
    #endif
687
#endif
688
689
#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
690
    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
691
#endif
692
#if defined(JSON_HEDLEY_CRAY_VERSION)
693
    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
694
#else
695
    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
696
#endif
697
698
#if defined(JSON_HEDLEY_IAR_VERSION)
699
    #undef JSON_HEDLEY_IAR_VERSION
700
#endif
701
#if defined(__IAR_SYSTEMS_ICC__)
702
    #if __VER__ > 1000
703
        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
704
    #else
705
        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
706
    #endif
707
#endif
708
709
#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
710
    #undef JSON_HEDLEY_IAR_VERSION_CHECK
711
#endif
712
#if defined(JSON_HEDLEY_IAR_VERSION)
713
    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
714
#else
715
    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
716
#endif
717
718
#if defined(JSON_HEDLEY_TINYC_VERSION)
719
    #undef JSON_HEDLEY_TINYC_VERSION
720
#endif
721
#if defined(__TINYC__)
722
    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
723
#endif
724
725
#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
726
    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
727
#endif
728
#if defined(JSON_HEDLEY_TINYC_VERSION)
729
    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
730
#else
731
    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
732
#endif
733
734
#if defined(JSON_HEDLEY_DMC_VERSION)
735
    #undef JSON_HEDLEY_DMC_VERSION
736
#endif
737
#if defined(__DMC__)
738
    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
739
#endif
740
741
#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
742
    #undef JSON_HEDLEY_DMC_VERSION_CHECK
743
#endif
744
#if defined(JSON_HEDLEY_DMC_VERSION)
745
    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
746
#else
747
    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
748
#endif
749
750
#if defined(JSON_HEDLEY_COMPCERT_VERSION)
751
    #undef JSON_HEDLEY_COMPCERT_VERSION
752
#endif
753
#if defined(__COMPCERT_VERSION__)
754
    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
755
#endif
756
757
#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
758
    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
759
#endif
760
#if defined(JSON_HEDLEY_COMPCERT_VERSION)
761
    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
762
#else
763
    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
764
#endif
765
766
#if defined(JSON_HEDLEY_PELLES_VERSION)
767
    #undef JSON_HEDLEY_PELLES_VERSION
768
#endif
769
#if defined(__POCC__)
770
    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
771
#endif
772
773
#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
774
    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
775
#endif
776
#if defined(JSON_HEDLEY_PELLES_VERSION)
777
    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
778
#else
779
    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
780
#endif
781
782
#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
783
    #undef JSON_HEDLEY_MCST_LCC_VERSION
784
#endif
785
#if defined(__LCC__) && defined(__LCC_MINOR__)
786
    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
787
#endif
788
789
#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
790
    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
791
#endif
792
#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
793
    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
794
#else
795
    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
796
#endif
797
798
#if defined(JSON_HEDLEY_GCC_VERSION)
799
    #undef JSON_HEDLEY_GCC_VERSION
800
#endif
801
#if \
802
    defined(JSON_HEDLEY_GNUC_VERSION) && \
803
    !defined(__clang__) && \
804
    !defined(JSON_HEDLEY_INTEL_VERSION) && \
805
    !defined(JSON_HEDLEY_PGI_VERSION) && \
806
    !defined(JSON_HEDLEY_ARM_VERSION) && \
807
    !defined(JSON_HEDLEY_CRAY_VERSION) && \
808
    !defined(JSON_HEDLEY_TI_VERSION) && \
809
    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
810
    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
811
    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
812
    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
813
    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
814
    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
815
    !defined(__COMPCERT__) && \
816
    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
817
    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
818
#endif
819
820
#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
821
    #undef JSON_HEDLEY_GCC_VERSION_CHECK
822
#endif
823
#if defined(JSON_HEDLEY_GCC_VERSION)
824
    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
825
#else
826
    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
827
#endif
828
829
#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
830
    #undef JSON_HEDLEY_HAS_ATTRIBUTE
831
#endif
832
#if \
833
  defined(__has_attribute) && \
834
  ( \
835
    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
836
  )
837
#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
838
#else
839
#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
840
#endif
841
842
#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
843
    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
844
#endif
845
#if defined(__has_attribute)
846
    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
847
#else
848
    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
849
#endif
850
851
#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
852
    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
853
#endif
854
#if defined(__has_attribute)
855
    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
856
#else
857
    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
858
#endif
859
860
#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
861
    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
862
#endif
863
#if \
864
    defined(__has_cpp_attribute) && \
865
    defined(__cplusplus) && \
866
    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
867
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
868
#else
869
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
870
#endif
871
872
#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
873
    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
874
#endif
875
#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
876
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
877
#elif \
878
    !defined(JSON_HEDLEY_PGI_VERSION) && \
879
    !defined(JSON_HEDLEY_IAR_VERSION) && \
880
    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
881
    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
882
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
883
#else
884
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
885
#endif
886
887
#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
888
    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
889
#endif
890
#if defined(__has_cpp_attribute) && defined(__cplusplus)
891
    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
892
#else
893
    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
894
#endif
895
896
#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
897
    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
898
#endif
899
#if defined(__has_cpp_attribute) && defined(__cplusplus)
900
    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
901
#else
902
    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
903
#endif
904
905
#if defined(JSON_HEDLEY_HAS_BUILTIN)
906
    #undef JSON_HEDLEY_HAS_BUILTIN
907
#endif
908
#if defined(__has_builtin)
909
    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
910
#else
911
    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
912
#endif
913
914
#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
915
    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
916
#endif
917
#if defined(__has_builtin)
918
    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
919
#else
920
    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
921
#endif
922
923
#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
924
    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
925
#endif
926
#if defined(__has_builtin)
927
    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
928
#else
929
    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
930
#endif
931
932
#if defined(JSON_HEDLEY_HAS_FEATURE)
933
    #undef JSON_HEDLEY_HAS_FEATURE
934
#endif
935
#if defined(__has_feature)
936
    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
937
#else
938
    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
939
#endif
940
941
#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
942
    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
943
#endif
944
#if defined(__has_feature)
945
    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
946
#else
947
    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
948
#endif
949
950
#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
951
    #undef JSON_HEDLEY_GCC_HAS_FEATURE
952
#endif
953
#if defined(__has_feature)
954
    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
955
#else
956
    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
957
#endif
958
959
#if defined(JSON_HEDLEY_HAS_EXTENSION)
960
    #undef JSON_HEDLEY_HAS_EXTENSION
961
#endif
962
#if defined(__has_extension)
963
    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
964
#else
965
    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
966
#endif
967
968
#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
969
    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
970
#endif
971
#if defined(__has_extension)
972
    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
973
#else
974
    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
975
#endif
976
977
#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
978
    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
979
#endif
980
#if defined(__has_extension)
981
    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
982
#else
983
    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
984
#endif
985
986
#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
987
    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
988
#endif
989
#if defined(__has_declspec_attribute)
990
    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
991
#else
992
    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
993
#endif
994
995
#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
996
    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
997
#endif
998
#if defined(__has_declspec_attribute)
999
    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
1000
#else
1001
    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
1002
#endif
1003
1004
#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
1005
    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
1006
#endif
1007
#if defined(__has_declspec_attribute)
1008
    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
1009
#else
1010
    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1011
#endif
1012
1013
#if defined(JSON_HEDLEY_HAS_WARNING)
1014
    #undef JSON_HEDLEY_HAS_WARNING
1015
#endif
1016
#if defined(__has_warning)
1017
    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
1018
#else
1019
    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
1020
#endif
1021
1022
#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
1023
    #undef JSON_HEDLEY_GNUC_HAS_WARNING
1024
#endif
1025
#if defined(__has_warning)
1026
    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
1027
#else
1028
    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
1029
#endif
1030
1031
#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
1032
    #undef JSON_HEDLEY_GCC_HAS_WARNING
1033
#endif
1034
#if defined(__has_warning)
1035
    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
1036
#else
1037
    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1038
#endif
1039
1040
#if \
1041
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1042
    defined(__clang__) || \
1043
    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1044
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1045
    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1046
    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1047
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1048
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1049
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1050
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1051
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1052
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
1053
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1054
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1055
    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
1056
    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
1057
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
1058
    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
1059
    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
1060
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1061
    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
1062
#else
1063
    #define JSON_HEDLEY_PRAGMA(value)
1064
#endif
1065
1066
#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
1067
    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
1068
#endif
1069
#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
1070
    #undef JSON_HEDLEY_DIAGNOSTIC_POP
1071
#endif
1072
#if defined(__clang__)
1073
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
1074
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
1075
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1076
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
1077
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
1078
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1079
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
1080
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
1081
#elif \
1082
    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
1083
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1084
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
1085
    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
1086
#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
1087
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
1088
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
1089
#elif \
1090
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1091
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1092
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
1093
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1094
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1095
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1096
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
1097
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
1098
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1099
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
1100
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
1101
#else
1102
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
1103
    #define JSON_HEDLEY_DIAGNOSTIC_POP
1104
#endif
1105
1106
/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
1107
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
1108
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1109
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
1110
#endif
1111
#if defined(__cplusplus)
1112
#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
1113
#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
1114
#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
1115
#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1116
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1117
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1118
    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
1119
    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
1120
    xpr \
1121
    JSON_HEDLEY_DIAGNOSTIC_POP
1122
#      else
1123
#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1124
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1125
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1126
    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
1127
    xpr \
1128
    JSON_HEDLEY_DIAGNOSTIC_POP
1129
#      endif
1130
#    else
1131
#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
1132
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1133
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
1134
    xpr \
1135
    JSON_HEDLEY_DIAGNOSTIC_POP
1136
#    endif
1137
#  endif
1138
#endif
1139
#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1140
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
1141
#endif
1142
1143
#if defined(JSON_HEDLEY_CONST_CAST)
1144
    #undef JSON_HEDLEY_CONST_CAST
1145
#endif
1146
#if defined(__cplusplus)
1147
#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1148
#elif \
1149
  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1150
  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1151
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1152
#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1153
        JSON_HEDLEY_DIAGNOSTIC_PUSH \
1154
        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1155
        ((T) (expr)); \
1156
        JSON_HEDLEY_DIAGNOSTIC_POP \
1157
    }))
1158
#else
1159
#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1160
#endif
1161
1162
#if defined(JSON_HEDLEY_REINTERPRET_CAST)
1163
    #undef JSON_HEDLEY_REINTERPRET_CAST
1164
#endif
1165
#if defined(__cplusplus)
1166
    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1167
#else
1168
    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1169
#endif
1170
1171
#if defined(JSON_HEDLEY_STATIC_CAST)
1172
    #undef JSON_HEDLEY_STATIC_CAST
1173
#endif
1174
#if defined(__cplusplus)
1175
    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1176
#else
1177
    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1178
#endif
1179
1180
#if defined(JSON_HEDLEY_CPP_CAST)
1181
    #undef JSON_HEDLEY_CPP_CAST
1182
#endif
1183
#if defined(__cplusplus)
1184
#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1185
#    define JSON_HEDLEY_CPP_CAST(T, expr) \
1186
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1187
    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1188
    ((T) (expr)) \
1189
    JSON_HEDLEY_DIAGNOSTIC_POP
1190
#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1191
#    define JSON_HEDLEY_CPP_CAST(T, expr) \
1192
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1193
    _Pragma("diag_suppress=Pe137") \
1194
    JSON_HEDLEY_DIAGNOSTIC_POP
1195
#  else
1196
#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1197
#  endif
1198
#else
1199
#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1200
#endif
1201
1202
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1203
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1204
#endif
1205
#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1206
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1207
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1208
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1209
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1210
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1211
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1212
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1213
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1214
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1215
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1216
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1217
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1218
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1219
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1220
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1221
#elif \
1222
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1223
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1224
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1225
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1226
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1227
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1228
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1229
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1230
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1231
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1232
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1233
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1234
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1235
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1236
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1237
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1238
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1239
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1240
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1241
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1242
#else
1243
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1244
#endif
1245
1246
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1247
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1248
#endif
1249
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1250
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1251
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1252
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1253
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1254
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1255
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1256
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1257
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1258
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1259
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1260
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1261
#elif \
1262
    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1263
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1264
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1265
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1266
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1267
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1268
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1269
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1270
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1271
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1272
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1273
#else
1274
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1275
#endif
1276
1277
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1278
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1279
#endif
1280
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1281
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1282
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1283
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1284
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1285
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1286
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1287
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1288
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1289
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1290
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1291
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1292
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1293
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1294
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1295
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1296
#elif \
1297
    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1298
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1299
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1300
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1301
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1302
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1303
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1304
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1305
#else
1306
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1307
#endif
1308
1309
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1310
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1311
#endif
1312
#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1313
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1314
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1315
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1316
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1317
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1318
#else
1319
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1320
#endif
1321
1322
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1323
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1324
#endif
1325
#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1326
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1327
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1328
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1329
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1330
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1331
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1332
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1333
#else
1334
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1335
#endif
1336
1337
#if defined(JSON_HEDLEY_DEPRECATED)
1338
    #undef JSON_HEDLEY_DEPRECATED
1339
#endif
1340
#if defined(JSON_HEDLEY_DEPRECATED_FOR)
1341
    #undef JSON_HEDLEY_DEPRECATED_FOR
1342
#endif
1343
#if \
1344
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1345
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1346
    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1347
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1348
#elif \
1349
    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1350
    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1351
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1352
    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1353
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1354
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1355
    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1356
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1357
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1358
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1359
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1360
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1361
    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1362
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1363
#elif defined(__cplusplus) && (__cplusplus >= 201402L)
1364
    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1365
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1366
#elif \
1367
    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1368
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1369
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1370
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1371
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1372
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1373
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1374
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1375
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1376
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1377
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1378
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1379
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1380
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1381
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1382
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1383
    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1384
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1385
#elif \
1386
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1387
    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1388
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1389
    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1390
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1391
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1392
    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1393
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1394
#else
1395
    #define JSON_HEDLEY_DEPRECATED(since)
1396
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1397
#endif
1398
1399
#if defined(JSON_HEDLEY_UNAVAILABLE)
1400
    #undef JSON_HEDLEY_UNAVAILABLE
1401
#endif
1402
#if \
1403
    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1404
    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1405
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1406
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1407
    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1408
#else
1409
    #define JSON_HEDLEY_UNAVAILABLE(available_since)
1410
#endif
1411
1412
#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1413
    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1414
#endif
1415
#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1416
    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1417
#endif
1418
#if \
1419
    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1420
    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1421
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1422
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1423
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1424
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1425
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1426
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1427
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1428
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1429
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1430
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1431
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1432
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1433
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1434
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1435
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1436
    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1437
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1438
#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1439
    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1440
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1441
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1442
    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1443
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1444
#elif defined(_Check_return_) /* SAL */
1445
    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1446
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1447
#else
1448
    #define JSON_HEDLEY_WARN_UNUSED_RESULT
1449
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1450
#endif
1451
1452
#if defined(JSON_HEDLEY_SENTINEL)
1453
    #undef JSON_HEDLEY_SENTINEL
1454
#endif
1455
#if \
1456
    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1457
    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1458
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1459
    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1460
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1461
    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1462
#else
1463
    #define JSON_HEDLEY_SENTINEL(position)
1464
#endif
1465
1466
#if defined(JSON_HEDLEY_NO_RETURN)
1467
    #undef JSON_HEDLEY_NO_RETURN
1468
#endif
1469
#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1470
    #define JSON_HEDLEY_NO_RETURN __noreturn
1471
#elif \
1472
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1473
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1474
    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1475
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1476
    #define JSON_HEDLEY_NO_RETURN _Noreturn
1477
#elif defined(__cplusplus) && (__cplusplus >= 201103L)
1478
    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1479
#elif \
1480
    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1481
    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1482
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1483
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1484
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1485
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1486
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1487
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1488
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1489
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1490
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1491
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1492
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1493
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1494
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1495
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1496
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1497
    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1498
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1499
    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1500
#elif \
1501
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1502
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1503
    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1504
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1505
    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1506
#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1507
    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1508
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1509
    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1510
#else
1511
    #define JSON_HEDLEY_NO_RETURN
1512
#endif
1513
1514
#if defined(JSON_HEDLEY_NO_ESCAPE)
1515
    #undef JSON_HEDLEY_NO_ESCAPE
1516
#endif
1517
#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1518
    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1519
#else
1520
    #define JSON_HEDLEY_NO_ESCAPE
1521
#endif
1522
1523
#if defined(JSON_HEDLEY_UNREACHABLE)
1524
    #undef JSON_HEDLEY_UNREACHABLE
1525
#endif
1526
#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1527
    #undef JSON_HEDLEY_UNREACHABLE_RETURN
1528
#endif
1529
#if defined(JSON_HEDLEY_ASSUME)
1530
    #undef JSON_HEDLEY_ASSUME
1531
#endif
1532
#if \
1533
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1534
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1535
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1536
    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1537
#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1538
    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1539
#elif \
1540
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1541
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1542
    #if defined(__cplusplus)
1543
        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1544
    #else
1545
        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1546
    #endif
1547
#endif
1548
#if \
1549
    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1550
    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1551
    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1552
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1553
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1554
    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1555
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1556
    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1557
#elif defined(JSON_HEDLEY_ASSUME)
1558
    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1559
#endif
1560
#if !defined(JSON_HEDLEY_ASSUME)
1561
    #if defined(JSON_HEDLEY_UNREACHABLE)
1562
        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1563
    #else
1564
        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1565
    #endif
1566
#endif
1567
#if defined(JSON_HEDLEY_UNREACHABLE)
1568
    #if  \
1569
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1570
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1571
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1572
    #else
1573
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1574
    #endif
1575
#else
1576
    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1577
#endif
1578
#if !defined(JSON_HEDLEY_UNREACHABLE)
1579
    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1580
#endif
1581
1582
JSON_HEDLEY_DIAGNOSTIC_PUSH
1583
#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1584
    #pragma clang diagnostic ignored "-Wpedantic"
1585
#endif
1586
#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1587
    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1588
#endif
1589
#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1590
    #if defined(__clang__)
1591
        #pragma clang diagnostic ignored "-Wvariadic-macros"
1592
    #elif defined(JSON_HEDLEY_GCC_VERSION)
1593
        #pragma GCC diagnostic ignored "-Wvariadic-macros"
1594
    #endif
1595
#endif
1596
#if defined(JSON_HEDLEY_NON_NULL)
1597
    #undef JSON_HEDLEY_NON_NULL
1598
#endif
1599
#if \
1600
    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1601
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1602
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1603
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1604
    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1605
#else
1606
    #define JSON_HEDLEY_NON_NULL(...)
1607
#endif
1608
JSON_HEDLEY_DIAGNOSTIC_POP
1609
1610
#if defined(JSON_HEDLEY_PRINTF_FORMAT)
1611
    #undef JSON_HEDLEY_PRINTF_FORMAT
1612
#endif
1613
#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1614
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1615
#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1616
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1617
#elif \
1618
    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1619
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1620
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1621
    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1622
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1623
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1624
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1625
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1626
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1627
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1628
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1629
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1630
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1631
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1632
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1633
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1634
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1635
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1636
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1637
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1638
#else
1639
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1640
#endif
1641
1642
#if defined(JSON_HEDLEY_CONSTEXPR)
1643
    #undef JSON_HEDLEY_CONSTEXPR
1644
#endif
1645
#if defined(__cplusplus)
1646
    #if __cplusplus >= 201103L
1647
        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1648
    #endif
1649
#endif
1650
#if !defined(JSON_HEDLEY_CONSTEXPR)
1651
    #define JSON_HEDLEY_CONSTEXPR
1652
#endif
1653
1654
#if defined(JSON_HEDLEY_PREDICT)
1655
    #undef JSON_HEDLEY_PREDICT
1656
#endif
1657
#if defined(JSON_HEDLEY_LIKELY)
1658
    #undef JSON_HEDLEY_LIKELY
1659
#endif
1660
#if defined(JSON_HEDLEY_UNLIKELY)
1661
    #undef JSON_HEDLEY_UNLIKELY
1662
#endif
1663
#if defined(JSON_HEDLEY_UNPREDICTABLE)
1664
    #undef JSON_HEDLEY_UNPREDICTABLE
1665
#endif
1666
#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1667
    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1668
#endif
1669
#if \
1670
  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1671
  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1672
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1673
#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
1674
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
1675
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
1676
16.0M
#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
1677
51.3M
#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
1678
#elif \
1679
  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1680
  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1681
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1682
  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1683
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1684
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1685
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1686
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1687
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1688
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1689
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1690
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1691
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1692
  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1693
  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1694
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1695
#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1696
    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1697
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1698
    (__extension__ ({ \
1699
        double hedley_probability_ = (probability); \
1700
        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1701
    }))
1702
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1703
    (__extension__ ({ \
1704
        double hedley_probability_ = (probability); \
1705
        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1706
    }))
1707
#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
1708
#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1709
#else
1710
#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1711
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1712
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1713
#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1714
#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1715
#endif
1716
#if !defined(JSON_HEDLEY_UNPREDICTABLE)
1717
    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1718
#endif
1719
1720
#if defined(JSON_HEDLEY_MALLOC)
1721
    #undef JSON_HEDLEY_MALLOC
1722
#endif
1723
#if \
1724
    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1725
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1726
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1727
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1728
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1729
    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1730
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1731
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1732
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1733
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1734
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1735
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1736
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1737
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1738
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1739
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1740
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1741
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1742
    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1743
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1744
    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1745
#elif \
1746
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1747
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1748
    #define JSON_HEDLEY_MALLOC __declspec(restrict)
1749
#else
1750
    #define JSON_HEDLEY_MALLOC
1751
#endif
1752
1753
#if defined(JSON_HEDLEY_PURE)
1754
    #undef JSON_HEDLEY_PURE
1755
#endif
1756
#if \
1757
  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1758
  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1759
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1760
  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1761
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1762
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1763
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1764
  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1765
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1766
  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1767
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1768
  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1769
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1770
  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1771
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1772
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1773
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1774
  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1775
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1776
#  define JSON_HEDLEY_PURE __attribute__((__pure__))
1777
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1778
#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1779
#elif defined(__cplusplus) && \
1780
    ( \
1781
      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1782
      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1783
      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1784
    )
1785
#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1786
#else
1787
#  define JSON_HEDLEY_PURE
1788
#endif
1789
1790
#if defined(JSON_HEDLEY_CONST)
1791
    #undef JSON_HEDLEY_CONST
1792
#endif
1793
#if \
1794
    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1795
    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1796
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1797
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1798
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1799
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1800
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1801
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1802
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1803
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1804
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1805
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1806
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1807
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1808
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1809
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1810
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1811
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1812
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1813
    #define JSON_HEDLEY_CONST __attribute__((__const__))
1814
#elif \
1815
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1816
    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1817
#else
1818
    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1819
#endif
1820
1821
#if defined(JSON_HEDLEY_RESTRICT)
1822
    #undef JSON_HEDLEY_RESTRICT
1823
#endif
1824
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1825
    #define JSON_HEDLEY_RESTRICT restrict
1826
#elif \
1827
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1828
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1829
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1830
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1831
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1832
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1833
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1834
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1835
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1836
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1837
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1838
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1839
    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1840
    defined(__clang__) || \
1841
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1842
    #define JSON_HEDLEY_RESTRICT __restrict
1843
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1844
    #define JSON_HEDLEY_RESTRICT _Restrict
1845
#else
1846
    #define JSON_HEDLEY_RESTRICT
1847
#endif
1848
1849
#if defined(JSON_HEDLEY_INLINE)
1850
    #undef JSON_HEDLEY_INLINE
1851
#endif
1852
#if \
1853
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1854
    (defined(__cplusplus) && (__cplusplus >= 199711L))
1855
    #define JSON_HEDLEY_INLINE inline
1856
#elif \
1857
    defined(JSON_HEDLEY_GCC_VERSION) || \
1858
    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1859
    #define JSON_HEDLEY_INLINE __inline__
1860
#elif \
1861
    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1862
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1863
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1864
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1865
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1866
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1867
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1868
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1869
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1870
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1871
    #define JSON_HEDLEY_INLINE __inline
1872
#else
1873
    #define JSON_HEDLEY_INLINE
1874
#endif
1875
1876
#if defined(JSON_HEDLEY_ALWAYS_INLINE)
1877
    #undef JSON_HEDLEY_ALWAYS_INLINE
1878
#endif
1879
#if \
1880
  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1881
  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1882
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1883
  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1884
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1885
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1886
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1887
  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1888
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1889
  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1890
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1891
  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1892
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1893
  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1894
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1895
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1896
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1897
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1898
  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1899
#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1900
#elif \
1901
  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1902
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1903
#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1904
#elif defined(__cplusplus) && \
1905
    ( \
1906
      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1907
      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1908
      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1909
      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1910
      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1911
      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1912
    )
1913
#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1914
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1915
#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1916
#else
1917
#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1918
#endif
1919
1920
#if defined(JSON_HEDLEY_NEVER_INLINE)
1921
    #undef JSON_HEDLEY_NEVER_INLINE
1922
#endif
1923
#if \
1924
    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1925
    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1926
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1927
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1928
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1929
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1930
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1931
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1932
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1933
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1934
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1935
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1936
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1937
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1938
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1939
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1940
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1941
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1942
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1943
    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1944
#elif \
1945
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1946
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1947
    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1948
#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1949
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1950
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1951
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1952
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1953
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1954
#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1955
    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1956
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1957
    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1958
#else
1959
    #define JSON_HEDLEY_NEVER_INLINE
1960
#endif
1961
1962
#if defined(JSON_HEDLEY_PRIVATE)
1963
    #undef JSON_HEDLEY_PRIVATE
1964
#endif
1965
#if defined(JSON_HEDLEY_PUBLIC)
1966
    #undef JSON_HEDLEY_PUBLIC
1967
#endif
1968
#if defined(JSON_HEDLEY_IMPORT)
1969
    #undef JSON_HEDLEY_IMPORT
1970
#endif
1971
#if defined(_WIN32) || defined(__CYGWIN__)
1972
#  define JSON_HEDLEY_PRIVATE
1973
#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
1974
#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
1975
#else
1976
#  if \
1977
    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1978
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1979
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1980
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1981
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1982
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1983
    ( \
1984
      defined(__TI_EABI__) && \
1985
      ( \
1986
        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1987
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1988
      ) \
1989
    ) || \
1990
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1991
#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1992
#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
1993
#  else
1994
#    define JSON_HEDLEY_PRIVATE
1995
#    define JSON_HEDLEY_PUBLIC
1996
#  endif
1997
#  define JSON_HEDLEY_IMPORT    extern
1998
#endif
1999
2000
#if defined(JSON_HEDLEY_NO_THROW)
2001
    #undef JSON_HEDLEY_NO_THROW
2002
#endif
2003
#if \
2004
    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
2005
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
2006
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2007
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2008
    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
2009
#elif \
2010
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
2011
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
2012
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
2013
    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
2014
#else
2015
    #define JSON_HEDLEY_NO_THROW
2016
#endif
2017
2018
#if defined(JSON_HEDLEY_FALL_THROUGH)
2019
    #undef JSON_HEDLEY_FALL_THROUGH
2020
#endif
2021
#if \
2022
    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
2023
    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
2024
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2025
    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
2026
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
2027
    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
2028
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
2029
    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
2030
#elif defined(__fallthrough) /* SAL */
2031
    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
2032
#else
2033
    #define JSON_HEDLEY_FALL_THROUGH
2034
#endif
2035
2036
#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
2037
    #undef JSON_HEDLEY_RETURNS_NON_NULL
2038
#endif
2039
#if \
2040
    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
2041
    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
2042
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2043
    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
2044
#elif defined(_Ret_notnull_) /* SAL */
2045
    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
2046
#else
2047
    #define JSON_HEDLEY_RETURNS_NON_NULL
2048
#endif
2049
2050
#if defined(JSON_HEDLEY_ARRAY_PARAM)
2051
    #undef JSON_HEDLEY_ARRAY_PARAM
2052
#endif
2053
#if \
2054
    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
2055
    !defined(__STDC_NO_VLA__) && \
2056
    !defined(__cplusplus) && \
2057
    !defined(JSON_HEDLEY_PGI_VERSION) && \
2058
    !defined(JSON_HEDLEY_TINYC_VERSION)
2059
    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
2060
#else
2061
    #define JSON_HEDLEY_ARRAY_PARAM(name)
2062
#endif
2063
2064
#if defined(JSON_HEDLEY_IS_CONSTANT)
2065
    #undef JSON_HEDLEY_IS_CONSTANT
2066
#endif
2067
#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
2068
    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
2069
#endif
2070
/* JSON_HEDLEY_IS_CONSTEXPR_ is for
2071
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
2072
#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2073
    #undef JSON_HEDLEY_IS_CONSTEXPR_
2074
#endif
2075
#if \
2076
    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
2077
    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
2078
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2079
    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
2080
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
2081
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
2082
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
2083
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
2084
    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
2085
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
2086
    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
2087
#endif
2088
#if !defined(__cplusplus)
2089
#  if \
2090
       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
2091
       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
2092
       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2093
       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
2094
       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
2095
       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
2096
       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
2097
#if defined(__INTPTR_TYPE__)
2098
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
2099
#else
2100
    #include <stdint.h>
2101
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
2102
#endif
2103
#  elif \
2104
       ( \
2105
          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
2106
          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
2107
          !defined(JSON_HEDLEY_PGI_VERSION) && \
2108
          !defined(JSON_HEDLEY_IAR_VERSION)) || \
2109
       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
2110
       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
2111
       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
2112
       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
2113
       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
2114
#if defined(__INTPTR_TYPE__)
2115
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
2116
#else
2117
    #include <stdint.h>
2118
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
2119
#endif
2120
#  elif \
2121
       defined(JSON_HEDLEY_GCC_VERSION) || \
2122
       defined(JSON_HEDLEY_INTEL_VERSION) || \
2123
       defined(JSON_HEDLEY_TINYC_VERSION) || \
2124
       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
2125
       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
2126
       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
2127
       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
2128
       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
2129
       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
2130
       defined(__clang__)
2131
#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
2132
        sizeof(void) != \
2133
        sizeof(*( \
2134
                  1 ? \
2135
                  ((void*) ((expr) * 0L) ) : \
2136
((struct { char v[sizeof(void) * 2]; } *) 1) \
2137
                ) \
2138
              ) \
2139
                                            )
2140
#  endif
2141
#endif
2142
#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2143
    #if !defined(JSON_HEDLEY_IS_CONSTANT)
2144
        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
2145
    #endif
2146
    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2147
#else
2148
    #if !defined(JSON_HEDLEY_IS_CONSTANT)
2149
        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2150
    #endif
2151
    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2152
#endif
2153
2154
#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2155
    #undef JSON_HEDLEY_BEGIN_C_DECLS
2156
#endif
2157
#if defined(JSON_HEDLEY_END_C_DECLS)
2158
    #undef JSON_HEDLEY_END_C_DECLS
2159
#endif
2160
#if defined(JSON_HEDLEY_C_DECL)
2161
    #undef JSON_HEDLEY_C_DECL
2162
#endif
2163
#if defined(__cplusplus)
2164
    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2165
    #define JSON_HEDLEY_END_C_DECLS }
2166
    #define JSON_HEDLEY_C_DECL extern "C"
2167
#else
2168
    #define JSON_HEDLEY_BEGIN_C_DECLS
2169
    #define JSON_HEDLEY_END_C_DECLS
2170
    #define JSON_HEDLEY_C_DECL
2171
#endif
2172
2173
#if defined(JSON_HEDLEY_STATIC_ASSERT)
2174
    #undef JSON_HEDLEY_STATIC_ASSERT
2175
#endif
2176
#if \
2177
  !defined(__cplusplus) && ( \
2178
      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2179
      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2180
      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2181
      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2182
      defined(_Static_assert) \
2183
    )
2184
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2185
#elif \
2186
  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2187
  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2188
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2189
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2190
#else
2191
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2192
#endif
2193
2194
#if defined(JSON_HEDLEY_NULL)
2195
    #undef JSON_HEDLEY_NULL
2196
#endif
2197
#if defined(__cplusplus)
2198
    #if __cplusplus >= 201103L
2199
        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2200
    #elif defined(NULL)
2201
        #define JSON_HEDLEY_NULL NULL
2202
    #else
2203
        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2204
    #endif
2205
#elif defined(NULL)
2206
    #define JSON_HEDLEY_NULL NULL
2207
#else
2208
    #define JSON_HEDLEY_NULL ((void*) 0)
2209
#endif
2210
2211
#if defined(JSON_HEDLEY_MESSAGE)
2212
    #undef JSON_HEDLEY_MESSAGE
2213
#endif
2214
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2215
#  define JSON_HEDLEY_MESSAGE(msg) \
2216
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2217
    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2218
    JSON_HEDLEY_PRAGMA(message msg) \
2219
    JSON_HEDLEY_DIAGNOSTIC_POP
2220
#elif \
2221
  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2222
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2223
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2224
#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2225
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2226
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2227
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2228
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2229
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2230
#else
2231
#  define JSON_HEDLEY_MESSAGE(msg)
2232
#endif
2233
2234
#if defined(JSON_HEDLEY_WARNING)
2235
    #undef JSON_HEDLEY_WARNING
2236
#endif
2237
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2238
#  define JSON_HEDLEY_WARNING(msg) \
2239
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2240
    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2241
    JSON_HEDLEY_PRAGMA(clang warning msg) \
2242
    JSON_HEDLEY_DIAGNOSTIC_POP
2243
#elif \
2244
  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2245
  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2246
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2247
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2248
#elif \
2249
  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2250
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2251
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2252
#else
2253
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2254
#endif
2255
2256
#if defined(JSON_HEDLEY_REQUIRE)
2257
    #undef JSON_HEDLEY_REQUIRE
2258
#endif
2259
#if defined(JSON_HEDLEY_REQUIRE_MSG)
2260
    #undef JSON_HEDLEY_REQUIRE_MSG
2261
#endif
2262
#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2263
#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2264
#    define JSON_HEDLEY_REQUIRE(expr) \
2265
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2266
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2267
    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2268
    JSON_HEDLEY_DIAGNOSTIC_POP
2269
#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2270
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2271
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2272
    __attribute__((diagnose_if(!(expr), msg, "error"))) \
2273
    JSON_HEDLEY_DIAGNOSTIC_POP
2274
#  else
2275
#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2276
#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2277
#  endif
2278
#else
2279
#  define JSON_HEDLEY_REQUIRE(expr)
2280
#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2281
#endif
2282
2283
#if defined(JSON_HEDLEY_FLAGS)
2284
    #undef JSON_HEDLEY_FLAGS
2285
#endif
2286
#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2287
    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2288
#else
2289
    #define JSON_HEDLEY_FLAGS
2290
#endif
2291
2292
#if defined(JSON_HEDLEY_FLAGS_CAST)
2293
    #undef JSON_HEDLEY_FLAGS_CAST
2294
#endif
2295
#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2296
#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2297
        JSON_HEDLEY_DIAGNOSTIC_PUSH \
2298
        _Pragma("warning(disable:188)") \
2299
        ((T) (expr)); \
2300
        JSON_HEDLEY_DIAGNOSTIC_POP \
2301
    }))
2302
#else
2303
#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2304
#endif
2305
2306
#if defined(JSON_HEDLEY_EMPTY_BASES)
2307
    #undef JSON_HEDLEY_EMPTY_BASES
2308
#endif
2309
#if \
2310
    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2311
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2312
    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2313
#else
2314
    #define JSON_HEDLEY_EMPTY_BASES
2315
#endif
2316
2317
/* Remaining macros are deprecated. */
2318
2319
#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2320
    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2321
#endif
2322
#if defined(__clang__)
2323
    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2324
#else
2325
    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2326
#endif
2327
2328
#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2329
    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2330
#endif
2331
#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2332
2333
#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2334
    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2335
#endif
2336
#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2337
2338
#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2339
    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2340
#endif
2341
#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2342
2343
#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2344
    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2345
#endif
2346
#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2347
2348
#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2349
    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2350
#endif
2351
#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2352
2353
#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2354
    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2355
#endif
2356
#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2357
2358
#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2359
    #undef JSON_HEDLEY_CLANG_HAS_WARNING
2360
#endif
2361
#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2362
2363
#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2364
2365
2366
// This file contains all internal macro definitions (except those affecting ABI)
2367
// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2368
2369
// #include <nlohmann/detail/abi_macros.hpp>
2370
2371
2372
// exclude unsupported compilers
2373
#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2374
    #if defined(__clang__)
2375
        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2376
            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2377
        #endif
2378
    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2379
        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2380
            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2381
        #endif
2382
    #endif
2383
#endif
2384
2385
// C++ language standard detection
2386
// if the user manually specified the used c++ version this is skipped
2387
#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2388
    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2389
        #define JSON_HAS_CPP_20
2390
        #define JSON_HAS_CPP_17
2391
        #define JSON_HAS_CPP_14
2392
    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2393
        #define JSON_HAS_CPP_17
2394
        #define JSON_HAS_CPP_14
2395
    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2396
        #define JSON_HAS_CPP_14
2397
    #endif
2398
    // the cpp 11 flag is always specified because it is the minimal required version
2399
    #define JSON_HAS_CPP_11
2400
#endif
2401
2402
#ifdef __has_include
2403
    #if __has_include(<version>)
2404
        #include <version>
2405
    #endif
2406
#endif
2407
2408
#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
2409
    #ifdef JSON_HAS_CPP_17
2410
        #if defined(__cpp_lib_filesystem)
2411
            #define JSON_HAS_FILESYSTEM 1
2412
        #elif defined(__cpp_lib_experimental_filesystem)
2413
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2414
        #elif !defined(__has_include)
2415
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2416
        #elif __has_include(<filesystem>)
2417
            #define JSON_HAS_FILESYSTEM 1
2418
        #elif __has_include(<experimental/filesystem>)
2419
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2420
        #endif
2421
2422
        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
2423
        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
2424
            #undef JSON_HAS_FILESYSTEM
2425
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2426
        #endif
2427
2428
        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
2429
        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
2430
            #undef JSON_HAS_FILESYSTEM
2431
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2432
        #endif
2433
2434
        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
2435
        #if defined(__clang_major__) && __clang_major__ < 7
2436
            #undef JSON_HAS_FILESYSTEM
2437
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2438
        #endif
2439
2440
        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
2441
        #if defined(_MSC_VER) && _MSC_VER < 1914
2442
            #undef JSON_HAS_FILESYSTEM
2443
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2444
        #endif
2445
2446
        // no filesystem support before iOS 13
2447
        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
2448
            #undef JSON_HAS_FILESYSTEM
2449
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2450
        #endif
2451
2452
        // no filesystem support before macOS Catalina
2453
        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
2454
            #undef JSON_HAS_FILESYSTEM
2455
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2456
        #endif
2457
    #endif
2458
#endif
2459
2460
#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2461
    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
2462
#endif
2463
2464
#ifndef JSON_HAS_FILESYSTEM
2465
    #define JSON_HAS_FILESYSTEM 0
2466
#endif
2467
2468
#ifndef JSON_HAS_THREE_WAY_COMPARISON
2469
    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
2470
        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
2471
        #define JSON_HAS_THREE_WAY_COMPARISON 1
2472
    #else
2473
        #define JSON_HAS_THREE_WAY_COMPARISON 0
2474
    #endif
2475
#endif
2476
2477
#ifndef JSON_HAS_RANGES
2478
    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
2479
    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
2480
        #define JSON_HAS_RANGES 0
2481
    #elif defined(__cpp_lib_ranges)
2482
        #define JSON_HAS_RANGES 1
2483
    #else
2484
        #define JSON_HAS_RANGES 0
2485
    #endif
2486
#endif
2487
2488
#ifndef JSON_HAS_STATIC_RTTI
2489
    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
2490
        #define JSON_HAS_STATIC_RTTI 1
2491
    #else
2492
        #define JSON_HAS_STATIC_RTTI 0
2493
    #endif
2494
#endif
2495
2496
#ifdef JSON_HAS_CPP_17
2497
    #define JSON_INLINE_VARIABLE inline
2498
#else
2499
    #define JSON_INLINE_VARIABLE
2500
#endif
2501
2502
#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
2503
    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
2504
#else
2505
    #define JSON_NO_UNIQUE_ADDRESS
2506
#endif
2507
2508
// disable documentation warnings on clang
2509
#if defined(__clang__)
2510
    #pragma clang diagnostic push
2511
    #pragma clang diagnostic ignored "-Wdocumentation"
2512
    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2513
#endif
2514
2515
// allow disabling exceptions
2516
#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2517
15.1k
    #define JSON_THROW(exception) throw exception
2518
    #define JSON_TRY try
2519
    #define JSON_CATCH(exception) catch(exception)
2520
    #define JSON_INTERNAL_CATCH(exception) catch(exception)
2521
#else
2522
    #include <cstdlib>
2523
    #define JSON_THROW(exception) std::abort()
2524
    #define JSON_TRY if(true)
2525
    #define JSON_CATCH(exception) if(false)
2526
    #define JSON_INTERNAL_CATCH(exception) if(false)
2527
#endif
2528
2529
// override exception macros
2530
#if defined(JSON_THROW_USER)
2531
    #undef JSON_THROW
2532
    #define JSON_THROW JSON_THROW_USER
2533
#endif
2534
#if defined(JSON_TRY_USER)
2535
    #undef JSON_TRY
2536
    #define JSON_TRY JSON_TRY_USER
2537
#endif
2538
#if defined(JSON_CATCH_USER)
2539
    #undef JSON_CATCH
2540
    #define JSON_CATCH JSON_CATCH_USER
2541
    #undef JSON_INTERNAL_CATCH
2542
    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2543
#endif
2544
#if defined(JSON_INTERNAL_CATCH_USER)
2545
    #undef JSON_INTERNAL_CATCH
2546
    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2547
#endif
2548
2549
// allow overriding assert
2550
#if !defined(JSON_ASSERT)
2551
    #include <cassert> // assert
2552
0
    #define JSON_ASSERT(x) assert(x)
2553
#endif
2554
2555
// allow to access some private functions (needed by the test suite)
2556
#if defined(JSON_TESTS_PRIVATE)
2557
    #define JSON_PRIVATE_UNLESS_TESTED public
2558
#else
2559
    #define JSON_PRIVATE_UNLESS_TESTED private
2560
#endif
2561
2562
/*!
2563
@brief macro to briefly define a mapping between an enum and JSON
2564
@def NLOHMANN_JSON_SERIALIZE_ENUM
2565
@since version 3.4.0
2566
*/
2567
#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
2568
    template<typename BasicJsonType>                                                            \
2569
    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
2570
    {                                                                                           \
2571
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2572
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2573
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
2574
                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
2575
        {                                                                                       \
2576
            return ej_pair.first == e;                                                          \
2577
        });                                                                                     \
2578
        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
2579
    }                                                                                           \
2580
    template<typename BasicJsonType>                                                            \
2581
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
2582
    {                                                                                           \
2583
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2584
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2585
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
2586
                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2587
        {                                                                                       \
2588
            return ej_pair.second == j;                                                         \
2589
        });                                                                                     \
2590
        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
2591
    }
2592
2593
// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2594
// may be removed in the future once the class is split.
2595
2596
#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
2597
    template<template<typename, typename, typename...> class ObjectType,   \
2598
             template<typename, typename...> class ArrayType,              \
2599
             class StringType, class BooleanType, class NumberIntegerType, \
2600
             class NumberUnsignedType, class NumberFloatType,              \
2601
             template<typename> class AllocatorType,                       \
2602
             template<typename, typename = void> class JSONSerializer,     \
2603
             class BinaryType,                                             \
2604
             class CustomBaseClass>
2605
2606
#define NLOHMANN_BASIC_JSON_TPL                                            \
2607
    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
2608
    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
2609
    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
2610
2611
// Macros to simplify conversion from/to types
2612
2613
#define NLOHMANN_JSON_EXPAND( x ) x
2614
#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
2615
#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2616
        NLOHMANN_JSON_PASTE64, \
2617
        NLOHMANN_JSON_PASTE63, \
2618
        NLOHMANN_JSON_PASTE62, \
2619
        NLOHMANN_JSON_PASTE61, \
2620
        NLOHMANN_JSON_PASTE60, \
2621
        NLOHMANN_JSON_PASTE59, \
2622
        NLOHMANN_JSON_PASTE58, \
2623
        NLOHMANN_JSON_PASTE57, \
2624
        NLOHMANN_JSON_PASTE56, \
2625
        NLOHMANN_JSON_PASTE55, \
2626
        NLOHMANN_JSON_PASTE54, \
2627
        NLOHMANN_JSON_PASTE53, \
2628
        NLOHMANN_JSON_PASTE52, \
2629
        NLOHMANN_JSON_PASTE51, \
2630
        NLOHMANN_JSON_PASTE50, \
2631
        NLOHMANN_JSON_PASTE49, \
2632
        NLOHMANN_JSON_PASTE48, \
2633
        NLOHMANN_JSON_PASTE47, \
2634
        NLOHMANN_JSON_PASTE46, \
2635
        NLOHMANN_JSON_PASTE45, \
2636
        NLOHMANN_JSON_PASTE44, \
2637
        NLOHMANN_JSON_PASTE43, \
2638
        NLOHMANN_JSON_PASTE42, \
2639
        NLOHMANN_JSON_PASTE41, \
2640
        NLOHMANN_JSON_PASTE40, \
2641
        NLOHMANN_JSON_PASTE39, \
2642
        NLOHMANN_JSON_PASTE38, \
2643
        NLOHMANN_JSON_PASTE37, \
2644
        NLOHMANN_JSON_PASTE36, \
2645
        NLOHMANN_JSON_PASTE35, \
2646
        NLOHMANN_JSON_PASTE34, \
2647
        NLOHMANN_JSON_PASTE33, \
2648
        NLOHMANN_JSON_PASTE32, \
2649
        NLOHMANN_JSON_PASTE31, \
2650
        NLOHMANN_JSON_PASTE30, \
2651
        NLOHMANN_JSON_PASTE29, \
2652
        NLOHMANN_JSON_PASTE28, \
2653
        NLOHMANN_JSON_PASTE27, \
2654
        NLOHMANN_JSON_PASTE26, \
2655
        NLOHMANN_JSON_PASTE25, \
2656
        NLOHMANN_JSON_PASTE24, \
2657
        NLOHMANN_JSON_PASTE23, \
2658
        NLOHMANN_JSON_PASTE22, \
2659
        NLOHMANN_JSON_PASTE21, \
2660
        NLOHMANN_JSON_PASTE20, \
2661
        NLOHMANN_JSON_PASTE19, \
2662
        NLOHMANN_JSON_PASTE18, \
2663
        NLOHMANN_JSON_PASTE17, \
2664
        NLOHMANN_JSON_PASTE16, \
2665
        NLOHMANN_JSON_PASTE15, \
2666
        NLOHMANN_JSON_PASTE14, \
2667
        NLOHMANN_JSON_PASTE13, \
2668
        NLOHMANN_JSON_PASTE12, \
2669
        NLOHMANN_JSON_PASTE11, \
2670
        NLOHMANN_JSON_PASTE10, \
2671
        NLOHMANN_JSON_PASTE9, \
2672
        NLOHMANN_JSON_PASTE8, \
2673
        NLOHMANN_JSON_PASTE7, \
2674
        NLOHMANN_JSON_PASTE6, \
2675
        NLOHMANN_JSON_PASTE5, \
2676
        NLOHMANN_JSON_PASTE4, \
2677
        NLOHMANN_JSON_PASTE3, \
2678
        NLOHMANN_JSON_PASTE2, \
2679
        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2680
#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2681
#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2682
#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2683
#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2684
#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2685
#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
2686
#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
2687
#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
2688
#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
2689
#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
2690
#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
2691
#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
2692
#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
2693
#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
2694
#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
2695
#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
2696
#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
2697
#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
2698
#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
2699
#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
2700
#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
2701
#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
2702
#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
2703
#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
2704
#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
2705
#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
2706
#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
2707
#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
2708
#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
2709
#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
2710
#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
2711
#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
2712
#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
2713
#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
2714
#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
2715
#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
2716
#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
2717
#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
2718
#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
2719
#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
2720
#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
2721
#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
2722
#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
2723
#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
2724
#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
2725
#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
2726
#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
2727
#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
2728
#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
2729
#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
2730
#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
2731
#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
2732
#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
2733
#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
2734
#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
2735
#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
2736
#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
2737
#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
2738
#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
2739
#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
2740
#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
2741
#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
2742
#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
2743
2744
#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2745
#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2746
#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);
2747
2748
/*!
2749
@brief macro
2750
@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
2751
@since version 3.9.0
2752
*/
2753
#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
2754
    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2755
    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2756
2757
#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
2758
    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2759
    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2760
2761
#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
2762
    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2763
2764
/*!
2765
@brief macro
2766
@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
2767
@since version 3.9.0
2768
*/
2769
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
2770
    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2771
    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2772
2773
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
2774
    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
2775
2776
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
2777
    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2778
    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2779
2780
// inspired from https://stackoverflow.com/a/26745591
2781
// allows to call any std function as if (e.g. with begin):
2782
// using std::begin; begin(x);
2783
//
2784
// it allows using the detected idiom to retrieve the return type
2785
// of such an expression
2786
#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
2787
    namespace detail {                                                            \
2788
    using std::std_name;                                                          \
2789
    \
2790
    template<typename... T>                                                       \
2791
    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2792
    }                                                                             \
2793
    \
2794
    namespace detail2 {                                                           \
2795
    struct std_name##_tag                                                         \
2796
    {                                                                             \
2797
    };                                                                            \
2798
    \
2799
    template<typename... T>                                                       \
2800
    std_name##_tag std_name(T&&...);                                              \
2801
    \
2802
    template<typename... T>                                                       \
2803
    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2804
    \
2805
    template<typename... T>                                                       \
2806
    struct would_call_std_##std_name                                              \
2807
    {                                                                             \
2808
        static constexpr auto const value = ::nlohmann::detail::                  \
2809
                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
2810
    };                                                                            \
2811
    } /* namespace detail2 */ \
2812
    \
2813
    template<typename... T>                                                       \
2814
    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
2815
    {                                                                             \
2816
    }
2817
2818
#ifndef JSON_USE_IMPLICIT_CONVERSIONS
2819
    #define JSON_USE_IMPLICIT_CONVERSIONS 1
2820
#endif
2821
2822
#if JSON_USE_IMPLICIT_CONVERSIONS
2823
    #define JSON_EXPLICIT
2824
#else
2825
    #define JSON_EXPLICIT explicit
2826
#endif
2827
2828
#ifndef JSON_DISABLE_ENUM_SERIALIZATION
2829
    #define JSON_DISABLE_ENUM_SERIALIZATION 0
2830
#endif
2831
2832
#ifndef JSON_USE_GLOBAL_UDLS
2833
    #define JSON_USE_GLOBAL_UDLS 1
2834
#endif
2835
2836
#if JSON_HAS_THREE_WAY_COMPARISON
2837
    #include <compare> // partial_ordering
2838
#endif
2839
2840
NLOHMANN_JSON_NAMESPACE_BEGIN
2841
namespace detail
2842
{
2843
2844
///////////////////////////
2845
// JSON type enumeration //
2846
///////////////////////////
2847
2848
/*!
2849
@brief the JSON type enumeration
2850
2851
This enumeration collects the different JSON types. It is internally used to
2852
distinguish the stored values, and the functions @ref basic_json::is_null(),
2853
@ref basic_json::is_object(), @ref basic_json::is_array(),
2854
@ref basic_json::is_string(), @ref basic_json::is_boolean(),
2855
@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
2856
@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
2857
@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
2858
@ref basic_json::is_structured() rely on it.
2859
2860
@note There are three enumeration entries (number_integer, number_unsigned, and
2861
number_float), because the library distinguishes these three types for numbers:
2862
@ref basic_json::number_unsigned_t is used for unsigned integers,
2863
@ref basic_json::number_integer_t is used for signed integers, and
2864
@ref basic_json::number_float_t is used for floating-point numbers or to
2865
approximate integers which do not fit in the limits of their respective type.
2866
2867
@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
2868
value with the default value for a given type
2869
2870
@since version 1.0.0
2871
*/
2872
enum class value_t : std::uint8_t
2873
{
2874
    null,             ///< null value
2875
    object,           ///< object (unordered set of name/value pairs)
2876
    array,            ///< array (ordered collection of values)
2877
    string,           ///< string value
2878
    boolean,          ///< boolean value
2879
    number_integer,   ///< number value (signed integer)
2880
    number_unsigned,  ///< number value (unsigned integer)
2881
    number_float,     ///< number value (floating-point)
2882
    binary,           ///< binary array (ordered collection of bytes)
2883
    discarded         ///< discarded by the parser callback function
2884
};
2885
2886
/*!
2887
@brief comparison operator for JSON types
2888
2889
Returns an ordering that is similar to Python:
2890
- order: null < boolean < number < object < array < string < binary
2891
- furthermore, each type is not smaller than itself
2892
- discarded values are not comparable
2893
- binary is represented as a b"" string in python and directly comparable to a
2894
  string; however, making a binary array directly comparable with a string would
2895
  be surprising behavior in a JSON file.
2896
2897
@since version 1.0.0
2898
*/
2899
#if JSON_HAS_THREE_WAY_COMPARISON
2900
    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
2901
#else
2902
    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2903
#endif
2904
0
{
2905
0
    static constexpr std::array<std::uint8_t, 9> order = {{
2906
0
            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
2907
0
            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
2908
0
            6 /* binary */
2909
0
        }
2910
0
    };
2911
0
2912
0
    const auto l_index = static_cast<std::size_t>(lhs);
2913
0
    const auto r_index = static_cast<std::size_t>(rhs);
2914
0
#if JSON_HAS_THREE_WAY_COMPARISON
2915
0
    if (l_index < order.size() && r_index < order.size())
2916
0
    {
2917
0
        return order[l_index] <=> order[r_index]; // *NOPAD*
2918
0
    }
2919
0
    return std::partial_ordering::unordered;
2920
0
#else
2921
0
    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
2922
0
#endif
2923
0
}
2924
2925
// GCC selects the built-in operator< over an operator rewritten from
2926
// a user-defined spaceship operator
2927
// Clang, MSVC, and ICC select the rewritten candidate
2928
// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
2929
#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
2930
inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2931
{
2932
    return std::is_lt(lhs <=> rhs); // *NOPAD*
2933
}
2934
#endif
2935
2936
}  // namespace detail
2937
NLOHMANN_JSON_NAMESPACE_END
2938
2939
// #include <nlohmann/detail/string_escape.hpp>
2940
//     __ _____ _____ _____
2941
//  __|  |   __|     |   | |  JSON for Modern C++
2942
// |  |  |__   |  |  | | | |  version 3.11.3
2943
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
2944
//
2945
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
2946
// SPDX-License-Identifier: MIT
2947
2948
2949
2950
// #include <nlohmann/detail/abi_macros.hpp>
2951
2952
2953
NLOHMANN_JSON_NAMESPACE_BEGIN
2954
namespace detail
2955
{
2956
2957
/*!
2958
@brief replace all occurrences of a substring by another string
2959
2960
@param[in,out] s  the string to manipulate; changed so that all
2961
               occurrences of @a f are replaced with @a t
2962
@param[in]     f  the substring to replace with @a t
2963
@param[in]     t  the string to replace @a f
2964
2965
@pre The search string @a f must not be empty. **This precondition is
2966
enforced with an assertion.**
2967
2968
@since version 2.0.0
2969
*/
2970
template<typename StringType>
2971
inline void replace_substring(StringType& s, const StringType& f,
2972
                              const StringType& t)
2973
0
{
2974
0
    JSON_ASSERT(!f.empty());
2975
0
    for (auto pos = s.find(f);                // find first occurrence of f
2976
0
            pos != StringType::npos;          // make sure f was found
2977
0
            s.replace(pos, f.size(), t),      // replace with t, and
2978
0
            pos = s.find(f, pos + t.size()))  // find next occurrence of f
2979
0
    {}
2980
0
}
2981
2982
/*!
2983
 * @brief string escaping as described in RFC 6901 (Sect. 4)
2984
 * @param[in] s string to escape
2985
 * @return    escaped string
2986
 *
2987
 * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
2988
 */
2989
template<typename StringType>
2990
inline StringType escape(StringType s)
2991
{
2992
    replace_substring(s, StringType{"~"}, StringType{"~0"});
2993
    replace_substring(s, StringType{"/"}, StringType{"~1"});
2994
    return s;
2995
}
2996
2997
/*!
2998
 * @brief string unescaping as described in RFC 6901 (Sect. 4)
2999
 * @param[in] s string to unescape
3000
 * @return    unescaped string
3001
 *
3002
 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
3003
 */
3004
template<typename StringType>
3005
static void unescape(StringType& s)
3006
0
{
3007
0
    replace_substring(s, StringType{"~1"}, StringType{"/"});
3008
0
    replace_substring(s, StringType{"~0"}, StringType{"~"});
3009
0
}
Unexecuted instantiation: fuzzer-parse_bjdata.cpp:void nlohmann::json_abi_v3_11_3::detail::unescape<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Unexecuted instantiation: fuzzer-parse_bson.cpp:void nlohmann::json_abi_v3_11_3::detail::unescape<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Unexecuted instantiation: fuzzer-parse_ubjson.cpp:void nlohmann::json_abi_v3_11_3::detail::unescape<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Unexecuted instantiation: fuzzer-parse_json.cpp:void nlohmann::json_abi_v3_11_3::detail::unescape<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Unexecuted instantiation: fuzzer-parse_cbor.cpp:void nlohmann::json_abi_v3_11_3::detail::unescape<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Unexecuted instantiation: fuzzer-parse_msgpack.cpp:void nlohmann::json_abi_v3_11_3::detail::unescape<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
3010
3011
}  // namespace detail
3012
NLOHMANN_JSON_NAMESPACE_END
3013
3014
// #include <nlohmann/detail/input/position_t.hpp>
3015
//     __ _____ _____ _____
3016
//  __|  |   __|     |   | |  JSON for Modern C++
3017
// |  |  |__   |  |  | | | |  version 3.11.3
3018
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3019
//
3020
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3021
// SPDX-License-Identifier: MIT
3022
3023
3024
3025
#include <cstddef> // size_t
3026
3027
// #include <nlohmann/detail/abi_macros.hpp>
3028
3029
3030
NLOHMANN_JSON_NAMESPACE_BEGIN
3031
namespace detail
3032
{
3033
3034
/// struct to capture the start position of the current token
3035
struct position_t
3036
{
3037
    /// the total number of characters read
3038
    std::size_t chars_read_total = 0;
3039
    /// the number of characters read in the current line
3040
    std::size_t chars_read_current_line = 0;
3041
    /// the number of lines read
3042
    std::size_t lines_read = 0;
3043
3044
    /// conversion to size_t to preserve SAX interface
3045
    constexpr operator size_t() const
3046
2.77k
    {
3047
2.77k
        return chars_read_total;
3048
2.77k
    }
3049
};
3050
3051
}  // namespace detail
3052
NLOHMANN_JSON_NAMESPACE_END
3053
3054
// #include <nlohmann/detail/macro_scope.hpp>
3055
3056
// #include <nlohmann/detail/meta/cpp_future.hpp>
3057
//     __ _____ _____ _____
3058
//  __|  |   __|     |   | |  JSON for Modern C++
3059
// |  |  |__   |  |  | | | |  version 3.11.3
3060
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3061
//
3062
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3063
// SPDX-FileCopyrightText: 2018 The Abseil Authors
3064
// SPDX-License-Identifier: MIT
3065
3066
3067
3068
#include <array> // array
3069
#include <cstddef> // size_t
3070
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
3071
#include <utility> // index_sequence, make_index_sequence, index_sequence_for
3072
3073
// #include <nlohmann/detail/macro_scope.hpp>
3074
3075
3076
NLOHMANN_JSON_NAMESPACE_BEGIN
3077
namespace detail
3078
{
3079
3080
template<typename T>
3081
using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3082
3083
#ifdef JSON_HAS_CPP_14
3084
3085
// the following utilities are natively available in C++14
3086
using std::enable_if_t;
3087
using std::index_sequence;
3088
using std::make_index_sequence;
3089
using std::index_sequence_for;
3090
3091
#else
3092
3093
// alias templates to reduce boilerplate
3094
template<bool B, typename T = void>
3095
using enable_if_t = typename std::enable_if<B, T>::type;
3096
3097
// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
3098
// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
3099
3100
//// START OF CODE FROM GOOGLE ABSEIL
3101
3102
// integer_sequence
3103
//
3104
// Class template representing a compile-time integer sequence. An instantiation
3105
// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
3106
// type through its template arguments (which is a common need when
3107
// working with C++11 variadic templates). `absl::integer_sequence` is designed
3108
// to be a drop-in replacement for C++14's `std::integer_sequence`.
3109
//
3110
// Example:
3111
//
3112
//   template< class T, T... Ints >
3113
//   void user_function(integer_sequence<T, Ints...>);
3114
//
3115
//   int main()
3116
//   {
3117
//     // user_function's `T` will be deduced to `int` and `Ints...`
3118
//     // will be deduced to `0, 1, 2, 3, 4`.
3119
//     user_function(make_integer_sequence<int, 5>());
3120
//   }
3121
template <typename T, T... Ints>
3122
struct integer_sequence
3123
{
3124
    using value_type = T;
3125
    static constexpr std::size_t size() noexcept
3126
    {
3127
        return sizeof...(Ints);
3128
    }
3129
};
3130
3131
// index_sequence
3132
//
3133
// A helper template for an `integer_sequence` of `size_t`,
3134
// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
3135
// `std::index_sequence`.
3136
template <size_t... Ints>
3137
using index_sequence = integer_sequence<size_t, Ints...>;
3138
3139
namespace utility_internal
3140
{
3141
3142
template <typename Seq, size_t SeqSize, size_t Rem>
3143
struct Extend;
3144
3145
// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
3146
template <typename T, T... Ints, size_t SeqSize>
3147
struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3148
{
3149
    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3150
};
3151
3152
template <typename T, T... Ints, size_t SeqSize>
3153
struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3154
{
3155
    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3156
};
3157
3158
// Recursion helper for 'make_integer_sequence<T, N>'.
3159
// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
3160
template <typename T, size_t N>
3161
struct Gen
3162
{
3163
    using type =
3164
        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3165
};
3166
3167
template <typename T>
3168
struct Gen<T, 0>
3169
{
3170
    using type = integer_sequence<T>;
3171
};
3172
3173
}  // namespace utility_internal
3174
3175
// Compile-time sequences of integers
3176
3177
// make_integer_sequence
3178
//
3179
// This template alias is equivalent to
3180
// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
3181
// replacement for C++14's `std::make_integer_sequence`.
3182
template <typename T, T N>
3183
using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
3184
3185
// make_index_sequence
3186
//
3187
// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
3188
// and is designed to be a drop-in replacement for C++14's
3189
// `std::make_index_sequence`.
3190
template <size_t N>
3191
using make_index_sequence = make_integer_sequence<size_t, N>;
3192
3193
// index_sequence_for
3194
//
3195
// Converts a typename pack into an index sequence of the same length, and
3196
// is designed to be a drop-in replacement for C++14's
3197
// `std::index_sequence_for()`
3198
template <typename... Ts>
3199
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
3200
3201
//// END OF CODE FROM GOOGLE ABSEIL
3202
3203
#endif
3204
3205
// dispatch utility (taken from ranges-v3)
3206
template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
3207
template<> struct priority_tag<0> {};
3208
3209
// taken from ranges-v3
3210
template<typename T>
3211
struct static_const
3212
{
3213
    static JSON_INLINE_VARIABLE constexpr T value{};
3214
};
3215
3216
#ifndef JSON_HAS_CPP_17
3217
    template<typename T>
3218
    constexpr T static_const<T>::value;
3219
#endif
3220
3221
template<typename T, typename... Args>
3222
inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
3223
80.7k
{
3224
80.7k
    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
3225
80.7k
}
std::__1::array<unsigned long, 8> nlohmann::json_abi_v3_11_3::detail::make_array<unsigned long, char, char, char, char, char, char, char, char>(char&&, char&&, char&&, char&&, char&&, char&&, char&&, char&&)
Line
Count
Source
3223
40.3k
{
3224
40.3k
    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
3225
40.3k
}
std::__1::array<std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, 11> nlohmann::json_abi_v3_11_3::detail::make_array<std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >(std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&, std::__1::pair<unsigned long, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >&&)
Line
Count
Source
3223
40.3k
{
3224
40.3k
    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
3225
40.3k
}
3226
3227
}  // namespace detail
3228
NLOHMANN_JSON_NAMESPACE_END
3229
3230
// #include <nlohmann/detail/meta/type_traits.hpp>
3231
//     __ _____ _____ _____
3232
//  __|  |   __|     |   | |  JSON for Modern C++
3233
// |  |  |__   |  |  | | | |  version 3.11.3
3234
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3235
//
3236
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3237
// SPDX-License-Identifier: MIT
3238
3239
3240
3241
#include <limits> // numeric_limits
3242
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
3243
#include <utility> // declval
3244
#include <tuple> // tuple
3245
#include <string> // char_traits
3246
3247
// #include <nlohmann/detail/iterators/iterator_traits.hpp>
3248
//     __ _____ _____ _____
3249
//  __|  |   __|     |   | |  JSON for Modern C++
3250
// |  |  |__   |  |  | | | |  version 3.11.3
3251
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3252
//
3253
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3254
// SPDX-License-Identifier: MIT
3255
3256
3257
3258
#include <iterator> // random_access_iterator_tag
3259
3260
// #include <nlohmann/detail/abi_macros.hpp>
3261
3262
// #include <nlohmann/detail/meta/void_t.hpp>
3263
3264
// #include <nlohmann/detail/meta/cpp_future.hpp>
3265
3266
3267
NLOHMANN_JSON_NAMESPACE_BEGIN
3268
namespace detail
3269
{
3270
3271
template<typename It, typename = void>
3272
struct iterator_types {};
3273
3274
template<typename It>
3275
struct iterator_types <
3276
    It,
3277
    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3278
    typename It::reference, typename It::iterator_category >>
3279
{
3280
    using difference_type = typename It::difference_type;
3281
    using value_type = typename It::value_type;
3282
    using pointer = typename It::pointer;
3283
    using reference = typename It::reference;
3284
    using iterator_category = typename It::iterator_category;
3285
};
3286
3287
// This is required as some compilers implement std::iterator_traits in a way that
3288
// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
3289
template<typename T, typename = void>
3290
struct iterator_traits
3291
{
3292
};
3293
3294
template<typename T>
3295
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3296
            : iterator_types<T>
3297
{
3298
};
3299
3300
template<typename T>
3301
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3302
{
3303
    using iterator_category = std::random_access_iterator_tag;
3304
    using value_type = T;
3305
    using difference_type = ptrdiff_t;
3306
    using pointer = T*;
3307
    using reference = T&;
3308
};
3309
3310
}  // namespace detail
3311
NLOHMANN_JSON_NAMESPACE_END
3312
3313
// #include <nlohmann/detail/macro_scope.hpp>
3314
3315
// #include <nlohmann/detail/meta/call_std/begin.hpp>
3316
//     __ _____ _____ _____
3317
//  __|  |   __|     |   | |  JSON for Modern C++
3318
// |  |  |__   |  |  | | | |  version 3.11.3
3319
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3320
//
3321
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3322
// SPDX-License-Identifier: MIT
3323
3324
3325
3326
// #include <nlohmann/detail/macro_scope.hpp>
3327
3328
3329
NLOHMANN_JSON_NAMESPACE_BEGIN
3330
3331
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
3332
3333
NLOHMANN_JSON_NAMESPACE_END
3334
3335
// #include <nlohmann/detail/meta/call_std/end.hpp>
3336
//     __ _____ _____ _____
3337
//  __|  |   __|     |   | |  JSON for Modern C++
3338
// |  |  |__   |  |  | | | |  version 3.11.3
3339
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3340
//
3341
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3342
// SPDX-License-Identifier: MIT
3343
3344
3345
3346
// #include <nlohmann/detail/macro_scope.hpp>
3347
3348
3349
NLOHMANN_JSON_NAMESPACE_BEGIN
3350
3351
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
3352
3353
NLOHMANN_JSON_NAMESPACE_END
3354
3355
// #include <nlohmann/detail/meta/cpp_future.hpp>
3356
3357
// #include <nlohmann/detail/meta/detected.hpp>
3358
3359
// #include <nlohmann/json_fwd.hpp>
3360
//     __ _____ _____ _____
3361
//  __|  |   __|     |   | |  JSON for Modern C++
3362
// |  |  |__   |  |  | | | |  version 3.11.3
3363
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
3364
//
3365
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
3366
// SPDX-License-Identifier: MIT
3367
3368
#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3369
    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3370
3371
    #include <cstdint> // int64_t, uint64_t
3372
    #include <map> // map
3373
    #include <memory> // allocator
3374
    #include <string> // string
3375
    #include <vector> // vector
3376
3377
    // #include <nlohmann/detail/abi_macros.hpp>
3378
3379
3380
    /*!
3381
    @brief namespace for Niels Lohmann
3382
    @see https://github.com/nlohmann
3383
    @since version 1.0.0
3384
    */
3385
    NLOHMANN_JSON_NAMESPACE_BEGIN
3386
3387
    /*!
3388
    @brief default JSONSerializer template argument
3389
3390
    This serializer ignores the template arguments and uses ADL
3391
    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
3392
    for serialization.
3393
    */
3394
    template<typename T = void, typename SFINAE = void>
3395
    struct adl_serializer;
3396
3397
    /// a class to store JSON values
3398
    /// @sa https://json.nlohmann.me/api/basic_json/
3399
    template<template<typename U, typename V, typename... Args> class ObjectType =
3400
    std::map,
3401
    template<typename U, typename... Args> class ArrayType = std::vector,
3402
    class StringType = std::string, class BooleanType = bool,
3403
    class NumberIntegerType = std::int64_t,
3404
    class NumberUnsignedType = std::uint64_t,
3405
    class NumberFloatType = double,
3406
    template<typename U> class AllocatorType = std::allocator,
3407
    template<typename T, typename SFINAE = void> class JSONSerializer =
3408
    adl_serializer,
3409
    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
3410
    class CustomBaseClass = void>
3411
    class basic_json;
3412
3413
    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
3414
    /// @sa https://json.nlohmann.me/api/json_pointer/
3415
    template<typename RefStringType>
3416
    class json_pointer;
3417
3418
    /*!
3419
    @brief default specialization
3420
    @sa https://json.nlohmann.me/api/json/
3421
    */
3422
    using json = basic_json<>;
3423
3424
    /// @brief a minimal map-like container that preserves insertion order
3425
    /// @sa https://json.nlohmann.me/api/ordered_map/
3426
    template<class Key, class T, class IgnoredLess, class Allocator>
3427
    struct ordered_map;
3428
3429
    /// @brief specialization that maintains the insertion order of object keys
3430
    /// @sa https://json.nlohmann.me/api/ordered_json/
3431
    using ordered_json = basic_json<nlohmann::ordered_map>;
3432
3433
    NLOHMANN_JSON_NAMESPACE_END
3434
3435
#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
3436
3437
3438
NLOHMANN_JSON_NAMESPACE_BEGIN
3439
/*!
3440
@brief detail namespace with internal helper functions
3441
3442
This namespace collects functions that should not be exposed,
3443
implementations of some @ref basic_json methods, and meta-programming helpers.
3444
3445
@since version 2.1.0
3446
*/
3447
namespace detail
3448
{
3449
3450
/////////////
3451
// helpers //
3452
/////////////
3453
3454
// Note to maintainers:
3455
//
3456
// Every trait in this file expects a non CV-qualified type.
3457
// The only exceptions are in the 'aliases for detected' section
3458
// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
3459
//
3460
// In this case, T has to be properly CV-qualified to constraint the function arguments
3461
// (e.g. to_json(BasicJsonType&, const T&))
3462
3463
template<typename> struct is_basic_json : std::false_type {};
3464
3465
NLOHMANN_BASIC_JSON_TPL_DECLARATION
3466
struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3467
3468
// used by exceptions create() member functions
3469
// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
3470
// false_type otherwise
3471
template<typename BasicJsonContext>
3472
struct is_basic_json_context :
3473
    std::integral_constant < bool,
3474
    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
3475
    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
3476
{};
3477
3478
//////////////////////
3479
// json_ref helpers //
3480
//////////////////////
3481
3482
template<typename>
3483
class json_ref;
3484
3485
template<typename>
3486
struct is_json_ref : std::false_type {};
3487
3488
template<typename T>
3489
struct is_json_ref<json_ref<T>> : std::true_type {};
3490
3491
//////////////////////////
3492
// aliases for detected //
3493
//////////////////////////
3494
3495
template<typename T>
3496
using mapped_type_t = typename T::mapped_type;
3497
3498
template<typename T>
3499
using key_type_t = typename T::key_type;
3500
3501
template<typename T>
3502
using value_type_t = typename T::value_type;
3503
3504
template<typename T>
3505
using difference_type_t = typename T::difference_type;
3506
3507
template<typename T>
3508
using pointer_t = typename T::pointer;
3509
3510
template<typename T>
3511
using reference_t = typename T::reference;
3512
3513
template<typename T>
3514
using iterator_category_t = typename T::iterator_category;
3515
3516
template<typename T, typename... Args>
3517
using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3518
3519
template<typename T, typename... Args>
3520
using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3521
3522
template<typename T, typename U>
3523
using get_template_function = decltype(std::declval<T>().template get<U>());
3524
3525
// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3526
template<typename BasicJsonType, typename T, typename = void>
3527
struct has_from_json : std::false_type {};
3528
3529
// trait checking if j.get<T> is valid
3530
// use this trait instead of std::is_constructible or std::is_convertible,
3531
// both rely on, or make use of implicit conversions, and thus fail when T
3532
// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3533
template <typename BasicJsonType, typename T>
3534
struct is_getable
3535
{
3536
    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3537
};
3538
3539
template<typename BasicJsonType, typename T>
3540
struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3541
{
3542
    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3543
3544
    static constexpr bool value =
3545
        is_detected_exact<void, from_json_function, serializer,
3546
        const BasicJsonType&, T&>::value;
3547
};
3548
3549
// This trait checks if JSONSerializer<T>::from_json(json const&) exists
3550
// this overload is used for non-default-constructible user-defined-types
3551
template<typename BasicJsonType, typename T, typename = void>
3552
struct has_non_default_from_json : std::false_type {};
3553
3554
template<typename BasicJsonType, typename T>
3555
struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3556
{
3557
    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3558
3559
    static constexpr bool value =
3560
        is_detected_exact<T, from_json_function, serializer,
3561
        const BasicJsonType&>::value;
3562
};
3563
3564
// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3565
// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3566
template<typename BasicJsonType, typename T, typename = void>
3567
struct has_to_json : std::false_type {};
3568
3569
template<typename BasicJsonType, typename T>
3570
struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3571
{
3572
    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3573
3574
    static constexpr bool value =
3575
        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3576
        T>::value;
3577
};
3578
3579
template<typename T>
3580
using detect_key_compare = typename T::key_compare;
3581
3582
template<typename T>
3583
struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
3584
3585
// obtains the actual object key comparator
3586
template<typename BasicJsonType>
3587
struct actual_object_comparator
3588
{
3589
    using object_t = typename BasicJsonType::object_t;
3590
    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
3591
    using type = typename std::conditional < has_key_compare<object_t>::value,
3592
          typename object_t::key_compare, object_comparator_t>::type;
3593
};
3594
3595
template<typename BasicJsonType>
3596
using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
3597
3598
/////////////////
3599
// char_traits //
3600
/////////////////
3601
3602
// Primary template of char_traits calls std char_traits
3603
template<typename T>
3604
struct char_traits : std::char_traits<T>
3605
{};
3606
3607
// Explicitly define char traits for unsigned char since it is not standard
3608
template<>
3609
struct char_traits<unsigned char> : std::char_traits<char>
3610
{
3611
    using char_type = unsigned char;
3612
    using int_type = uint64_t;
3613
3614
    // Redefine to_int_type function
3615
    static int_type to_int_type(char_type c) noexcept
3616
14.8M
    {
3617
14.8M
        return static_cast<int_type>(c);
3618
14.8M
    }
3619
3620
    static char_type to_char_type(int_type i) noexcept
3621
328k
    {
3622
328k
        return static_cast<char_type>(i);
3623
328k
    }
3624
3625
    static constexpr int_type eof() noexcept
3626
1.75M
    {
3627
1.75M
        return static_cast<int_type>(EOF);
3628
1.75M
    }
3629
};
3630
3631
// Explicitly define char traits for signed char since it is not standard
3632
template<>
3633
struct char_traits<signed char> : std::char_traits<char>
3634
{
3635
    using char_type = signed char;
3636
    using int_type = uint64_t;
3637
3638
    // Redefine to_int_type function
3639
    static int_type to_int_type(char_type c) noexcept
3640
0
    {
3641
0
        return static_cast<int_type>(c);
3642
0
    }
3643
3644
    static char_type to_char_type(int_type i) noexcept
3645
0
    {
3646
0
        return static_cast<char_type>(i);
3647
0
    }
3648
3649
    static constexpr int_type eof() noexcept
3650
0
    {
3651
0
        return static_cast<int_type>(EOF);
3652
0
    }
3653
};
3654
3655
///////////////////
3656
// is_ functions //
3657
///////////////////
3658
3659
// https://en.cppreference.com/w/cpp/types/conjunction
3660
template<class...> struct conjunction : std::true_type { };
3661
template<class B> struct conjunction<B> : B { };
3662
template<class B, class... Bn>
3663
struct conjunction<B, Bn...>
3664
: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
3665
3666
// https://en.cppreference.com/w/cpp/types/negation
3667
template<class B> struct negation : std::integral_constant < bool, !B::value > { };
3668
3669
// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
3670
// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
3671
// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
3672
template <typename T>
3673
struct is_default_constructible : std::is_default_constructible<T> {};
3674
3675
template <typename T1, typename T2>
3676
struct is_default_constructible<std::pair<T1, T2>>
3677
            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3678
3679
template <typename T1, typename T2>
3680
struct is_default_constructible<const std::pair<T1, T2>>
3681
            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3682
3683
template <typename... Ts>
3684
struct is_default_constructible<std::tuple<Ts...>>
3685
            : conjunction<is_default_constructible<Ts>...> {};
3686
3687
template <typename... Ts>
3688
struct is_default_constructible<const std::tuple<Ts...>>
3689
            : conjunction<is_default_constructible<Ts>...> {};
3690
3691
template <typename T, typename... Args>
3692
struct is_constructible : std::is_constructible<T, Args...> {};
3693
3694
template <typename T1, typename T2>
3695
struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3696
3697
template <typename T1, typename T2>
3698
struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3699
3700
template <typename... Ts>
3701
struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3702
3703
template <typename... Ts>
3704
struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3705
3706
template<typename T, typename = void>
3707
struct is_iterator_traits : std::false_type {};
3708
3709
template<typename T>
3710
struct is_iterator_traits<iterator_traits<T>>
3711
{
3712
  private:
3713
    using traits = iterator_traits<T>;
3714
3715
  public:
3716
    static constexpr auto value =
3717
        is_detected<value_type_t, traits>::value &&
3718
        is_detected<difference_type_t, traits>::value &&
3719
        is_detected<pointer_t, traits>::value &&
3720
        is_detected<iterator_category_t, traits>::value &&
3721
        is_detected<reference_t, traits>::value;
3722
};
3723
3724
template<typename T>
3725
struct is_range
3726
{
3727
  private:
3728
    using t_ref = typename std::add_lvalue_reference<T>::type;
3729
3730
    using iterator = detected_t<result_of_begin, t_ref>;
3731
    using sentinel = detected_t<result_of_end, t_ref>;
3732
3733
    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
3734
    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
3735
    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
3736
    static constexpr auto is_iterator_begin =
3737
        is_iterator_traits<iterator_traits<iterator>>::value;
3738
3739
  public:
3740
    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
3741
};
3742
3743
template<typename R>
3744
using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3745
3746
template<typename T>
3747
using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
3748
3749
// The following implementation of is_complete_type is taken from
3750
// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
3751
// and is written by Xiang Fan who agreed to using it in this library.
3752
3753
template<typename T, typename = void>
3754
struct is_complete_type : std::false_type {};
3755
3756
template<typename T>
3757
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3758
3759
template<typename BasicJsonType, typename CompatibleObjectType,
3760
         typename = void>
3761
struct is_compatible_object_type_impl : std::false_type {};
3762
3763
template<typename BasicJsonType, typename CompatibleObjectType>
3764
struct is_compatible_object_type_impl <
3765
    BasicJsonType, CompatibleObjectType,
3766
    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3767
    is_detected<key_type_t, CompatibleObjectType>::value >>
3768
{
3769
    using object_t = typename BasicJsonType::object_t;
3770
3771
    // macOS's is_constructible does not play well with nonesuch...
3772
    static constexpr bool value =
3773
        is_constructible<typename object_t::key_type,
3774
        typename CompatibleObjectType::key_type>::value &&
3775
        is_constructible<typename object_t::mapped_type,
3776
        typename CompatibleObjectType::mapped_type>::value;
3777
};
3778
3779
template<typename BasicJsonType, typename CompatibleObjectType>
3780
struct is_compatible_object_type
3781
    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3782
3783
template<typename BasicJsonType, typename ConstructibleObjectType,
3784
         typename = void>
3785
struct is_constructible_object_type_impl : std::false_type {};
3786
3787
template<typename BasicJsonType, typename ConstructibleObjectType>
3788
struct is_constructible_object_type_impl <
3789
    BasicJsonType, ConstructibleObjectType,
3790
    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3791
    is_detected<key_type_t, ConstructibleObjectType>::value >>
3792
{
3793
    using object_t = typename BasicJsonType::object_t;
3794
3795
    static constexpr bool value =
3796
        (is_default_constructible<ConstructibleObjectType>::value &&
3797
         (std::is_move_assignable<ConstructibleObjectType>::value ||
3798
          std::is_copy_assignable<ConstructibleObjectType>::value) &&
3799
         (is_constructible<typename ConstructibleObjectType::key_type,
3800
          typename object_t::key_type>::value &&
3801
          std::is_same <
3802
          typename object_t::mapped_type,
3803
          typename ConstructibleObjectType::mapped_type >::value)) ||
3804
        (has_from_json<BasicJsonType,
3805
         typename ConstructibleObjectType::mapped_type>::value ||
3806
         has_non_default_from_json <
3807
         BasicJsonType,
3808
         typename ConstructibleObjectType::mapped_type >::value);
3809
};
3810
3811
template<typename BasicJsonType, typename ConstructibleObjectType>
3812
struct is_constructible_object_type
3813
    : is_constructible_object_type_impl<BasicJsonType,
3814
      ConstructibleObjectType> {};
3815
3816
template<typename BasicJsonType, typename CompatibleStringType>
3817
struct is_compatible_string_type
3818
{
3819
    static constexpr auto value =
3820
        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3821
};
3822
3823
template<typename BasicJsonType, typename ConstructibleStringType>
3824
struct is_constructible_string_type
3825
{
3826
    // launder type through decltype() to fix compilation failure on ICPC
3827
#ifdef __INTEL_COMPILER
3828
    using laundered_type = decltype(std::declval<ConstructibleStringType>());
3829
#else
3830
    using laundered_type = ConstructibleStringType;
3831
#endif
3832
3833
    static constexpr auto value =
3834
        conjunction <
3835
        is_constructible<laundered_type, typename BasicJsonType::string_t>,
3836
        is_detected_exact<typename BasicJsonType::string_t::value_type,
3837
        value_type_t, laundered_type >>::value;
3838
};
3839
3840
template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3841
struct is_compatible_array_type_impl : std::false_type {};
3842
3843
template<typename BasicJsonType, typename CompatibleArrayType>
3844
struct is_compatible_array_type_impl <
3845
    BasicJsonType, CompatibleArrayType,
3846
    enable_if_t <
3847
    is_detected<iterator_t, CompatibleArrayType>::value&&
3848
    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
3849
// special case for types like std::filesystem::path whose iterator's value_type are themselves
3850
// c.f. https://github.com/nlohmann/json/pull/3073
3851
    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3852
{
3853
    static constexpr bool value =
3854
        is_constructible<BasicJsonType,
3855
        range_value_t<CompatibleArrayType>>::value;
3856
};
3857
3858
template<typename BasicJsonType, typename CompatibleArrayType>
3859
struct is_compatible_array_type
3860
    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3861
3862
template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3863
struct is_constructible_array_type_impl : std::false_type {};
3864
3865
template<typename BasicJsonType, typename ConstructibleArrayType>
3866
struct is_constructible_array_type_impl <
3867
    BasicJsonType, ConstructibleArrayType,
3868
    enable_if_t<std::is_same<ConstructibleArrayType,
3869
    typename BasicJsonType::value_type>::value >>
3870
            : std::true_type {};
3871
3872
template<typename BasicJsonType, typename ConstructibleArrayType>
3873
struct is_constructible_array_type_impl <
3874
    BasicJsonType, ConstructibleArrayType,
3875
    enable_if_t < !std::is_same<ConstructibleArrayType,
3876
    typename BasicJsonType::value_type>::value&&
3877
    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3878
    is_default_constructible<ConstructibleArrayType>::value&&
3879
(std::is_move_assignable<ConstructibleArrayType>::value ||
3880
 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3881
is_detected<iterator_t, ConstructibleArrayType>::value&&
3882
is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
3883
is_detected<range_value_t, ConstructibleArrayType>::value&&
3884
// special case for types like std::filesystem::path whose iterator's value_type are themselves
3885
// c.f. https://github.com/nlohmann/json/pull/3073
3886
!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
3887
        is_complete_type <
3888
        detected_t<range_value_t, ConstructibleArrayType >>::value >>
3889
{
3890
    using value_type = range_value_t<ConstructibleArrayType>;
3891
3892
    static constexpr bool value =
3893
        std::is_same<value_type,
3894
        typename BasicJsonType::array_t::value_type>::value ||
3895
        has_from_json<BasicJsonType,
3896
        value_type>::value ||
3897
        has_non_default_from_json <
3898
        BasicJsonType,
3899
        value_type >::value;
3900
};
3901
3902
template<typename BasicJsonType, typename ConstructibleArrayType>
3903
struct is_constructible_array_type
3904
    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3905
3906
template<typename RealIntegerType, typename CompatibleNumberIntegerType,
3907
         typename = void>
3908
struct is_compatible_integer_type_impl : std::false_type {};
3909
3910
template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3911
struct is_compatible_integer_type_impl <
3912
    RealIntegerType, CompatibleNumberIntegerType,
3913
    enable_if_t < std::is_integral<RealIntegerType>::value&&
3914
    std::is_integral<CompatibleNumberIntegerType>::value&&
3915
    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3916
{
3917
    // is there an assert somewhere on overflows?
3918
    using RealLimits = std::numeric_limits<RealIntegerType>;
3919
    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3920
3921
    static constexpr auto value =
3922
        is_constructible<RealIntegerType,
3923
        CompatibleNumberIntegerType>::value &&
3924
        CompatibleLimits::is_integer &&
3925
        RealLimits::is_signed == CompatibleLimits::is_signed;
3926
};
3927
3928
template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3929
struct is_compatible_integer_type
3930
    : is_compatible_integer_type_impl<RealIntegerType,
3931
      CompatibleNumberIntegerType> {};
3932
3933
template<typename BasicJsonType, typename CompatibleType, typename = void>
3934
struct is_compatible_type_impl: std::false_type {};
3935
3936
template<typename BasicJsonType, typename CompatibleType>
3937
struct is_compatible_type_impl <
3938
    BasicJsonType, CompatibleType,
3939
    enable_if_t<is_complete_type<CompatibleType>::value >>
3940
{
3941
    static constexpr bool value =
3942
        has_to_json<BasicJsonType, CompatibleType>::value;
3943
};
3944
3945
template<typename BasicJsonType, typename CompatibleType>
3946
struct is_compatible_type
3947
    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3948
3949
template<typename T1, typename T2>
3950
struct is_constructible_tuple : std::false_type {};
3951
3952
template<typename T1, typename... Args>
3953
struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3954
3955
template<typename BasicJsonType, typename T>
3956
struct is_json_iterator_of : std::false_type {};
3957
3958
template<typename BasicJsonType>
3959
struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
3960
3961
template<typename BasicJsonType>
3962
struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
3963
{};
3964
3965
// checks if a given type T is a template specialization of Primary
3966
template<template <typename...> class Primary, typename T>
3967
struct is_specialization_of : std::false_type {};
3968
3969
template<template <typename...> class Primary, typename... Args>
3970
struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
3971
3972
template<typename T>
3973
using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
3974
3975
// checks if A and B are comparable using Compare functor
3976
template<typename Compare, typename A, typename B, typename = void>
3977
struct is_comparable : std::false_type {};
3978
3979
template<typename Compare, typename A, typename B>
3980
struct is_comparable<Compare, A, B, void_t<
3981
decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
3982
decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
3983
>> : std::true_type {};
3984
3985
template<typename T>
3986
using detect_is_transparent = typename T::is_transparent;
3987
3988
// type trait to check if KeyType can be used as object key (without a BasicJsonType)
3989
// see is_usable_as_basic_json_key_type below
3990
template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
3991
         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
3992
using is_usable_as_key_type = typename std::conditional <
3993
                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
3994
                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
3995
                                   ObjectKeyType>::value)
3996
                              && (!RequireTransparentComparator
3997
                                  || is_detected <detect_is_transparent, Comparator>::value)
3998
                              && !is_json_pointer<KeyType>::value,
3999
                              std::true_type,
4000
                              std::false_type >::type;
4001
4002
// type trait to check if KeyType can be used as object key
4003
// true if:
4004
//   - KeyType is comparable with BasicJsonType::object_t::key_type
4005
//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
4006
//   - the comparator is transparent or RequireTransparentComparator is false
4007
//   - KeyType is not a JSON iterator or json_pointer
4008
template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
4009
         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
4010
using is_usable_as_basic_json_key_type = typename std::conditional <
4011
        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
4012
        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
4013
        RequireTransparentComparator, ExcludeObjectKeyType>::value
4014
        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
4015
        std::true_type,
4016
        std::false_type >::type;
4017
4018
template<typename ObjectType, typename KeyType>
4019
using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
4020
4021
// type trait to check if object_t has an erase() member functions accepting KeyType
4022
template<typename BasicJsonType, typename KeyType>
4023
using has_erase_with_key_type = typename std::conditional <
4024
                                is_detected <
4025
                                detect_erase_with_key_type,
4026
                                typename BasicJsonType::object_t, KeyType >::value,
4027
                                std::true_type,
4028
                                std::false_type >::type;
4029
4030
// a naive helper to check if a type is an ordered_map (exploits the fact that
4031
// ordered_map inherits capacity() from std::vector)
4032
template <typename T>
4033
struct is_ordered_map
4034
{
4035
    using one = char;
4036
4037
    struct two
4038
    {
4039
        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4040
    };
4041
4042
    template <typename C> static one test( decltype(&C::capacity) ) ;
4043
    template <typename C> static two test(...);
4044
4045
    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
4046
};
4047
4048
// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
4049
template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
4050
T conditional_static_cast(U value)
4051
108k
{
4052
108k
    return static_cast<T>(value);
4053
108k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::conditional_static_cast<unsigned long, unsigned int, 0>(unsigned int)
Line
Count
Source
4051
108k
{
4052
108k
    return static_cast<T>(value);
4053
108k
}
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::conditional_static_cast<unsigned long, unsigned char, 0>(unsigned char)
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::conditional_static_cast<unsigned long, unsigned short, 0>(unsigned short)
4054
4055
template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
4056
T conditional_static_cast(U value)
4057
1.46k
{
4058
1.46k
    return value;
4059
1.46k
}
4060
4061
template<typename... Types>
4062
using all_integral = conjunction<std::is_integral<Types>...>;
4063
4064
template<typename... Types>
4065
using all_signed = conjunction<std::is_signed<Types>...>;
4066
4067
template<typename... Types>
4068
using all_unsigned = conjunction<std::is_unsigned<Types>...>;
4069
4070
// there's a disjunction trait in another PR; replace when merged
4071
template<typename... Types>
4072
using same_sign = std::integral_constant < bool,
4073
      all_signed<Types...>::value || all_unsigned<Types...>::value >;
4074
4075
template<typename OfType, typename T>
4076
using never_out_of_range = std::integral_constant < bool,
4077
      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
4078
      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
4079
4080
template<typename OfType, typename T,
4081
         bool OfTypeSigned = std::is_signed<OfType>::value,
4082
         bool TSigned = std::is_signed<T>::value>
4083
struct value_in_range_of_impl2;
4084
4085
template<typename OfType, typename T>
4086
struct value_in_range_of_impl2<OfType, T, false, false>
4087
{
4088
    static constexpr bool test(T val)
4089
    {
4090
        using CommonType = typename std::common_type<OfType, T>::type;
4091
        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4092
    }
4093
};
4094
4095
template<typename OfType, typename T>
4096
struct value_in_range_of_impl2<OfType, T, true, false>
4097
{
4098
    static constexpr bool test(T val)
4099
    {
4100
        using CommonType = typename std::common_type<OfType, T>::type;
4101
        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4102
    }
4103
};
4104
4105
template<typename OfType, typename T>
4106
struct value_in_range_of_impl2<OfType, T, false, true>
4107
{
4108
    static constexpr bool test(T val)
4109
323
    {
4110
323
        using CommonType = typename std::common_type<OfType, T>::type;
4111
323
        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4112
323
    }
4113
};
4114
4115
template<typename OfType, typename T>
4116
struct value_in_range_of_impl2<OfType, T, true, true>
4117
{
4118
    static constexpr bool test(T val)
4119
    {
4120
        using CommonType = typename std::common_type<OfType, T>::type;
4121
        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
4122
               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4123
    }
4124
};
4125
4126
template<typename OfType, typename T,
4127
         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
4128
         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
4129
struct value_in_range_of_impl1;
4130
4131
template<typename OfType, typename T>
4132
struct value_in_range_of_impl1<OfType, T, false>
4133
{
4134
    static constexpr bool test(T val)
4135
323
    {
4136
323
        return value_in_range_of_impl2<OfType, T>::test(val);
4137
323
    }
4138
};
4139
4140
template<typename OfType, typename T>
4141
struct value_in_range_of_impl1<OfType, T, true>
4142
{
4143
    static constexpr bool test(T /*val*/)
4144
1.01k
    {
4145
1.01k
        return true;
4146
1.01k
    }
4147
};
4148
4149
template<typename OfType, typename T>
4150
inline constexpr bool value_in_range_of(T val)
4151
1.33k
{
4152
1.33k
    return value_in_range_of_impl1<OfType, T>::test(val);
4153
1.33k
}
bool nlohmann::json_abi_v3_11_3::detail::value_in_range_of<unsigned long, long>(long)
Line
Count
Source
4151
323
{
4152
323
    return value_in_range_of_impl1<OfType, T>::test(val);
4153
323
}
bool nlohmann::json_abi_v3_11_3::detail::value_in_range_of<unsigned long, unsigned long>(unsigned long)
Line
Count
Source
4151
1.01k
{
4152
1.01k
    return value_in_range_of_impl1<OfType, T>::test(val);
4153
1.01k
}
4154
4155
template<bool Value>
4156
using bool_constant = std::integral_constant<bool, Value>;
4157
4158
///////////////////////////////////////////////////////////////////////////////
4159
// is_c_string
4160
///////////////////////////////////////////////////////////////////////////////
4161
4162
namespace impl
4163
{
4164
4165
template<typename T>
4166
inline constexpr bool is_c_string()
4167
{
4168
    using TUnExt = typename std::remove_extent<T>::type;
4169
    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
4170
    using TUnPtr = typename std::remove_pointer<T>::type;
4171
    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
4172
    return
4173
        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
4174
        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
4175
}
4176
4177
}  // namespace impl
4178
4179
// checks whether T is a [cv] char */[cv] char[] C string
4180
template<typename T>
4181
struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
4182
4183
template<typename T>
4184
using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
4185
4186
///////////////////////////////////////////////////////////////////////////////
4187
// is_transparent
4188
///////////////////////////////////////////////////////////////////////////////
4189
4190
namespace impl
4191
{
4192
4193
template<typename T>
4194
inline constexpr bool is_transparent()
4195
0
{
4196
0
    return is_detected<detect_is_transparent, T>::value;
4197
0
}
4198
4199
}  // namespace impl
4200
4201
// checks whether T has a member named is_transparent
4202
template<typename T>
4203
struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
4204
4205
///////////////////////////////////////////////////////////////////////////////
4206
4207
}  // namespace detail
4208
NLOHMANN_JSON_NAMESPACE_END
4209
4210
// #include <nlohmann/detail/string_concat.hpp>
4211
//     __ _____ _____ _____
4212
//  __|  |   __|     |   | |  JSON for Modern C++
4213
// |  |  |__   |  |  | | | |  version 3.11.3
4214
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
4215
//
4216
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
4217
// SPDX-License-Identifier: MIT
4218
4219
4220
4221
#include <cstring> // strlen
4222
#include <string> // string
4223
#include <utility> // forward
4224
4225
// #include <nlohmann/detail/meta/cpp_future.hpp>
4226
4227
// #include <nlohmann/detail/meta/detected.hpp>
4228
4229
4230
NLOHMANN_JSON_NAMESPACE_BEGIN
4231
namespace detail
4232
{
4233
4234
inline std::size_t concat_length()
4235
67.0k
{
4236
67.0k
    return 0;
4237
67.0k
}
4238
4239
template<typename... Args>
4240
inline std::size_t concat_length(const char* cstr, const Args& ... rest);
4241
4242
template<typename StringType, typename... Args>
4243
inline std::size_t concat_length(const StringType& str, const Args& ... rest);
4244
4245
template<typename... Args>
4246
inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
4247
31.4k
{
4248
31.4k
    return 1 + concat_length(rest...);
4249
31.4k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3]>(char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3])
Line
Count
Source
4247
15.1k
{
4248
15.1k
    return 1 + concat_length(rest...);
4249
15.1k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4247
11.7k
{
4248
11.7k
    return 1 + concat_length(rest...);
4249
11.7k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<>(char)
Line
Count
Source
4247
4.58k
{
4248
4.58k
    return 1 + concat_length(rest...);
4249
4.58k
}
4250
4251
template<typename... Args>
4252
inline std::size_t concat_length(const char* cstr, const Args& ... rest)
4253
103k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
103k
    return ::strlen(cstr) + concat_length(rest...);
4256
103k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3]>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3])
Line
Count
Source
4253
15.1k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
15.1k
    return ::strlen(cstr) + concat_length(rest...);
4256
15.1k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<>(char const*)
Line
Count
Source
4253
17.3k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
17.3k
    return ::strlen(cstr) + concat_length(rest...);
4256
17.3k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4253
29.8k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
29.8k
    return ::strlen(cstr) + concat_length(rest...);
4256
29.8k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [41]>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [41])
Line
Count
Source
4253
3
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
3
    return ::strlen(cstr) + concat_length(rest...);
4256
3
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4253
14.6k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
14.6k
    return ::strlen(cstr) + concat_length(rest...);
4256
14.6k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4253
14.6k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
14.6k
    return ::strlen(cstr) + concat_length(rest...);
4256
14.6k
}
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(char const*, char const* const&)
Line
Count
Source
4253
2.19k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
2.19k
    return ::strlen(cstr) + concat_length(rest...);
4256
2.19k
}
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [2]>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2])
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [56]>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [56])
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const&)
Line
Count
Source
4253
4.58k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
4.58k
    return ::strlen(cstr) + concat_length(rest...);
4256
4.58k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4253
2.76k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
2.76k
    return ::strlen(cstr) + concat_length(rest...);
4256
2.76k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<char [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char>(char const*, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const&)
Line
Count
Source
4253
1.81k
{
4254
    // cppcheck-suppress ignoredReturnValue
4255
1.81k
    return ::strlen(cstr) + concat_length(rest...);
4256
1.81k
}
4257
4258
template<typename StringType, typename... Args>
4259
inline std::size_t concat_length(const StringType& str, const Args& ... rest)
4260
151k
{
4261
151k
    return str.size() + concat_length(rest...);
4262
151k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
567
{
4261
567
    return str.size() + concat_length(rest...);
4262
567
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
15.1k
{
4261
15.1k
    return str.size() + concat_length(rest...);
4262
15.1k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
45.0k
{
4261
45.0k
    return str.size() + concat_length(rest...);
4262
45.0k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3])
Line
Count
Source
4260
15.1k
{
4261
15.1k
    return str.size() + concat_length(rest...);
4262
15.1k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3])
Line
Count
Source
4260
15.1k
{
4261
15.1k
    return str.size() + concat_length(rest...);
4262
15.1k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [41]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [41])
Line
Count
Source
4260
3
{
4261
3
    return str.size() + concat_length(rest...);
4262
3
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
14.6k
{
4261
14.6k
    return str.size() + concat_length(rest...);
4262
14.6k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
14.6k
{
4261
14.6k
    return str.size() + concat_length(rest...);
4262
14.6k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
11.7k
{
4261
11.7k
    return str.size() + concat_length(rest...);
4262
11.7k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
11.7k
{
4261
11.7k
    return str.size() + concat_length(rest...);
4262
11.7k
}
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [2]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2])
Unexecuted instantiation: unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [56]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [56])
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const&)
Line
Count
Source
4260
4.58k
{
4261
4.58k
    return str.size() + concat_length(rest...);
4262
4.58k
}
unsigned long nlohmann::json_abi_v3_11_3::detail::concat_length<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4260
2.76k
{
4261
2.76k
    return str.size() + concat_length(rest...);
4262
2.76k
}
4263
4264
template<typename OutStringType>
4265
inline void concat_into(OutStringType& /*out*/)
4266
67.0k
{}
4267
4268
template<typename StringType, typename Arg>
4269
using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
4270
4271
template<typename StringType, typename Arg>
4272
using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
4273
4274
template<typename StringType, typename Arg>
4275
using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
4276
4277
template<typename StringType, typename Arg>
4278
using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
4279
4280
template<typename StringType, typename Arg>
4281
using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
4282
4283
template<typename StringType, typename Arg>
4284
using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
4285
4286
template<typename StringType, typename Arg>
4287
using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
4288
4289
template<typename StringType, typename Arg>
4290
using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
4291
4292
template < typename OutStringType, typename Arg, typename... Args,
4293
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4294
                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
4295
inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
4296
4297
template < typename OutStringType, typename Arg, typename... Args,
4298
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4299
                         && !detect_string_can_append_op<OutStringType, Arg>::value
4300
                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
4301
inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4302
4303
template < typename OutStringType, typename Arg, typename... Args,
4304
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4305
                         && !detect_string_can_append_op<OutStringType, Arg>::value
4306
                         && !detect_string_can_append_iter<OutStringType, Arg>::value
4307
                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
4308
inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4309
4310
template<typename OutStringType, typename Arg, typename... Args,
4311
         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
4312
inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
4313
254k
{
4314
254k
    out.append(std::forward<Arg>(arg));
4315
254k
    concat_into(out, std::forward<Args>(rest)...);
4316
254k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
567
{
4314
567
    out.append(std::forward<Arg>(arg));
4315
567
    concat_into(out, std::forward<Args>(rest)...);
4316
567
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
15.1k
{
4314
15.1k
    out.append(std::forward<Arg>(arg));
4315
15.1k
    concat_into(out, std::forward<Args>(rest)...);
4316
15.1k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
27.0k
{
4314
27.0k
    out.append(std::forward<Arg>(arg));
4315
27.0k
    concat_into(out, std::forward<Args>(rest)...);
4316
27.0k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3])
Line
Count
Source
4313
15.1k
{
4314
15.1k
    out.append(std::forward<Arg>(arg));
4315
15.1k
    concat_into(out, std::forward<Args>(rest)...);
4316
15.1k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3])
Line
Count
Source
4313
15.1k
{
4314
15.1k
    out.append(std::forward<Arg>(arg));
4315
15.1k
    concat_into(out, std::forward<Args>(rest)...);
4316
15.1k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3])
Line
Count
Source
4313
15.1k
{
4314
15.1k
    out.append(std::forward<Arg>(arg));
4315
15.1k
    concat_into(out, std::forward<Args>(rest)...);
4316
15.1k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [3])
Line
Count
Source
4313
15.1k
{
4314
15.1k
    out.append(std::forward<Arg>(arg));
4315
15.1k
    concat_into(out, std::forward<Args>(rest)...);
4316
15.1k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [24], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [24], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
168
{
4314
168
    out.append(std::forward<Arg>(arg));
4315
168
    concat_into(out, std::forward<Args>(rest)...);
4316
168
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
17.9k
{
4314
17.9k
    out.append(std::forward<Arg>(arg));
4315
17.9k
    concat_into(out, std::forward<Args>(rest)...);
4316
17.9k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [38], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [38], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
35
{
4314
35
    out.append(std::forward<Arg>(arg));
4315
35
    concat_into(out, std::forward<Args>(rest)...);
4316
35
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [23], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [23], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
140
{
4314
140
    out.append(std::forward<Arg>(arg));
4315
140
    concat_into(out, std::forward<Args>(rest)...);
4316
140
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [42], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [42], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
39
{
4314
39
    out.append(std::forward<Arg>(arg));
4315
39
    concat_into(out, std::forward<Args>(rest)...);
4316
39
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [32], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [32], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
124
{
4314
124
    out.append(std::forward<Arg>(arg));
4315
124
    concat_into(out, std::forward<Args>(rest)...);
4316
124
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [96], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [96], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
13
{
4314
13
    out.append(std::forward<Arg>(arg));
4315
13
    concat_into(out, std::forward<Args>(rest)...);
4316
13
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
85
{
4314
85
    out.append(std::forward<Arg>(arg));
4315
85
    concat_into(out, std::forward<Args>(rest)...);
4316
85
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [90], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [90], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
28
{
4314
28
    out.append(std::forward<Arg>(arg));
4315
28
    concat_into(out, std::forward<Args>(rest)...);
4316
28
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
26
{
4314
26
    out.append(std::forward<Arg>(arg));
4315
26
    concat_into(out, std::forward<Args>(rest)...);
4316
26
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [68], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [68], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
2
{
4314
2
    out.append(std::forward<Arg>(arg));
4315
2
    concat_into(out, std::forward<Args>(rest)...);
4316
2
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41])
Line
Count
Source
4313
3
{
4314
3
    out.append(std::forward<Arg>(arg));
4315
3
    concat_into(out, std::forward<Args>(rest)...);
4316
3
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41])
Line
Count
Source
4313
3
{
4314
3
    out.append(std::forward<Arg>(arg));
4315
3
    concat_into(out, std::forward<Args>(rest)...);
4316
3
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [41], , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41])
Line
Count
Source
4313
3
{
4314
3
    out.append(std::forward<Arg>(arg));
4315
3
    concat_into(out, std::forward<Args>(rest)...);
4316
3
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [51], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [51], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
12
{
4314
12
    out.append(std::forward<Arg>(arg));
4315
12
    concat_into(out, std::forward<Args>(rest)...);
4316
12
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [22], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [22], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
2.71k
{
4314
2.71k
    out.append(std::forward<Arg>(arg));
4315
2.71k
    concat_into(out, std::forward<Args>(rest)...);
4316
2.71k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [58], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [58], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4313
4
{
4314
4
    out.append(std::forward<Arg>(arg));
4315
4
    concat_into(out, std::forward<Args>(rest)...);
4316
4
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
14.6k
{
4314
14.6k
    out.append(std::forward<Arg>(arg));
4315
14.6k
    concat_into(out, std::forward<Args>(rest)...);
4316
14.6k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
14.6k
{
4314
14.6k
    out.append(std::forward<Arg>(arg));
4315
14.6k
    concat_into(out, std::forward<Args>(rest)...);
4316
14.6k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
14.6k
{
4314
14.6k
    out.append(std::forward<Arg>(arg));
4315
14.6k
    concat_into(out, std::forward<Args>(rest)...);
4316
14.6k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
14.6k
{
4314
14.6k
    out.append(std::forward<Arg>(arg));
4315
14.6k
    concat_into(out, std::forward<Args>(rest)...);
4316
14.6k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
14.6k
{
4314
14.6k
    out.append(std::forward<Arg>(arg));
4315
14.6k
    concat_into(out, std::forward<Args>(rest)...);
4316
14.6k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
11.7k
{
4314
11.7k
    out.append(std::forward<Arg>(arg));
4315
11.7k
    concat_into(out, std::forward<Args>(rest)...);
4316
11.7k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
11.7k
{
4314
11.7k
    out.append(std::forward<Arg>(arg));
4315
11.7k
    concat_into(out, std::forward<Args>(rest)...);
4316
11.7k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4313
11.7k
{
4314
11.7k
    out.append(std::forward<Arg>(arg));
4315
11.7k
    concat_into(out, std::forward<Args>(rest)...);
4316
11.7k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [37], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [37], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
217
{
4314
217
    out.append(std::forward<Arg>(arg));
4315
217
    concat_into(out, std::forward<Args>(rest)...);
4316
217
}
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [29], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [29], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [39], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [39], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [29], char const*, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [29], char const*&&)
Line
Count
Source
4313
244
{
4314
244
    out.append(std::forward<Arg>(arg));
4315
244
    concat_into(out, std::forward<Args>(rest)...);
4316
244
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*, , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const*&&)
Line
Count
Source
4313
2.19k
{
4314
2.19k
    out.append(std::forward<Arg>(arg));
4315
2.19k
    concat_into(out, std::forward<Args>(rest)...);
4316
2.19k
}
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [25], char const*, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [25], char const*&&)
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [54], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [54], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [2], , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [2])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [52], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [2], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [52], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [2])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [2], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [2])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [16], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [56], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [16], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [56])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [56], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [56])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [56], , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [56])
Unexecuted instantiation: void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [61], char const*, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [61], char const*&&)
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [26], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [26], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char&&)
Line
Count
Source
4313
8
{
4314
8
    out.append(std::forward<Arg>(arg));
4315
8
    concat_into(out, std::forward<Args>(rest)...);
4316
8
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char&&)
Line
Count
Source
4313
1.82k
{
4314
1.82k
    out.append(std::forward<Arg>(arg));
4315
1.82k
    concat_into(out, std::forward<Args>(rest)...);
4316
1.82k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
2.76k
{
4314
2.76k
    out.append(std::forward<Arg>(arg));
4315
2.76k
    concat_into(out, std::forward<Args>(rest)...);
4316
2.76k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4313
2.76k
{
4314
2.76k
    out.append(std::forward<Arg>(arg));
4315
2.76k
    concat_into(out, std::forward<Args>(rest)...);
4316
2.76k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char&&)
Line
Count
Source
4313
2.76k
{
4314
2.76k
    out.append(std::forward<Arg>(arg));
4315
2.76k
    concat_into(out, std::forward<Args>(rest)...);
4316
2.76k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char&&)
Line
Count
Source
4313
2.76k
{
4314
2.76k
    out.append(std::forward<Arg>(arg));
4315
2.76k
    concat_into(out, std::forward<Args>(rest)...);
4316
2.76k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const*&&, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char&&)
Line
Count
Source
4313
1.81k
{
4314
1.81k
    out.append(std::forward<Arg>(arg));
4315
1.81k
    concat_into(out, std::forward<Args>(rest)...);
4316
1.81k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char&&)
Line
Count
Source
4313
1.81k
{
4314
1.81k
    out.append(std::forward<Arg>(arg));
4315
1.81k
    concat_into(out, std::forward<Args>(rest)...);
4316
1.81k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [12], char const*, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [12], char const*&&)
Line
Count
Source
4313
1.95k
{
4314
1.95k
    out.append(std::forward<Arg>(arg));
4315
1.95k
    concat_into(out, std::forward<Args>(rest)...);
4316
1.95k
}
4317
4318
template < typename OutStringType, typename Arg, typename... Args,
4319
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4320
                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
4321
inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
4322
31.4k
{
4323
31.4k
    out += std::forward<Arg>(arg);
4324
31.4k
    concat_into(out, std::forward<Args>(rest)...);
4325
31.4k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3])
Line
Count
Source
4322
15.1k
{
4323
15.1k
    out += std::forward<Arg>(arg);
4324
15.1k
    concat_into(out, std::forward<Args>(rest)...);
4325
15.1k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4322
11.7k
{
4323
11.7k
    out += std::forward<Arg>(arg);
4324
11.7k
    concat_into(out, std::forward<Args>(rest)...);
4325
11.7k
}
void nlohmann::json_abi_v3_11_3::detail::concat_into<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char, , 0>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char&&)
Line
Count
Source
4322
4.58k
{
4323
4.58k
    out += std::forward<Arg>(arg);
4324
4.58k
    concat_into(out, std::forward<Args>(rest)...);
4325
4.58k
}
4326
4327
template < typename OutStringType, typename Arg, typename... Args,
4328
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4329
                         && !detect_string_can_append_op<OutStringType, Arg>::value
4330
                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
4331
inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4332
{
4333
    out.append(arg.begin(), arg.end());
4334
    concat_into(out, std::forward<Args>(rest)...);
4335
}
4336
4337
template < typename OutStringType, typename Arg, typename... Args,
4338
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
4339
                         && !detect_string_can_append_op<OutStringType, Arg>::value
4340
                         && !detect_string_can_append_iter<OutStringType, Arg>::value
4341
                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
4342
inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4343
{
4344
    out.append(arg.data(), arg.size());
4345
    concat_into(out, std::forward<Args>(rest)...);
4346
}
4347
4348
template<typename OutStringType = std::string, typename... Args>
4349
inline OutStringType concat(Args && ... args)
4350
67.0k
{
4351
67.0k
    OutStringType str;
4352
67.0k
    str.reserve(concat_length(args...));
4353
67.0k
    concat_into(str, std::forward<Args>(args)...);
4354
67.0k
    return str;
4355
67.0k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4350
567
{
4351
567
    OutStringType str;
4352
567
    str.reserve(concat_length(args...));
4353
567
    concat_into(str, std::forward<Args>(args)...);
4354
567
    return str;
4355
567
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3]>(char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3])
Line
Count
Source
4350
15.1k
{
4351
15.1k
    OutStringType str;
4352
15.1k
    str.reserve(concat_length(args...));
4353
15.1k
    concat_into(str, std::forward<Args>(args)...);
4354
15.1k
    return str;
4355
15.1k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [24], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [24], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
168
{
4351
168
    OutStringType str;
4352
168
    str.reserve(concat_length(args...));
4353
168
    concat_into(str, std::forward<Args>(args)...);
4354
168
    return str;
4355
168
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [38], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [38], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
35
{
4351
35
    OutStringType str;
4352
35
    str.reserve(concat_length(args...));
4353
35
    concat_into(str, std::forward<Args>(args)...);
4354
35
    return str;
4355
35
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [23], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [23], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
140
{
4351
140
    OutStringType str;
4352
140
    str.reserve(concat_length(args...));
4353
140
    concat_into(str, std::forward<Args>(args)...);
4354
140
    return str;
4355
140
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [42], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [42], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
39
{
4351
39
    OutStringType str;
4352
39
    str.reserve(concat_length(args...));
4353
39
    concat_into(str, std::forward<Args>(args)...);
4354
39
    return str;
4355
39
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [32], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(char const (&) [32], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4350
124
{
4351
124
    OutStringType str;
4352
124
    str.reserve(concat_length(args...));
4353
124
    concat_into(str, std::forward<Args>(args)...);
4354
124
    return str;
4355
124
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [96], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(char const (&) [96], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4350
13
{
4351
13
    OutStringType str;
4352
13
    str.reserve(concat_length(args...));
4353
13
    concat_into(str, std::forward<Args>(args)...);
4354
13
    return str;
4355
13
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [90], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(char const (&) [90], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4350
28
{
4351
28
    OutStringType str;
4352
28
    str.reserve(concat_length(args...));
4353
28
    concat_into(str, std::forward<Args>(args)...);
4354
28
    return str;
4355
28
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(char const (&) [17], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4350
26
{
4351
26
    OutStringType str;
4352
26
    str.reserve(concat_length(args...));
4353
26
    concat_into(str, std::forward<Args>(args)...);
4354
26
    return str;
4355
26
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [68], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(char const (&) [68], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4350
2
{
4351
2
    OutStringType str;
4352
2
    str.reserve(concat_length(args...));
4353
2
    concat_into(str, std::forward<Args>(args)...);
4354
2
    return str;
4355
2
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41]>(char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [41])
Line
Count
Source
4350
3
{
4351
3
    OutStringType str;
4352
3
    str.reserve(concat_length(args...));
4353
3
    concat_into(str, std::forward<Args>(args)...);
4354
3
    return str;
4355
3
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [51], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(char const (&) [51], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4350
12
{
4351
12
    OutStringType str;
4352
12
    str.reserve(concat_length(args...));
4353
12
    concat_into(str, std::forward<Args>(args)...);
4354
12
    return str;
4355
12
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [22], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [22], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
2.71k
{
4351
2.71k
    OutStringType str;
4352
2.71k
    str.reserve(concat_length(args...));
4353
2.71k
    concat_into(str, std::forward<Args>(args)...);
4354
2.71k
    return str;
4355
2.71k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [58], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(char const (&) [58], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
4350
4
{
4351
4
    OutStringType str;
4352
4
    str.reserve(concat_length(args...));
4353
4
    concat_into(str, std::forward<Args>(args)...);
4354
4
    return str;
4355
4
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [12], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4350
14.6k
{
4351
14.6k
    OutStringType str;
4352
14.6k
    str.reserve(concat_length(args...));
4353
14.6k
    concat_into(str, std::forward<Args>(args)...);
4354
14.6k
    return str;
4355
14.6k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
11.8k
{
4351
11.8k
    OutStringType str;
4352
11.8k
    str.reserve(concat_length(args...));
4353
11.8k
    concat_into(str, std::forward<Args>(args)...);
4354
11.8k
    return str;
4355
11.8k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [3], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
4350
11.7k
{
4351
11.7k
    OutStringType str;
4352
11.7k
    str.reserve(concat_length(args...));
4353
11.7k
    concat_into(str, std::forward<Args>(args)...);
4354
11.7k
    return str;
4355
11.7k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [37], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [37], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
217
{
4351
217
    OutStringType str;
4352
217
    str.reserve(concat_length(args...));
4353
217
    concat_into(str, std::forward<Args>(args)...);
4354
217
    return str;
4355
217
}
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [29], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [29], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [5], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [39], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [39], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [29], char const*>(char const (&) [29], char const*&&)
Line
Count
Source
4350
244
{
4351
244
    OutStringType str;
4352
244
    str.reserve(concat_length(args...));
4353
244
    concat_into(str, std::forward<Args>(args)...);
4354
244
    return str;
4355
244
}
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [25], char const*>(char const (&) [25], char const*&&)
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [54], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2]>(char const (&) [54], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [2])
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [52], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [2]>(char const (&) [52], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [2])
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [16], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [56]>(char const (&) [16], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [56])
Unexecuted instantiation: std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [61], char const*>(char const (&) [61], char const*&&)
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [26], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char>(char const (&) [26], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char&&)
Line
Count
Source
4350
8
{
4351
8
    OutStringType str;
4352
8
    str.reserve(concat_length(args...));
4353
8
    concat_into(str, std::forward<Args>(args)...);
4354
8
    return str;
4355
8
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char const (&) [10], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&)
Line
Count
Source
4350
2.76k
{
4351
2.76k
    OutStringType str;
4352
2.76k
    str.reserve(concat_length(args...));
4353
2.76k
    concat_into(str, std::forward<Args>(args)...);
4354
2.76k
    return str;
4355
2.76k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char>(char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char&&)
Line
Count
Source
4350
2.76k
{
4351
2.76k
    OutStringType str;
4352
2.76k
    str.reserve(concat_length(args...));
4353
2.76k
    concat_into(str, std::forward<Args>(args)...);
4354
2.76k
    return str;
4355
2.76k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char>(char const*&&, char const (&) [15], std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&, char&&)
Line
Count
Source
4350
1.81k
{
4351
1.81k
    OutStringType str;
4352
1.81k
    str.reserve(concat_length(args...));
4353
1.81k
    concat_into(str, std::forward<Args>(args)...);
4354
1.81k
    return str;
4355
1.81k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > nlohmann::json_abi_v3_11_3::detail::concat<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const (&) [12], char const*>(char const (&) [12], char const*&&)
Line
Count
Source
4350
1.95k
{
4351
1.95k
    OutStringType str;
4352
1.95k
    str.reserve(concat_length(args...));
4353
1.95k
    concat_into(str, std::forward<Args>(args)...);
4354
1.95k
    return str;
4355
1.95k
}
4356
4357
}  // namespace detail
4358
NLOHMANN_JSON_NAMESPACE_END
4359
4360
4361
NLOHMANN_JSON_NAMESPACE_BEGIN
4362
namespace detail
4363
{
4364
4365
////////////////
4366
// exceptions //
4367
////////////////
4368
4369
/// @brief general exception of the @ref basic_json class
4370
/// @sa https://json.nlohmann.me/api/basic_json/exception/
4371
class exception : public std::exception
4372
{
4373
  public:
4374
    /// returns the explanatory string
4375
    const char* what() const noexcept override
4376
0
    {
4377
0
        return m.what();
4378
0
    }
4379
4380
    /// the id of the exception
4381
    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
4382
4383
  protected:
4384
    JSON_HEDLEY_NON_NULL(3)
4385
15.1k
    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
4386
4387
    static std::string name(const std::string& ename, int id_)
4388
15.1k
    {
4389
15.1k
        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
4390
15.1k
    }
4391