CoCalc -- json.hpp

GitHub Repository: eclipse/sumo
Path: blob/main/src/foreign/nlohmann/json.hpp
¹⁶⁹⁶⁷⁸ views
1
/*
2
    __ _____ _____ _____
3
 __|  |   __|     |   | |  JSON for Modern C++
4
|  |  |__   |  |  | | | |  version 3.10.5
5
|_____|_____|_____|_|___|  https://github.com/nlohmann/json
6

7
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
8
SPDX-License-Identifier: MIT
9
Copyright (c) 2013-2022 Niels Lohmann <http://nlohmann.me>.
10

11
Permission is hereby  granted, free of charge, to any  person obtaining a copy
12
of this software and associated  documentation files (the "Software"), to deal
13
in the Software  without restriction, including without  limitation the rights
14
to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
15
copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
16
furnished to do so, subject to the following conditions:
17

18
The above copyright notice and this permission notice shall be included in all
19
copies or substantial portions of the Software.
20

21
THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
22
IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
23
FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
24
AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
25
LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26
OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
27
SOFTWARE.
28
*/
29

30
/****************************************************************************\
31
 * Note on documentation: The source files contain links to the online      *
32
 * documentation of the public API at https://json.nlohmann.me. This URL    *
33
 * contains the most recent documentation and should also be applicable to  *
34
 * previous versions; documentation for deprecated functions is not         *
35
 * removed, but marked deprecated. See "Generate documentation" section in  *
36
 * file doc/README.md.                                                      *
37
\****************************************************************************/
38

39
#ifndef INCLUDE_NLOHMANN_JSON_HPP_
40
#define INCLUDE_NLOHMANN_JSON_HPP_
41

42
#define NLOHMANN_JSON_VERSION_MAJOR 3
43
#define NLOHMANN_JSON_VERSION_MINOR 10
44
#define NLOHMANN_JSON_VERSION_PATCH 5
45

46
#include <algorithm> // all_of, find, for_each
47
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
48
#include <functional> // hash, less
49
#include <initializer_list> // initializer_list
50
#ifndef JSON_NO_IO
51
    #include <iosfwd> // istream, ostream
52
#endif  // JSON_NO_IO
53
#include <iterator> // random_access_iterator_tag
54
#include <memory> // unique_ptr
55
#include <numeric> // accumulate
56
#include <string> // string, stoi, to_string
57
#include <utility> // declval, forward, move, pair, swap
58
#include <vector> // vector
59

60
// #include <nlohmann/adl_serializer.hpp>
61

62

63
#include <type_traits>
64
#include <utility>
65

66
// #include <nlohmann/detail/conversions/from_json.hpp>
67

68

69
#include <algorithm> // transform
70
#include <array> // array
71
#include <forward_list> // forward_list
72
#include <iterator> // inserter, front_inserter, end
73
#include <map> // map
74
#include <string> // string
75
#include <tuple> // tuple, make_tuple
76
#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
77
#include <unordered_map> // unordered_map
78
#include <utility> // pair, declval
79
#include <valarray> // valarray
80

81
// #include <nlohmann/detail/exceptions.hpp>
82

83

84
#include <exception> // exception
85
#include <stdexcept> // runtime_error
86
#include <string> // to_string
87
#include <vector> // vector
88

89
// #include <nlohmann/detail/value_t.hpp>
90

91

92
#include <array> // array
93
#include <cstddef> // size_t
94
#include <cstdint> // uint8_t
95
#include <string> // string
96

97
namespace nlohmann
98
{
99
namespace detail
100
{
101
///////////////////////////
102
// JSON type enumeration //
103
///////////////////////////
104

105
/*!
106
@brief the JSON type enumeration
107

108
This enumeration collects the different JSON types. It is internally used to
109
distinguish the stored values, and the functions @ref basic_json::is_null(),
110
@ref basic_json::is_object(), @ref basic_json::is_array(),
111
@ref basic_json::is_string(), @ref basic_json::is_boolean(),
112
@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
113
@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
114
@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
115
@ref basic_json::is_structured() rely on it.
116

117
@note There are three enumeration entries (number_integer, number_unsigned, and
118
number_float), because the library distinguishes these three types for numbers:
119
@ref basic_json::number_unsigned_t is used for unsigned integers,
120
@ref basic_json::number_integer_t is used for signed integers, and
121
@ref basic_json::number_float_t is used for floating-point numbers or to
122
approximate integers which do not fit in the limits of their respective type.
123

124
@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
125
value with the default value for a given type
126

127
@since version 1.0.0
128
*/
129
enum class value_t : std::uint8_t
130
{
131
    null,             ///< null value
132
    object,           ///< object (unordered set of name/value pairs)
133
    array,            ///< array (ordered collection of values)
134
    string,           ///< string value
135
    boolean,          ///< boolean value
136
    number_integer,   ///< number value (signed integer)
137
    number_unsigned,  ///< number value (unsigned integer)
138
    number_float,     ///< number value (floating-point)
139
    binary,           ///< binary array (ordered collection of bytes)
140
    discarded         ///< discarded by the parser callback function
141
};
142

143
/*!
144
@brief comparison operator for JSON types
145

146
Returns an ordering that is similar to Python:
147
- order: null < boolean < number < object < array < string < binary
148
- furthermore, each type is not smaller than itself
149
- discarded values are not comparable
150
- binary is represented as a b"" string in python and directly comparable to a
151
  string; however, making a binary array directly comparable with a string would
152
  be surprising behavior in a JSON file.
153

154
@since version 1.0.0
155
*/
156
inline bool operator<(const value_t lhs, const value_t rhs) noexcept
157
{
158
    static constexpr std::array<std::uint8_t, 9> order = {{
159
            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
160
            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
161
            6 /* binary */
162
        }
163
    };
164

165
    const auto l_index = static_cast<std::size_t>(lhs);
166
    const auto r_index = static_cast<std::size_t>(rhs);
167
    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
168
}
169
}  // namespace detail
170
}  // namespace nlohmann
171

172
// #include <nlohmann/detail/string_escape.hpp>
173

174

175
#include <string>
176
// #include <nlohmann/detail/macro_scope.hpp>
177

178

179
#include <utility> // declval, pair
180
// #include <nlohmann/thirdparty/hedley/hedley.hpp>
181

182

183
/* Hedley - https://nemequ.github.io/hedley
184
 * Created by Evan Nemerson <[email protected]>
185
 *
186
 * To the extent possible under law, the author(s) have dedicated all
187
 * copyright and related and neighboring rights to this software to
188
 * the public domain worldwide. This software is distributed without
189
 * any warranty.
190
 *
191
 * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
192
 * SPDX-License-Identifier: CC0-1.0
193
 */
194

195
#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
196
#if defined(JSON_HEDLEY_VERSION)
197
    #undef JSON_HEDLEY_VERSION
198
#endif
199
#define JSON_HEDLEY_VERSION 15
200

201
#if defined(JSON_HEDLEY_STRINGIFY_EX)
202
    #undef JSON_HEDLEY_STRINGIFY_EX
203
#endif
204
#define JSON_HEDLEY_STRINGIFY_EX(x) #x
205

206
#if defined(JSON_HEDLEY_STRINGIFY)
207
    #undef JSON_HEDLEY_STRINGIFY
208
#endif
209
#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
210

211
#if defined(JSON_HEDLEY_CONCAT_EX)
212
    #undef JSON_HEDLEY_CONCAT_EX
213
#endif
214
#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
215

216
#if defined(JSON_HEDLEY_CONCAT)
217
    #undef JSON_HEDLEY_CONCAT
218
#endif
219
#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
220

221
#if defined(JSON_HEDLEY_CONCAT3_EX)
222
    #undef JSON_HEDLEY_CONCAT3_EX
223
#endif
224
#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
225

226
#if defined(JSON_HEDLEY_CONCAT3)
227
    #undef JSON_HEDLEY_CONCAT3
228
#endif
229
#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
230

231
#if defined(JSON_HEDLEY_VERSION_ENCODE)
232
    #undef JSON_HEDLEY_VERSION_ENCODE
233
#endif
234
#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
235

236
#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
237
    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
238
#endif
239
#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
240

241
#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
242
    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
243
#endif
244
#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
245

246
#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
247
    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
248
#endif
249
#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
250

251
#if defined(JSON_HEDLEY_GNUC_VERSION)
252
    #undef JSON_HEDLEY_GNUC_VERSION
253
#endif
254
#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
255
    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
256
#elif defined(__GNUC__)
257
    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
258
#endif
259

260
#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
261
    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
262
#endif
263
#if defined(JSON_HEDLEY_GNUC_VERSION)
264
    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
265
#else
266
    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
267
#endif
268

269
#if defined(JSON_HEDLEY_MSVC_VERSION)
270
    #undef JSON_HEDLEY_MSVC_VERSION
271
#endif
272
#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
273
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
274
#elif defined(_MSC_FULL_VER) && !defined(__ICL)
275
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
276
#elif defined(_MSC_VER) && !defined(__ICL)
277
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
278
#endif
279

280
#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
281
    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
282
#endif
283
#if !defined(JSON_HEDLEY_MSVC_VERSION)
284
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
285
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
286
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
287
#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
288
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
289
#else
290
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
291
#endif
292

293
#if defined(JSON_HEDLEY_INTEL_VERSION)
294
    #undef JSON_HEDLEY_INTEL_VERSION
295
#endif
296
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
297
    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
298
#elif defined(__INTEL_COMPILER) && !defined(__ICL)
299
    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
300
#endif
301

302
#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
303
    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
304
#endif
305
#if defined(JSON_HEDLEY_INTEL_VERSION)
306
    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
307
#else
308
    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
309
#endif
310

311
#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
312
    #undef JSON_HEDLEY_INTEL_CL_VERSION
313
#endif
314
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
315
    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
316
#endif
317

318
#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
319
    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
320
#endif
321
#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
322
    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
323
#else
324
    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
325
#endif
326

327
#if defined(JSON_HEDLEY_PGI_VERSION)
328
    #undef JSON_HEDLEY_PGI_VERSION
329
#endif
330
#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
331
    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
332
#endif
333

334
#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
335
    #undef JSON_HEDLEY_PGI_VERSION_CHECK
336
#endif
337
#if defined(JSON_HEDLEY_PGI_VERSION)
338
    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
339
#else
340
    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
341
#endif
342

343
#if defined(JSON_HEDLEY_SUNPRO_VERSION)
344
    #undef JSON_HEDLEY_SUNPRO_VERSION
345
#endif
346
#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
347
    #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)
348
#elif defined(__SUNPRO_C)
349
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
350
#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
351
    #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)
352
#elif defined(__SUNPRO_CC)
353
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
354
#endif
355

356
#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
357
    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
358
#endif
359
#if defined(JSON_HEDLEY_SUNPRO_VERSION)
360
    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
361
#else
362
    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
363
#endif
364

365
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
366
    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
367
#endif
368
#if defined(__EMSCRIPTEN__)
369
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
370
#endif
371

372
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
373
    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
374
#endif
375
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
376
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
377
#else
378
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
379
#endif
380

381
#if defined(JSON_HEDLEY_ARM_VERSION)
382
    #undef JSON_HEDLEY_ARM_VERSION
383
#endif
384
#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
385
    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
386
#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
387
    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
388
#endif
389

390
#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
391
    #undef JSON_HEDLEY_ARM_VERSION_CHECK
392
#endif
393
#if defined(JSON_HEDLEY_ARM_VERSION)
394
    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
395
#else
396
    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
397
#endif
398

399
#if defined(JSON_HEDLEY_IBM_VERSION)
400
    #undef JSON_HEDLEY_IBM_VERSION
401
#endif
402
#if defined(__ibmxl__)
403
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
404
#elif defined(__xlC__) && defined(__xlC_ver__)
405
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
406
#elif defined(__xlC__)
407
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
408
#endif
409

410
#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
411
    #undef JSON_HEDLEY_IBM_VERSION_CHECK
412
#endif
413
#if defined(JSON_HEDLEY_IBM_VERSION)
414
    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
415
#else
416
    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
417
#endif
418

419
#if defined(JSON_HEDLEY_TI_VERSION)
420
    #undef JSON_HEDLEY_TI_VERSION
421
#endif
422
#if \
423
    defined(__TI_COMPILER_VERSION__) && \
424
    ( \
425
      defined(__TMS470__) || defined(__TI_ARM__) || \
426
      defined(__MSP430__) || \
427
      defined(__TMS320C2000__) \
428
    )
429
#if (__TI_COMPILER_VERSION__ >= 16000000)
430
    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
431
#endif
432
#endif
433

434
#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
435
    #undef JSON_HEDLEY_TI_VERSION_CHECK
436
#endif
437
#if defined(JSON_HEDLEY_TI_VERSION)
438
    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
439
#else
440
    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
441
#endif
442

443
#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
444
    #undef JSON_HEDLEY_TI_CL2000_VERSION
445
#endif
446
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
447
    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
448
#endif
449

450
#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
451
    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
452
#endif
453
#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
454
    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
455
#else
456
    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
457
#endif
458

459
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
460
    #undef JSON_HEDLEY_TI_CL430_VERSION
461
#endif
462
#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
463
    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
464
#endif
465

466
#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
467
    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
468
#endif
469
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
470
    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
471
#else
472
    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
473
#endif
474

475
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
476
    #undef JSON_HEDLEY_TI_ARMCL_VERSION
477
#endif
478
#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
479
    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
480
#endif
481

482
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
483
    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
484
#endif
485
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
486
    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
487
#else
488
    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
489
#endif
490

491
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
492
    #undef JSON_HEDLEY_TI_CL6X_VERSION
493
#endif
494
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
495
    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
496
#endif
497

498
#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
499
    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
500
#endif
501
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
502
    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
503
#else
504
    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
505
#endif
506

507
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
508
    #undef JSON_HEDLEY_TI_CL7X_VERSION
509
#endif
510
#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
511
    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
512
#endif
513

514
#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
515
    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
516
#endif
517
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
518
    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
519
#else
520
    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
521
#endif
522

523
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
524
    #undef JSON_HEDLEY_TI_CLPRU_VERSION
525
#endif
526
#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
527
    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
528
#endif
529

530
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
531
    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
532
#endif
533
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
534
    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
535
#else
536
    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
537
#endif
538

539
#if defined(JSON_HEDLEY_CRAY_VERSION)
540
    #undef JSON_HEDLEY_CRAY_VERSION
541
#endif
542
#if defined(_CRAYC)
543
    #if defined(_RELEASE_PATCHLEVEL)
544
        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
545
    #else
546
        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
547
    #endif
548
#endif
549

550
#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
551
    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
552
#endif
553
#if defined(JSON_HEDLEY_CRAY_VERSION)
554
    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
555
#else
556
    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
557
#endif
558

559
#if defined(JSON_HEDLEY_IAR_VERSION)
560
    #undef JSON_HEDLEY_IAR_VERSION
561
#endif
562
#if defined(__IAR_SYSTEMS_ICC__)
563
    #if __VER__ > 1000
564
        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
565
    #else
566
        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
567
    #endif
568
#endif
569

570
#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
571
    #undef JSON_HEDLEY_IAR_VERSION_CHECK
572
#endif
573
#if defined(JSON_HEDLEY_IAR_VERSION)
574
    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
575
#else
576
    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
577
#endif
578

579
#if defined(JSON_HEDLEY_TINYC_VERSION)
580
    #undef JSON_HEDLEY_TINYC_VERSION
581
#endif
582
#if defined(__TINYC__)
583
    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
584
#endif
585

586
#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
587
    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
588
#endif
589
#if defined(JSON_HEDLEY_TINYC_VERSION)
590
    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
591
#else
592
    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
593
#endif
594

595
#if defined(JSON_HEDLEY_DMC_VERSION)
596
    #undef JSON_HEDLEY_DMC_VERSION
597
#endif
598
#if defined(__DMC__)
599
    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
600
#endif
601

602
#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
603
    #undef JSON_HEDLEY_DMC_VERSION_CHECK
604
#endif
605
#if defined(JSON_HEDLEY_DMC_VERSION)
606
    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
607
#else
608
    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
609
#endif
610

611
#if defined(JSON_HEDLEY_COMPCERT_VERSION)
612
    #undef JSON_HEDLEY_COMPCERT_VERSION
613
#endif
614
#if defined(__COMPCERT_VERSION__)
615
    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
616
#endif
617

618
#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
619
    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
620
#endif
621
#if defined(JSON_HEDLEY_COMPCERT_VERSION)
622
    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
623
#else
624
    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
625
#endif
626

627
#if defined(JSON_HEDLEY_PELLES_VERSION)
628
    #undef JSON_HEDLEY_PELLES_VERSION
629
#endif
630
#if defined(__POCC__)
631
    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
632
#endif
633

634
#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
635
    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
636
#endif
637
#if defined(JSON_HEDLEY_PELLES_VERSION)
638
    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
639
#else
640
    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
641
#endif
642

643
#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
644
    #undef JSON_HEDLEY_MCST_LCC_VERSION
645
#endif
646
#if defined(__LCC__) && defined(__LCC_MINOR__)
647
    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
648
#endif
649

650
#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
651
    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
652
#endif
653
#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
654
    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
655
#else
656
    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
657
#endif
658

659
#if defined(JSON_HEDLEY_GCC_VERSION)
660
    #undef JSON_HEDLEY_GCC_VERSION
661
#endif
662
#if \
663
    defined(JSON_HEDLEY_GNUC_VERSION) && \
664
    !defined(__clang__) && \
665
    !defined(JSON_HEDLEY_INTEL_VERSION) && \
666
    !defined(JSON_HEDLEY_PGI_VERSION) && \
667
    !defined(JSON_HEDLEY_ARM_VERSION) && \
668
    !defined(JSON_HEDLEY_CRAY_VERSION) && \
669
    !defined(JSON_HEDLEY_TI_VERSION) && \
670
    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
671
    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
672
    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
673
    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
674
    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
675
    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
676
    !defined(__COMPCERT__) && \
677
    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
678
    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
679
#endif
680

681
#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
682
    #undef JSON_HEDLEY_GCC_VERSION_CHECK
683
#endif
684
#if defined(JSON_HEDLEY_GCC_VERSION)
685
    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
686
#else
687
    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
688
#endif
689

690
#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
691
    #undef JSON_HEDLEY_HAS_ATTRIBUTE
692
#endif
693
#if \
694
  defined(__has_attribute) && \
695
  ( \
696
    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
697
  )
698
#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
699
#else
700
#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
701
#endif
702

703
#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
704
    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
705
#endif
706
#if defined(__has_attribute)
707
    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
708
#else
709
    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
710
#endif
711

712
#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
713
    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
714
#endif
715
#if defined(__has_attribute)
716
    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
717
#else
718
    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
719
#endif
720

721
#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
722
    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
723
#endif
724
#if \
725
    defined(__has_cpp_attribute) && \
726
    defined(__cplusplus) && \
727
    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
728
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
729
#else
730
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
731
#endif
732

733
#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
734
    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
735
#endif
736
#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
737
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
738
#elif \
739
    !defined(JSON_HEDLEY_PGI_VERSION) && \
740
    !defined(JSON_HEDLEY_IAR_VERSION) && \
741
    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
742
    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
743
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
744
#else
745
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
746
#endif
747

748
#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
749
    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
750
#endif
751
#if defined(__has_cpp_attribute) && defined(__cplusplus)
752
    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
753
#else
754
    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
755
#endif
756

757
#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
758
    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
759
#endif
760
#if defined(__has_cpp_attribute) && defined(__cplusplus)
761
    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
762
#else
763
    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
764
#endif
765

766
#if defined(JSON_HEDLEY_HAS_BUILTIN)
767
    #undef JSON_HEDLEY_HAS_BUILTIN
768
#endif
769
#if defined(__has_builtin)
770
    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
771
#else
772
    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
773
#endif
774

775
#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
776
    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
777
#endif
778
#if defined(__has_builtin)
779
    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
780
#else
781
    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
782
#endif
783

784
#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
785
    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
786
#endif
787
#if defined(__has_builtin)
788
    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
789
#else
790
    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
791
#endif
792

793
#if defined(JSON_HEDLEY_HAS_FEATURE)
794
    #undef JSON_HEDLEY_HAS_FEATURE
795
#endif
796
#if defined(__has_feature)
797
    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
798
#else
799
    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
800
#endif
801

802
#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
803
    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
804
#endif
805
#if defined(__has_feature)
806
    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
807
#else
808
    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
809
#endif
810

811
#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
812
    #undef JSON_HEDLEY_GCC_HAS_FEATURE
813
#endif
814
#if defined(__has_feature)
815
    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
816
#else
817
    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
818
#endif
819

820
#if defined(JSON_HEDLEY_HAS_EXTENSION)
821
    #undef JSON_HEDLEY_HAS_EXTENSION
822
#endif
823
#if defined(__has_extension)
824
    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
825
#else
826
    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
827
#endif
828

829
#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
830
    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
831
#endif
832
#if defined(__has_extension)
833
    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
834
#else
835
    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
836
#endif
837

838
#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
839
    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
840
#endif
841
#if defined(__has_extension)
842
    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
843
#else
844
    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
845
#endif
846

847
#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
848
    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
849
#endif
850
#if defined(__has_declspec_attribute)
851
    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
852
#else
853
    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
854
#endif
855

856
#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
857
    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
858
#endif
859
#if defined(__has_declspec_attribute)
860
    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
861
#else
862
    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
863
#endif
864

865
#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
866
    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
867
#endif
868
#if defined(__has_declspec_attribute)
869
    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
870
#else
871
    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
872
#endif
873

874
#if defined(JSON_HEDLEY_HAS_WARNING)
875
    #undef JSON_HEDLEY_HAS_WARNING
876
#endif
877
#if defined(__has_warning)
878
    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
879
#else
880
    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
881
#endif
882

883
#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
884
    #undef JSON_HEDLEY_GNUC_HAS_WARNING
885
#endif
886
#if defined(__has_warning)
887
    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
888
#else
889
    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
890
#endif
891

892
#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
893
    #undef JSON_HEDLEY_GCC_HAS_WARNING
894
#endif
895
#if defined(__has_warning)
896
    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
897
#else
898
    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
899
#endif
900

901
#if \
902
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
903
    defined(__clang__) || \
904
    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
905
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
906
    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
907
    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
908
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
909
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
910
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
911
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
912
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
913
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
914
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
915
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
916
    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
917
    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
918
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
919
    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
920
    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
921
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
922
    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
923
#else
924
    #define JSON_HEDLEY_PRAGMA(value)
925
#endif
926

927
#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
928
    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
929
#endif
930
#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
931
    #undef JSON_HEDLEY_DIAGNOSTIC_POP
932
#endif
933
#if defined(__clang__)
934
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
935
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
936
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
937
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
938
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
939
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
940
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
941
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
942
#elif \
943
    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
944
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
945
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
946
    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
947
#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
948
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
949
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
950
#elif \
951
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
952
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
953
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
954
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
955
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
956
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
957
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
958
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
959
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
960
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
961
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
962
#else
963
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
964
    #define JSON_HEDLEY_DIAGNOSTIC_POP
965
#endif
966

967
/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
968
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
969
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
970
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
971
#endif
972
#if defined(__cplusplus)
973
#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
974
#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
975
#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
976
#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
977
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
978
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
979
    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
980
    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
981
    xpr \
982
    JSON_HEDLEY_DIAGNOSTIC_POP
983
#      else
984
#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
985
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
986
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
987
    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
988
    xpr \
989
    JSON_HEDLEY_DIAGNOSTIC_POP
990
#      endif
991
#    else
992
#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
993
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
994
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
995
    xpr \
996
    JSON_HEDLEY_DIAGNOSTIC_POP
997
#    endif
998
#  endif
999
#endif
1000
#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1001
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
1002
#endif
1003

1004
#if defined(JSON_HEDLEY_CONST_CAST)
1005
    #undef JSON_HEDLEY_CONST_CAST
1006
#endif
1007
#if defined(__cplusplus)
1008
#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1009
#elif \
1010
  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1011
  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1012
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1013
#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1014
        JSON_HEDLEY_DIAGNOSTIC_PUSH \
1015
        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1016
        ((T) (expr)); \
1017
        JSON_HEDLEY_DIAGNOSTIC_POP \
1018
    }))
1019
#else
1020
#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1021
#endif
1022

1023
#if defined(JSON_HEDLEY_REINTERPRET_CAST)
1024
    #undef JSON_HEDLEY_REINTERPRET_CAST
1025
#endif
1026
#if defined(__cplusplus)
1027
    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1028
#else
1029
    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1030
#endif
1031

1032
#if defined(JSON_HEDLEY_STATIC_CAST)
1033
    #undef JSON_HEDLEY_STATIC_CAST
1034
#endif
1035
#if defined(__cplusplus)
1036
    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1037
#else
1038
    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1039
#endif
1040

1041
#if defined(JSON_HEDLEY_CPP_CAST)
1042
    #undef JSON_HEDLEY_CPP_CAST
1043
#endif
1044
#if defined(__cplusplus)
1045
#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1046
#    define JSON_HEDLEY_CPP_CAST(T, expr) \
1047
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1048
    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1049
    ((T) (expr)) \
1050
    JSON_HEDLEY_DIAGNOSTIC_POP
1051
#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1052
#    define JSON_HEDLEY_CPP_CAST(T, expr) \
1053
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
1054
    _Pragma("diag_suppress=Pe137") \
1055
    JSON_HEDLEY_DIAGNOSTIC_POP
1056
#  else
1057
#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1058
#  endif
1059
#else
1060
#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1061
#endif
1062

1063
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1064
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1065
#endif
1066
#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1067
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1068
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1069
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1070
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1071
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1072
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1073
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1074
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1075
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1076
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1077
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1078
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1079
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1080
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1081
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1082
#elif \
1083
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1084
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1085
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1086
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1087
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1088
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1089
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1090
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1091
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1092
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1093
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1094
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1095
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1096
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1097
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1098
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1099
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1100
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1101
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1102
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1103
#else
1104
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1105
#endif
1106

1107
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1108
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1109
#endif
1110
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1111
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1112
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1113
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1114
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1115
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1116
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1117
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1118
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1119
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1120
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1121
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1122
#elif \
1123
    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1124
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1125
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1126
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1127
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1128
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1129
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1130
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1131
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1132
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1133
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1134
#else
1135
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1136
#endif
1137

1138
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1139
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1140
#endif
1141
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1142
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1143
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1144
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1145
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1146
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1147
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1148
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1149
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1150
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1151
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1152
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1153
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1154
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1155
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1156
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1157
#elif \
1158
    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1159
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1160
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1161
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1162
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1163
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1164
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1165
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1166
#else
1167
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1168
#endif
1169

1170
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1171
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1172
#endif
1173
#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1174
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1175
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1176
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1177
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1178
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1179
#else
1180
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1181
#endif
1182

1183
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1184
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1185
#endif
1186
#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1187
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1188
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1189
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1190
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1191
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1192
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1193
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1194
#else
1195
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1196
#endif
1197

1198
#if defined(JSON_HEDLEY_DEPRECATED)
1199
    #undef JSON_HEDLEY_DEPRECATED
1200
#endif
1201
#if defined(JSON_HEDLEY_DEPRECATED_FOR)
1202
    #undef JSON_HEDLEY_DEPRECATED_FOR
1203
#endif
1204
#if \
1205
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1206
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1207
    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1208
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1209
#elif \
1210
    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1211
    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1212
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1213
    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1214
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1215
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1216
    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1217
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1218
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1219
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1220
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1221
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1222
    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1223
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1224
#elif defined(__cplusplus) && (__cplusplus >= 201402L)
1225
    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1226
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1227
#elif \
1228
    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1229
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1230
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1231
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1232
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1233
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1234
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1235
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1236
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1237
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1238
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1239
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1240
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1241
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1242
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1243
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1244
    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1245
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1246
#elif \
1247
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1248
    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1249
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1250
    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1251
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1252
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1253
    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1254
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1255
#else
1256
    #define JSON_HEDLEY_DEPRECATED(since)
1257
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1258
#endif
1259

1260
#if defined(JSON_HEDLEY_UNAVAILABLE)
1261
    #undef JSON_HEDLEY_UNAVAILABLE
1262
#endif
1263
#if \
1264
    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1265
    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1266
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1267
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1268
    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1269
#else
1270
    #define JSON_HEDLEY_UNAVAILABLE(available_since)
1271
#endif
1272

1273
#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1274
    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1275
#endif
1276
#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1277
    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1278
#endif
1279
#if \
1280
    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1281
    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1282
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1283
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1284
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1285
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1286
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1287
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1288
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1289
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1290
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1291
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1292
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1293
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1294
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1295
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1296
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1297
    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1298
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1299
#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1300
    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1301
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1302
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1303
    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1304
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1305
#elif defined(_Check_return_) /* SAL */
1306
    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1307
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1308
#else
1309
    #define JSON_HEDLEY_WARN_UNUSED_RESULT
1310
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1311
#endif
1312

1313
#if defined(JSON_HEDLEY_SENTINEL)
1314
    #undef JSON_HEDLEY_SENTINEL
1315
#endif
1316
#if \
1317
    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1318
    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1319
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1320
    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1321
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1322
    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1323
#else
1324
    #define JSON_HEDLEY_SENTINEL(position)
1325
#endif
1326

1327
#if defined(JSON_HEDLEY_NO_RETURN)
1328
    #undef JSON_HEDLEY_NO_RETURN
1329
#endif
1330
#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1331
    #define JSON_HEDLEY_NO_RETURN __noreturn
1332
#elif \
1333
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1334
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1335
    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1336
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1337
    #define JSON_HEDLEY_NO_RETURN _Noreturn
1338
#elif defined(__cplusplus) && (__cplusplus >= 201103L)
1339
    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1340
#elif \
1341
    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1342
    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1343
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1344
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1345
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1346
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1347
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1348
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1349
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1350
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1351
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1352
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1353
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1354
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1355
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1356
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1357
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1358
    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1359
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1360
    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1361
#elif \
1362
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1363
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1364
    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1365
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1366
    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1367
#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1368
    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1369
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1370
    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1371
#else
1372
    #define JSON_HEDLEY_NO_RETURN
1373
#endif
1374

1375
#if defined(JSON_HEDLEY_NO_ESCAPE)
1376
    #undef JSON_HEDLEY_NO_ESCAPE
1377
#endif
1378
#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1379
    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1380
#else
1381
    #define JSON_HEDLEY_NO_ESCAPE
1382
#endif
1383

1384
#if defined(JSON_HEDLEY_UNREACHABLE)
1385
    #undef JSON_HEDLEY_UNREACHABLE
1386
#endif
1387
#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1388
    #undef JSON_HEDLEY_UNREACHABLE_RETURN
1389
#endif
1390
#if defined(JSON_HEDLEY_ASSUME)
1391
    #undef JSON_HEDLEY_ASSUME
1392
#endif
1393
#if \
1394
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1395
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1396
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1397
    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1398
#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1399
    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1400
#elif \
1401
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1402
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1403
    #if defined(__cplusplus)
1404
        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1405
    #else
1406
        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1407
    #endif
1408
#endif
1409
#if \
1410
    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1411
    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1412
    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1413
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1414
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1415
    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1416
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1417
    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1418
#elif defined(JSON_HEDLEY_ASSUME)
1419
    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1420
#endif
1421
#if !defined(JSON_HEDLEY_ASSUME)
1422
    #if defined(JSON_HEDLEY_UNREACHABLE)
1423
        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1424
    #else
1425
        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1426
    #endif
1427
#endif
1428
#if defined(JSON_HEDLEY_UNREACHABLE)
1429
    #if  \
1430
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1431
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1432
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1433
    #else
1434
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1435
    #endif
1436
#else
1437
    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1438
#endif
1439
#if !defined(JSON_HEDLEY_UNREACHABLE)
1440
    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1441
#endif
1442

1443
JSON_HEDLEY_DIAGNOSTIC_PUSH
1444
#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1445
    #pragma clang diagnostic ignored "-Wpedantic"
1446
#endif
1447
#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1448
    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1449
#endif
1450
#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1451
    #if defined(__clang__)
1452
        #pragma clang diagnostic ignored "-Wvariadic-macros"
1453
    #elif defined(JSON_HEDLEY_GCC_VERSION)
1454
        #pragma GCC diagnostic ignored "-Wvariadic-macros"
1455
    #endif
1456
#endif
1457
#if defined(JSON_HEDLEY_NON_NULL)
1458
    #undef JSON_HEDLEY_NON_NULL
1459
#endif
1460
#if \
1461
    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1462
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1463
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1464
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1465
    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1466
#else
1467
    #define JSON_HEDLEY_NON_NULL(...)
1468
#endif
1469
JSON_HEDLEY_DIAGNOSTIC_POP
1470

1471
#if defined(JSON_HEDLEY_PRINTF_FORMAT)
1472
    #undef JSON_HEDLEY_PRINTF_FORMAT
1473
#endif
1474
#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1475
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1476
#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1477
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1478
#elif \
1479
    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1480
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1481
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1482
    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1483
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1484
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1485
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1486
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1487
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1488
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1489
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1490
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1491
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1492
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1493
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1494
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1495
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1496
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1497
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1498
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1499
#else
1500
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1501
#endif
1502

1503
#if defined(JSON_HEDLEY_CONSTEXPR)
1504
    #undef JSON_HEDLEY_CONSTEXPR
1505
#endif
1506
#if defined(__cplusplus)
1507
    #if __cplusplus >= 201103L
1508
        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1509
    #endif
1510
#endif
1511
#if !defined(JSON_HEDLEY_CONSTEXPR)
1512
    #define JSON_HEDLEY_CONSTEXPR
1513
#endif
1514

1515
#if defined(JSON_HEDLEY_PREDICT)
1516
    #undef JSON_HEDLEY_PREDICT
1517
#endif
1518
#if defined(JSON_HEDLEY_LIKELY)
1519
    #undef JSON_HEDLEY_LIKELY
1520
#endif
1521
#if defined(JSON_HEDLEY_UNLIKELY)
1522
    #undef JSON_HEDLEY_UNLIKELY
1523
#endif
1524
#if defined(JSON_HEDLEY_UNPREDICTABLE)
1525
    #undef JSON_HEDLEY_UNPREDICTABLE
1526
#endif
1527
#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1528
    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1529
#endif
1530
#if \
1531
  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1532
  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1533
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1534
#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
1535
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
1536
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
1537
#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
1538
#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
1539
#elif \
1540
  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1541
  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1542
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1543
  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1544
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1545
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1546
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1547
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1548
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1549
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1550
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1551
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1552
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1553
  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1554
  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1555
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1556
#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1557
    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1558
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1559
    (__extension__ ({ \
1560
        double hedley_probability_ = (probability); \
1561
        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1562
    }))
1563
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1564
    (__extension__ ({ \
1565
        double hedley_probability_ = (probability); \
1566
        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1567
    }))
1568
#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
1569
#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1570
#else
1571
#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1572
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1573
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1574
#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1575
#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1576
#endif
1577
#if !defined(JSON_HEDLEY_UNPREDICTABLE)
1578
    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1579
#endif
1580

1581
#if defined(JSON_HEDLEY_MALLOC)
1582
    #undef JSON_HEDLEY_MALLOC
1583
#endif
1584
#if \
1585
    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1586
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1587
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1588
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1589
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1590
    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1591
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1592
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1593
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1594
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1595
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1596
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1597
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1598
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1599
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1600
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1601
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1602
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1603
    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1604
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1605
    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1606
#elif \
1607
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1608
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1609
    #define JSON_HEDLEY_MALLOC __declspec(restrict)
1610
#else
1611
    #define JSON_HEDLEY_MALLOC
1612
#endif
1613

1614
#if defined(JSON_HEDLEY_PURE)
1615
    #undef JSON_HEDLEY_PURE
1616
#endif
1617
#if \
1618
  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1619
  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1620
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1621
  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1622
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1623
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1624
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1625
  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1626
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1627
  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1628
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1629
  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1630
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1631
  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1632
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1633
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1634
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1635
  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1636
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1637
#  define JSON_HEDLEY_PURE __attribute__((__pure__))
1638
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1639
#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1640
#elif defined(__cplusplus) && \
1641
    ( \
1642
      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1643
      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1644
      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1645
    )
1646
#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1647
#else
1648
#  define JSON_HEDLEY_PURE
1649
#endif
1650

1651
#if defined(JSON_HEDLEY_CONST)
1652
    #undef JSON_HEDLEY_CONST
1653
#endif
1654
#if \
1655
    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1656
    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1657
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1658
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1659
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1660
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1661
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1662
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1663
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1664
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1665
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1666
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1667
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1668
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1669
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1670
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1671
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1672
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1673
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1674
    #define JSON_HEDLEY_CONST __attribute__((__const__))
1675
#elif \
1676
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1677
    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1678
#else
1679
    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1680
#endif
1681

1682
#if defined(JSON_HEDLEY_RESTRICT)
1683
    #undef JSON_HEDLEY_RESTRICT
1684
#endif
1685
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1686
    #define JSON_HEDLEY_RESTRICT restrict
1687
#elif \
1688
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1689
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1690
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1691
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1692
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1693
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1694
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1695
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1696
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1697
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1698
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1699
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1700
    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1701
    defined(__clang__) || \
1702
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1703
    #define JSON_HEDLEY_RESTRICT __restrict
1704
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1705
    #define JSON_HEDLEY_RESTRICT _Restrict
1706
#else
1707
    #define JSON_HEDLEY_RESTRICT
1708
#endif
1709

1710
#if defined(JSON_HEDLEY_INLINE)
1711
    #undef JSON_HEDLEY_INLINE
1712
#endif
1713
#if \
1714
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1715
    (defined(__cplusplus) && (__cplusplus >= 199711L))
1716
    #define JSON_HEDLEY_INLINE inline
1717
#elif \
1718
    defined(JSON_HEDLEY_GCC_VERSION) || \
1719
    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1720
    #define JSON_HEDLEY_INLINE __inline__
1721
#elif \
1722
    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1723
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1724
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1725
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1726
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1727
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1728
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1729
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1730
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1731
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1732
    #define JSON_HEDLEY_INLINE __inline
1733
#else
1734
    #define JSON_HEDLEY_INLINE
1735
#endif
1736

1737
#if defined(JSON_HEDLEY_ALWAYS_INLINE)
1738
    #undef JSON_HEDLEY_ALWAYS_INLINE
1739
#endif
1740
#if \
1741
  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1742
  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1743
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1744
  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1745
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1746
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1747
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1748
  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1749
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1750
  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1751
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1752
  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1753
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1754
  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1755
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1756
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1757
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1758
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1759
  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1760
#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1761
#elif \
1762
  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1763
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1764
#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1765
#elif defined(__cplusplus) && \
1766
    ( \
1767
      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1768
      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1769
      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1770
      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1771
      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1772
      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1773
    )
1774
#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1775
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1776
#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1777
#else
1778
#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1779
#endif
1780

1781
#if defined(JSON_HEDLEY_NEVER_INLINE)
1782
    #undef JSON_HEDLEY_NEVER_INLINE
1783
#endif
1784
#if \
1785
    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1786
    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1787
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1788
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1789
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1790
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1791
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1792
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1793
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1794
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1795
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1796
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1797
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1798
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1799
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1800
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1801
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1802
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1803
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1804
    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1805
#elif \
1806
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1807
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1808
    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1809
#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1810
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1811
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1812
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1813
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1814
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1815
#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1816
    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1817
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1818
    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1819
#else
1820
    #define JSON_HEDLEY_NEVER_INLINE
1821
#endif
1822

1823
#if defined(JSON_HEDLEY_PRIVATE)
1824
    #undef JSON_HEDLEY_PRIVATE
1825
#endif
1826
#if defined(JSON_HEDLEY_PUBLIC)
1827
    #undef JSON_HEDLEY_PUBLIC
1828
#endif
1829
#if defined(JSON_HEDLEY_IMPORT)
1830
    #undef JSON_HEDLEY_IMPORT
1831
#endif
1832
#if defined(_WIN32) || defined(__CYGWIN__)
1833
#  define JSON_HEDLEY_PRIVATE
1834
#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
1835
#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
1836
#else
1837
#  if \
1838
    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1839
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1840
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1841
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1842
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1843
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1844
    ( \
1845
      defined(__TI_EABI__) && \
1846
      ( \
1847
        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1848
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1849
      ) \
1850
    ) || \
1851
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1852
#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1853
#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
1854
#  else
1855
#    define JSON_HEDLEY_PRIVATE
1856
#    define JSON_HEDLEY_PUBLIC
1857
#  endif
1858
#  define JSON_HEDLEY_IMPORT    extern
1859
#endif
1860

1861
#if defined(JSON_HEDLEY_NO_THROW)
1862
    #undef JSON_HEDLEY_NO_THROW
1863
#endif
1864
#if \
1865
    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1866
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1867
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1868
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1869
    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1870
#elif \
1871
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1872
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1873
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1874
    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1875
#else
1876
    #define JSON_HEDLEY_NO_THROW
1877
#endif
1878

1879
#if defined(JSON_HEDLEY_FALL_THROUGH)
1880
    #undef JSON_HEDLEY_FALL_THROUGH
1881
#endif
1882
#if \
1883
    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1884
    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
1885
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1886
    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1887
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1888
    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1889
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1890
    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1891
#elif defined(__fallthrough) /* SAL */
1892
    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1893
#else
1894
    #define JSON_HEDLEY_FALL_THROUGH
1895
#endif
1896

1897
#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1898
    #undef JSON_HEDLEY_RETURNS_NON_NULL
1899
#endif
1900
#if \
1901
    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1902
    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1903
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1904
    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1905
#elif defined(_Ret_notnull_) /* SAL */
1906
    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1907
#else
1908
    #define JSON_HEDLEY_RETURNS_NON_NULL
1909
#endif
1910

1911
#if defined(JSON_HEDLEY_ARRAY_PARAM)
1912
    #undef JSON_HEDLEY_ARRAY_PARAM
1913
#endif
1914
#if \
1915
    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1916
    !defined(__STDC_NO_VLA__) && \
1917
    !defined(__cplusplus) && \
1918
    !defined(JSON_HEDLEY_PGI_VERSION) && \
1919
    !defined(JSON_HEDLEY_TINYC_VERSION)
1920
    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1921
#else
1922
    #define JSON_HEDLEY_ARRAY_PARAM(name)
1923
#endif
1924

1925
#if defined(JSON_HEDLEY_IS_CONSTANT)
1926
    #undef JSON_HEDLEY_IS_CONSTANT
1927
#endif
1928
#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1929
    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1930
#endif
1931
/* JSON_HEDLEY_IS_CONSTEXPR_ is for
1932
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
1933
#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1934
    #undef JSON_HEDLEY_IS_CONSTEXPR_
1935
#endif
1936
#if \
1937
    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1938
    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1939
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1940
    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1941
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1942
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1943
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1944
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1945
    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1946
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1947
    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1948
#endif
1949
#if !defined(__cplusplus)
1950
#  if \
1951
       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1952
       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1953
       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1954
       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1955
       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1956
       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1957
       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1958
#if defined(__INTPTR_TYPE__)
1959
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1960
#else
1961
    #include <stdint.h>
1962
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1963
#endif
1964
#  elif \
1965
       ( \
1966
          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1967
          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1968
          !defined(JSON_HEDLEY_PGI_VERSION) && \
1969
          !defined(JSON_HEDLEY_IAR_VERSION)) || \
1970
       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1971
       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1972
       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1973
       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1974
       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1975
#if defined(__INTPTR_TYPE__)
1976
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1977
#else
1978
    #include <stdint.h>
1979
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1980
#endif
1981
#  elif \
1982
       defined(JSON_HEDLEY_GCC_VERSION) || \
1983
       defined(JSON_HEDLEY_INTEL_VERSION) || \
1984
       defined(JSON_HEDLEY_TINYC_VERSION) || \
1985
       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1986
       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1987
       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1988
       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1989
       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1990
       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1991
       defined(__clang__)
1992
#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1993
        sizeof(void) != \
1994
        sizeof(*( \
1995
                  1 ? \
1996
                  ((void*) ((expr) * 0L) ) : \
1997
((struct { char v[sizeof(void) * 2]; } *) 1) \
1998
                ) \
1999
              ) \
2000
                                            )
2001
#  endif
2002
#endif
2003
#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2004
    #if !defined(JSON_HEDLEY_IS_CONSTANT)
2005
        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
2006
    #endif
2007
    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2008
#else
2009
    #if !defined(JSON_HEDLEY_IS_CONSTANT)
2010
        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2011
    #endif
2012
    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2013
#endif
2014

2015
#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2016
    #undef JSON_HEDLEY_BEGIN_C_DECLS
2017
#endif
2018
#if defined(JSON_HEDLEY_END_C_DECLS)
2019
    #undef JSON_HEDLEY_END_C_DECLS
2020
#endif
2021
#if defined(JSON_HEDLEY_C_DECL)
2022
    #undef JSON_HEDLEY_C_DECL
2023
#endif
2024
#if defined(__cplusplus)
2025
    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2026
    #define JSON_HEDLEY_END_C_DECLS }
2027
    #define JSON_HEDLEY_C_DECL extern "C"
2028
#else
2029
    #define JSON_HEDLEY_BEGIN_C_DECLS
2030
    #define JSON_HEDLEY_END_C_DECLS
2031
    #define JSON_HEDLEY_C_DECL
2032
#endif
2033

2034
#if defined(JSON_HEDLEY_STATIC_ASSERT)
2035
    #undef JSON_HEDLEY_STATIC_ASSERT
2036
#endif
2037
#if \
2038
  !defined(__cplusplus) && ( \
2039
      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2040
      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2041
      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2042
      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2043
      defined(_Static_assert) \
2044
    )
2045
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2046
#elif \
2047
  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2048
  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2049
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2050
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2051
#else
2052
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2053
#endif
2054

2055
#if defined(JSON_HEDLEY_NULL)
2056
    #undef JSON_HEDLEY_NULL
2057
#endif
2058
#if defined(__cplusplus)
2059
    #if __cplusplus >= 201103L
2060
        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2061
    #elif defined(NULL)
2062
        #define JSON_HEDLEY_NULL NULL
2063
    #else
2064
        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2065
    #endif
2066
#elif defined(NULL)
2067
    #define JSON_HEDLEY_NULL NULL
2068
#else
2069
    #define JSON_HEDLEY_NULL ((void*) 0)
2070
#endif
2071

2072
#if defined(JSON_HEDLEY_MESSAGE)
2073
    #undef JSON_HEDLEY_MESSAGE
2074
#endif
2075
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2076
#  define JSON_HEDLEY_MESSAGE(msg) \
2077
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2078
    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2079
    JSON_HEDLEY_PRAGMA(message msg) \
2080
    JSON_HEDLEY_DIAGNOSTIC_POP
2081
#elif \
2082
  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2083
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2084
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2085
#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2086
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2087
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2088
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2089
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2090
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2091
#else
2092
#  define JSON_HEDLEY_MESSAGE(msg)
2093
#endif
2094

2095
#if defined(JSON_HEDLEY_WARNING)
2096
    #undef JSON_HEDLEY_WARNING
2097
#endif
2098
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2099
#  define JSON_HEDLEY_WARNING(msg) \
2100
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2101
    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2102
    JSON_HEDLEY_PRAGMA(clang warning msg) \
2103
    JSON_HEDLEY_DIAGNOSTIC_POP
2104
#elif \
2105
  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2106
  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2107
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2108
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2109
#elif \
2110
  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2111
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2112
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2113
#else
2114
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2115
#endif
2116

2117
#if defined(JSON_HEDLEY_REQUIRE)
2118
    #undef JSON_HEDLEY_REQUIRE
2119
#endif
2120
#if defined(JSON_HEDLEY_REQUIRE_MSG)
2121
    #undef JSON_HEDLEY_REQUIRE_MSG
2122
#endif
2123
#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2124
#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2125
#    define JSON_HEDLEY_REQUIRE(expr) \
2126
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2127
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2128
    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2129
    JSON_HEDLEY_DIAGNOSTIC_POP
2130
#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2131
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
2132
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2133
    __attribute__((diagnose_if(!(expr), msg, "error"))) \
2134
    JSON_HEDLEY_DIAGNOSTIC_POP
2135
#  else
2136
#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2137
#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2138
#  endif
2139
#else
2140
#  define JSON_HEDLEY_REQUIRE(expr)
2141
#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2142
#endif
2143

2144
#if defined(JSON_HEDLEY_FLAGS)
2145
    #undef JSON_HEDLEY_FLAGS
2146
#endif
2147
#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2148
    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2149
#else
2150
    #define JSON_HEDLEY_FLAGS
2151
#endif
2152

2153
#if defined(JSON_HEDLEY_FLAGS_CAST)
2154
    #undef JSON_HEDLEY_FLAGS_CAST
2155
#endif
2156
#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2157
#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2158
        JSON_HEDLEY_DIAGNOSTIC_PUSH \
2159
        _Pragma("warning(disable:188)") \
2160
        ((T) (expr)); \
2161
        JSON_HEDLEY_DIAGNOSTIC_POP \
2162
    }))
2163
#else
2164
#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2165
#endif
2166

2167
#if defined(JSON_HEDLEY_EMPTY_BASES)
2168
    #undef JSON_HEDLEY_EMPTY_BASES
2169
#endif
2170
#if \
2171
    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2172
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2173
    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2174
#else
2175
    #define JSON_HEDLEY_EMPTY_BASES
2176
#endif
2177

2178
/* Remaining macros are deprecated. */
2179

2180
#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2181
    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2182
#endif
2183
#if defined(__clang__)
2184
    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2185
#else
2186
    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2187
#endif
2188

2189
#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2190
    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2191
#endif
2192
#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2193

2194
#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2195
    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2196
#endif
2197
#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2198

2199
#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2200
    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2201
#endif
2202
#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2203

2204
#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2205
    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2206
#endif
2207
#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2208

2209
#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2210
    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2211
#endif
2212
#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2213

2214
#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2215
    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2216
#endif
2217
#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2218

2219
#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2220
    #undef JSON_HEDLEY_CLANG_HAS_WARNING
2221
#endif
2222
#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2223

2224
#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2225

2226
// #include <nlohmann/detail/meta/detected.hpp>
2227

2228

2229
#include <type_traits>
2230

2231
// #include <nlohmann/detail/meta/void_t.hpp>
2232

2233

2234
namespace nlohmann
2235
{
2236
namespace detail
2237
{
2238
template<typename ...Ts> struct make_void
2239
{
2240
    using type = void;
2241
};
2242
template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
2243
} // namespace detail
2244
}  // namespace nlohmann
2245

2246

2247
// https://en.cppreference.com/w/cpp/experimental/is_detected
2248
namespace nlohmann
2249
{
2250
namespace detail
2251
{
2252
struct nonesuch
2253
{
2254
    nonesuch() = delete;
2255
    ~nonesuch() = delete;
2256
    nonesuch(nonesuch const&) = delete;
2257
    nonesuch(nonesuch const&&) = delete;
2258
    void operator=(nonesuch const&) = delete;
2259
    void operator=(nonesuch&&) = delete;
2260
};
2261

2262
template<class Default,
2263
         class AlwaysVoid,
2264
         template<class...> class Op,
2265
         class... Args>
2266
struct detector
2267
{
2268
    using value_t = std::false_type;
2269
    using type = Default;
2270
};
2271

2272
template<class Default, template<class...> class Op, class... Args>
2273
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2274
{
2275
    using value_t = std::true_type;
2276
    using type = Op<Args...>;
2277
};
2278

2279
template<template<class...> class Op, class... Args>
2280
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
2281

2282
template<template<class...> class Op, class... Args>
2283
struct is_detected_lazy : is_detected<Op, Args...> { };
2284

2285
template<template<class...> class Op, class... Args>
2286
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
2287

2288
template<class Default, template<class...> class Op, class... Args>
2289
using detected_or = detector<Default, void, Op, Args...>;
2290

2291
template<class Default, template<class...> class Op, class... Args>
2292
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
2293

2294
template<class Expected, template<class...> class Op, class... Args>
2295
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2296

2297
template<class To, template<class...> class Op, class... Args>
2298
using is_detected_convertible =
2299
    std::is_convertible<detected_t<Op, Args...>, To>;
2300
}  // namespace detail
2301
}  // namespace nlohmann
2302

2303

2304
// This file contains all internal macro definitions
2305
// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2306

2307
// exclude unsupported compilers
2308
#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2309
    #if defined(__clang__)
2310
        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2311
            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2312
        #endif
2313
    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2314
        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2315
            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2316
        #endif
2317
    #endif
2318
#endif
2319

2320
// C++ language standard detection
2321
// if the user manually specified the used c++ version this is skipped
2322
#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2323
    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2324
        #define JSON_HAS_CPP_20
2325
        #define JSON_HAS_CPP_17
2326
        #define JSON_HAS_CPP_14
2327
    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2328
        #define JSON_HAS_CPP_17
2329
        #define JSON_HAS_CPP_14
2330
    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2331
        #define JSON_HAS_CPP_14
2332
    #endif
2333
    // the cpp 11 flag is always specified because it is the minimal required version
2334
    #define JSON_HAS_CPP_11
2335
#endif
2336

2337
#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
2338
    #ifdef JSON_HAS_CPP_17
2339
        #if defined(__cpp_lib_filesystem)
2340
            #define JSON_HAS_FILESYSTEM 1
2341
        #elif defined(__cpp_lib_experimental_filesystem)
2342
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2343
        #elif !defined(__has_include)
2344
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2345
        #elif __has_include(<filesystem>)
2346
            #define JSON_HAS_FILESYSTEM 1
2347
        #elif __has_include(<experimental/filesystem>)
2348
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2349
        #endif
2350

2351
        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
2352
        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
2353
            #undef JSON_HAS_FILESYSTEM
2354
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2355
        #endif
2356

2357
        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
2358
        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
2359
            #undef JSON_HAS_FILESYSTEM
2360
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2361
        #endif
2362

2363
        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
2364
        #if defined(__clang_major__) && __clang_major__ < 7
2365
            #undef JSON_HAS_FILESYSTEM
2366
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2367
        #endif
2368

2369
        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
2370
        #if defined(_MSC_VER) && _MSC_VER < 1940
2371
            #undef JSON_HAS_FILESYSTEM
2372
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2373
        #endif
2374

2375
        // no filesystem support before iOS 13
2376
        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
2377
            #undef JSON_HAS_FILESYSTEM
2378
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2379
        #endif
2380

2381
        // no filesystem support before macOS Catalina
2382
        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
2383
            #undef JSON_HAS_FILESYSTEM
2384
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2385
        #endif
2386
    #endif
2387
#endif
2388

2389
#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2390
    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
2391
#endif
2392

2393
#ifndef JSON_HAS_FILESYSTEM
2394
    #define JSON_HAS_FILESYSTEM 0
2395
#endif
2396

2397
// disable documentation warnings on clang
2398
#if defined(__clang__)
2399
    #pragma clang diagnostic push
2400
    #pragma clang diagnostic ignored "-Wdocumentation"
2401
    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2402
#endif
2403

2404
// allow disabling exceptions
2405
#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2406
    #define JSON_THROW(exception) throw exception
2407
    #define JSON_TRY try
2408
    #define JSON_CATCH(exception) catch(exception)
2409
    #define JSON_INTERNAL_CATCH(exception) catch(exception)
2410
#else
2411
    #include <cstdlib>
2412
    #define JSON_THROW(exception) std::abort()
2413
    #define JSON_TRY if(true)
2414
    #define JSON_CATCH(exception) if(false)
2415
    #define JSON_INTERNAL_CATCH(exception) if(false)
2416
#endif
2417

2418
// override exception macros
2419
#if defined(JSON_THROW_USER)
2420
    #undef JSON_THROW
2421
    #define JSON_THROW JSON_THROW_USER
2422
#endif
2423
#if defined(JSON_TRY_USER)
2424
    #undef JSON_TRY
2425
    #define JSON_TRY JSON_TRY_USER
2426
#endif
2427
#if defined(JSON_CATCH_USER)
2428
    #undef JSON_CATCH
2429
    #define JSON_CATCH JSON_CATCH_USER
2430
    #undef JSON_INTERNAL_CATCH
2431
    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2432
#endif
2433
#if defined(JSON_INTERNAL_CATCH_USER)
2434
    #undef JSON_INTERNAL_CATCH
2435
    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2436
#endif
2437

2438
// allow overriding assert
2439
#if !defined(JSON_ASSERT)
2440
    #include <cassert> // assert
2441
    #define JSON_ASSERT(x) assert(x)
2442
#endif
2443

2444
// allow to access some private functions (needed by the test suite)
2445
#if defined(JSON_TESTS_PRIVATE)
2446
    #define JSON_PRIVATE_UNLESS_TESTED public
2447
#else
2448
    #define JSON_PRIVATE_UNLESS_TESTED private
2449
#endif
2450

2451
/*!
2452
@brief macro to briefly define a mapping between an enum and JSON
2453
@def NLOHMANN_JSON_SERIALIZE_ENUM
2454
@since version 3.4.0
2455
*/
2456
#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
2457
    template<typename BasicJsonType>                                                            \
2458
    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
2459
    {                                                                                           \
2460
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2461
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2462
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
2463
                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
2464
        {                                                                                       \
2465
            return ej_pair.first == e;                                                          \
2466
        });                                                                                     \
2467
        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
2468
    }                                                                                           \
2469
    template<typename BasicJsonType>                                                            \
2470
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
2471
    {                                                                                           \
2472
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2473
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2474
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
2475
                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2476
        {                                                                                       \
2477
            return ej_pair.second == j;                                                         \
2478
        });                                                                                     \
2479
        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
2480
    }
2481

2482
// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2483
// may be removed in the future once the class is split.
2484

2485
#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
2486
    template<template<typename, typename, typename...> class ObjectType,   \
2487
             template<typename, typename...> class ArrayType,              \
2488
             class StringType, class BooleanType, class NumberIntegerType, \
2489
             class NumberUnsignedType, class NumberFloatType,              \
2490
             template<typename> class AllocatorType,                       \
2491
             template<typename, typename = void> class JSONSerializer,     \
2492
             class BinaryType>
2493

2494
#define NLOHMANN_BASIC_JSON_TPL                                            \
2495
    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
2496
    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
2497
    AllocatorType, JSONSerializer, BinaryType>
2498

2499
// Macros to simplify conversion from/to types
2500

2501
#define NLOHMANN_JSON_EXPAND( x ) x
2502
#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
2503
#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2504
        NLOHMANN_JSON_PASTE64, \
2505
        NLOHMANN_JSON_PASTE63, \
2506
        NLOHMANN_JSON_PASTE62, \
2507
        NLOHMANN_JSON_PASTE61, \
2508
        NLOHMANN_JSON_PASTE60, \
2509
        NLOHMANN_JSON_PASTE59, \
2510
        NLOHMANN_JSON_PASTE58, \
2511
        NLOHMANN_JSON_PASTE57, \
2512
        NLOHMANN_JSON_PASTE56, \
2513
        NLOHMANN_JSON_PASTE55, \
2514
        NLOHMANN_JSON_PASTE54, \
2515
        NLOHMANN_JSON_PASTE53, \
2516
        NLOHMANN_JSON_PASTE52, \
2517
        NLOHMANN_JSON_PASTE51, \
2518
        NLOHMANN_JSON_PASTE50, \
2519
        NLOHMANN_JSON_PASTE49, \
2520
        NLOHMANN_JSON_PASTE48, \
2521
        NLOHMANN_JSON_PASTE47, \
2522
        NLOHMANN_JSON_PASTE46, \
2523
        NLOHMANN_JSON_PASTE45, \
2524
        NLOHMANN_JSON_PASTE44, \
2525
        NLOHMANN_JSON_PASTE43, \
2526
        NLOHMANN_JSON_PASTE42, \
2527
        NLOHMANN_JSON_PASTE41, \
2528
        NLOHMANN_JSON_PASTE40, \
2529
        NLOHMANN_JSON_PASTE39, \
2530
        NLOHMANN_JSON_PASTE38, \
2531
        NLOHMANN_JSON_PASTE37, \
2532
        NLOHMANN_JSON_PASTE36, \
2533
        NLOHMANN_JSON_PASTE35, \
2534
        NLOHMANN_JSON_PASTE34, \
2535
        NLOHMANN_JSON_PASTE33, \
2536
        NLOHMANN_JSON_PASTE32, \
2537
        NLOHMANN_JSON_PASTE31, \
2538
        NLOHMANN_JSON_PASTE30, \
2539
        NLOHMANN_JSON_PASTE29, \
2540
        NLOHMANN_JSON_PASTE28, \
2541
        NLOHMANN_JSON_PASTE27, \
2542
        NLOHMANN_JSON_PASTE26, \
2543
        NLOHMANN_JSON_PASTE25, \
2544
        NLOHMANN_JSON_PASTE24, \
2545
        NLOHMANN_JSON_PASTE23, \
2546
        NLOHMANN_JSON_PASTE22, \
2547
        NLOHMANN_JSON_PASTE21, \
2548
        NLOHMANN_JSON_PASTE20, \
2549
        NLOHMANN_JSON_PASTE19, \
2550
        NLOHMANN_JSON_PASTE18, \
2551
        NLOHMANN_JSON_PASTE17, \
2552
        NLOHMANN_JSON_PASTE16, \
2553
        NLOHMANN_JSON_PASTE15, \
2554
        NLOHMANN_JSON_PASTE14, \
2555
        NLOHMANN_JSON_PASTE13, \
2556
        NLOHMANN_JSON_PASTE12, \
2557
        NLOHMANN_JSON_PASTE11, \
2558
        NLOHMANN_JSON_PASTE10, \
2559
        NLOHMANN_JSON_PASTE9, \
2560
        NLOHMANN_JSON_PASTE8, \
2561
        NLOHMANN_JSON_PASTE7, \
2562
        NLOHMANN_JSON_PASTE6, \
2563
        NLOHMANN_JSON_PASTE5, \
2564
        NLOHMANN_JSON_PASTE4, \
2565
        NLOHMANN_JSON_PASTE3, \
2566
        NLOHMANN_JSON_PASTE2, \
2567
        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2568
#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2569
#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2570
#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2571
#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2572
#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2573
#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)
2574
#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)
2575
#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)
2576
#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)
2577
#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)
2578
#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)
2579
#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)
2580
#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)
2581
#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)
2582
#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)
2583
#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)
2584
#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)
2585
#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)
2586
#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)
2587
#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)
2588
#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)
2589
#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)
2590
#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)
2591
#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)
2592
#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)
2593
#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)
2594
#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)
2595
#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)
2596
#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)
2597
#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)
2598
#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)
2599
#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)
2600
#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)
2601
#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)
2602
#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)
2603
#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)
2604
#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)
2605
#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)
2606
#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)
2607
#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)
2608
#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)
2609
#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)
2610
#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)
2611
#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)
2612
#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)
2613
#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)
2614
#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)
2615
#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)
2616
#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)
2617
#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)
2618
#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)
2619
#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)
2620
#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)
2621
#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)
2622
#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)
2623
#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)
2624
#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)
2625
#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)
2626
#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)
2627
#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)
2628
#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)
2629
#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)
2630
#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)
2631

2632
#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2633
#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2634

2635
/*!
2636
@brief macro
2637
@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
2638
@since version 3.9.0
2639
*/
2640
#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
2641
    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__)) } \
2642
    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__)) }
2643

2644
/*!
2645
@brief macro
2646
@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
2647
@since version 3.9.0
2648
*/
2649
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
2650
    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__)) } \
2651
    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__)) }
2652

2653

2654
// inspired from https://stackoverflow.com/a/26745591
2655
// allows to call any std function as if (e.g. with begin):
2656
// using std::begin; begin(x);
2657
//
2658
// it allows using the detected idiom to retrieve the return type
2659
// of such an expression
2660
#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
2661
    namespace detail {                                                            \
2662
    using std::std_name;                                                          \
2663
    \
2664
    template<typename... T>                                                       \
2665
    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2666
    }                                                                             \
2667
    \
2668
    namespace detail2 {                                                           \
2669
    struct std_name##_tag                                                         \
2670
    {                                                                             \
2671
    };                                                                            \
2672
    \
2673
    template<typename... T>                                                       \
2674
    std_name##_tag std_name(T&&...);                                              \
2675
    \
2676
    template<typename... T>                                                       \
2677
    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2678
    \
2679
    template<typename... T>                                                       \
2680
    struct would_call_std_##std_name                                              \
2681
    {                                                                             \
2682
        static constexpr auto const value = ::nlohmann::detail::                  \
2683
                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
2684
    };                                                                            \
2685
    } /* namespace detail2 */ \
2686
    \
2687
    template<typename... T>                                                       \
2688
    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
2689
    {                                                                             \
2690
    }
2691

2692
#ifndef JSON_USE_IMPLICIT_CONVERSIONS
2693
    #define JSON_USE_IMPLICIT_CONVERSIONS 1
2694
#endif
2695

2696
#if JSON_USE_IMPLICIT_CONVERSIONS
2697
    #define JSON_EXPLICIT
2698
#else
2699
    #define JSON_EXPLICIT explicit
2700
#endif
2701

2702
#ifndef JSON_DIAGNOSTICS
2703
    #define JSON_DIAGNOSTICS 0
2704
#endif
2705

2706

2707
namespace nlohmann
2708
{
2709
namespace detail
2710
{
2711

2712
/*!
2713
@brief replace all occurrences of a substring by another string
2714

2715
@param[in,out] s  the string to manipulate; changed so that all
2716
               occurrences of @a f are replaced with @a t
2717
@param[in]     f  the substring to replace with @a t
2718
@param[in]     t  the string to replace @a f
2719

2720
@pre The search string @a f must not be empty. **This precondition is
2721
enforced with an assertion.**
2722

2723
@since version 2.0.0
2724
*/
2725
inline void replace_substring(std::string& s, const std::string& f,
2726
                              const std::string& t)
2727
{
2728
    JSON_ASSERT(!f.empty());
2729
    for (auto pos = s.find(f);                // find first occurrence of f
2730
            pos != std::string::npos;         // make sure f was found
2731
            s.replace(pos, f.size(), t),      // replace with t, and
2732
            pos = s.find(f, pos + t.size()))  // find next occurrence of f
2733
    {}
2734
}
2735

2736
/*!
2737
 * @brief string escaping as described in RFC 6901 (Sect. 4)
2738
 * @param[in] s string to escape
2739
 * @return    escaped string
2740
 *
2741
 * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
2742
 */
2743
inline std::string escape(std::string s)
2744
{
2745
    replace_substring(s, "~", "~0");
2746
    replace_substring(s, "/", "~1");
2747
    return s;
2748
}
2749

2750
/*!
2751
 * @brief string unescaping as described in RFC 6901 (Sect. 4)
2752
 * @param[in] s string to unescape
2753
 * @return    unescaped string
2754
 *
2755
 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
2756
 */
2757
static void unescape(std::string& s)
2758
{
2759
    replace_substring(s, "~1", "/");
2760
    replace_substring(s, "~0", "~");
2761
}
2762

2763
} // namespace detail
2764
} // namespace nlohmann
2765

2766
// #include <nlohmann/detail/input/position_t.hpp>
2767

2768

2769
#include <cstddef> // size_t
2770

2771
namespace nlohmann
2772
{
2773
namespace detail
2774
{
2775
/// struct to capture the start position of the current token
2776
struct position_t
2777
{
2778
    /// the total number of characters read
2779
    std::size_t chars_read_total = 0;
2780
    /// the number of characters read in the current line
2781
    std::size_t chars_read_current_line = 0;
2782
    /// the number of lines read
2783
    std::size_t lines_read = 0;
2784

2785
    /// conversion to size_t to preserve SAX interface
2786
    constexpr operator size_t() const
2787
    {
2788
        return chars_read_total;
2789
    }
2790
};
2791

2792
} // namespace detail
2793
} // namespace nlohmann
2794

2795
// #include <nlohmann/detail/macro_scope.hpp>
2796

2797

2798
namespace nlohmann
2799
{
2800
namespace detail
2801
{
2802
////////////////
2803
// exceptions //
2804
////////////////
2805

2806
/// @brief general exception of the @ref basic_json class
2807
/// @sa https://json.nlohmann.me/api/basic_json/exception/
2808
class exception : public std::exception
2809
{
2810
  public:
2811
    /// returns the explanatory string
2812
    const char* what() const noexcept override
2813
    {
2814
        return m.what();
2815
    }
2816

2817
    /// the id of the exception
2818
    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
2819

2820
  protected:
2821
    JSON_HEDLEY_NON_NULL(3)
2822
    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
2823

2824
    static std::string name(const std::string& ename, int id_)
2825
    {
2826
        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
2827
    }
2828

2829
    template<typename BasicJsonType>
2830
    static std::string diagnostics(const BasicJsonType& leaf_element)
2831
    {
2832
#if JSON_DIAGNOSTICS
2833
        std::vector<std::string> tokens;
2834
        for (const auto* current = &leaf_element; current->m_parent != nullptr; current = current->m_parent)
2835
        {
2836
            switch (current->m_parent->type())
2837
            {
2838
                case value_t::array:
2839
                {
2840
                    for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
2841
                    {
2842
                        if (&current->m_parent->m_value.array->operator[](i) == current)
2843
                        {
2844
                            tokens.emplace_back(std::to_string(i));
2845
                            break;
2846
                        }
2847
                    }
2848
                    break;
2849
                }
2850

2851
                case value_t::object:
2852
                {
2853
                    for (const auto& element : *current->m_parent->m_value.object)
2854
                    {
2855
                        if (&element.second == current)
2856
                        {
2857
                            tokens.emplace_back(element.first.c_str());
2858
                            break;
2859
                        }
2860
                    }
2861
                    break;
2862
                }
2863

2864
                case value_t::null: // LCOV_EXCL_LINE
2865
                case value_t::string: // LCOV_EXCL_LINE
2866
                case value_t::boolean: // LCOV_EXCL_LINE
2867
                case value_t::number_integer: // LCOV_EXCL_LINE
2868
                case value_t::number_unsigned: // LCOV_EXCL_LINE
2869
                case value_t::number_float: // LCOV_EXCL_LINE
2870
                case value_t::binary: // LCOV_EXCL_LINE
2871
                case value_t::discarded: // LCOV_EXCL_LINE
2872
                default:   // LCOV_EXCL_LINE
2873
                    break; // LCOV_EXCL_LINE
2874
            }
2875
        }
2876

2877
        if (tokens.empty())
2878
        {
2879
            return "";
2880
        }
2881

2882
        return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
2883
                                     [](const std::string & a, const std::string & b)
2884
        {
2885
            return a + "/" + detail::escape(b);
2886
        }) + ") ";
2887
#else
2888
        static_cast<void>(leaf_element);
2889
        return "";
2890
#endif
2891
    }
2892

2893
  private:
2894
    /// an exception object as storage for error messages
2895
    std::runtime_error m;
2896
};
2897

2898
/// @brief exception indicating a parse error
2899
/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
2900
class parse_error : public exception
2901
{
2902
  public:
2903
    /*!
2904
    @brief create a parse error exception
2905
    @param[in] id_       the id of the exception
2906
    @param[in] pos       the position where the error occurred (or with
2907
                         chars_read_total=0 if the position cannot be
2908
                         determined)
2909
    @param[in] what_arg  the explanatory string
2910
    @return parse_error object
2911
    */
2912
    template<typename BasicJsonType>
2913
    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, const BasicJsonType& context)
2914
    {
2915
        std::string w = exception::name("parse_error", id_) + "parse error" +
2916
                        position_string(pos) + ": " + exception::diagnostics(context) + what_arg;
2917
        return {id_, pos.chars_read_total, w.c_str()};
2918
    }
2919

2920
    template<typename BasicJsonType>
2921
    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, const BasicJsonType& context)
2922
    {
2923
        std::string w = exception::name("parse_error", id_) + "parse error" +
2924
                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
2925
                        ": " + exception::diagnostics(context) + what_arg;
2926
        return {id_, byte_, w.c_str()};
2927
    }
2928

2929
    /*!
2930
    @brief byte index of the parse error
2931

2932
    The byte index of the last read character in the input file.
2933

2934
    @note For an input with n bytes, 1 is the index of the first character and
2935
          n+1 is the index of the terminating null byte or the end of file.
2936
          This also holds true when reading a byte vector (CBOR or MessagePack).
2937
    */
2938
    const std::size_t byte;
2939

2940
  private:
2941
    parse_error(int id_, std::size_t byte_, const char* what_arg)
2942
        : exception(id_, what_arg), byte(byte_) {}
2943

2944
    static std::string position_string(const position_t& pos)
2945
    {
2946
        return " at line " + std::to_string(pos.lines_read + 1) +
2947
               ", column " + std::to_string(pos.chars_read_current_line);
2948
    }
2949
};
2950

2951
/// @brief exception indicating errors with iterators
2952
/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
2953
class invalid_iterator : public exception
2954
{
2955
  public:
2956
    template<typename BasicJsonType>
2957
    static invalid_iterator create(int id_, const std::string& what_arg, const BasicJsonType& context)
2958
    {
2959
        std::string w = exception::name("invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
2960
        return {id_, w.c_str()};
2961
    }
2962

2963
  private:
2964
    JSON_HEDLEY_NON_NULL(3)
2965
    invalid_iterator(int id_, const char* what_arg)
2966
        : exception(id_, what_arg) {}
2967
};
2968

2969
/// @brief exception indicating executing a member function with a wrong type
2970
/// @sa https://json.nlohmann.me/api/basic_json/type_error/
2971
class type_error : public exception
2972
{
2973
  public:
2974
    template<typename BasicJsonType>
2975
    static type_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
2976
    {
2977
        std::string w = exception::name("type_error", id_) + exception::diagnostics(context) + what_arg;
2978
        return {id_, w.c_str()};
2979
    }
2980

2981
  private:
2982
    JSON_HEDLEY_NON_NULL(3)
2983
    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2984
};
2985

2986
/// @brief exception indicating access out of the defined range
2987
/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
2988
class out_of_range : public exception
2989
{
2990
  public:
2991
    template<typename BasicJsonType>
2992
    static out_of_range create(int id_, const std::string& what_arg, const BasicJsonType& context)
2993
    {
2994
        std::string w = exception::name("out_of_range", id_) + exception::diagnostics(context) + what_arg;
2995
        return {id_, w.c_str()};
2996
    }
2997

2998
  private:
2999
    JSON_HEDLEY_NON_NULL(3)
3000
    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
3001
};
3002

3003
/// @brief exception indicating other library errors
3004
/// @sa https://json.nlohmann.me/api/basic_json/other_error/
3005
class other_error : public exception
3006
{
3007
  public:
3008
    template<typename BasicJsonType>
3009
    static other_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
3010
    {
3011
        std::string w = exception::name("other_error", id_) + exception::diagnostics(context) + what_arg;
3012
        return {id_, w.c_str()};
3013
    }
3014

3015
  private:
3016
    JSON_HEDLEY_NON_NULL(3)
3017
    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
3018
};
3019

3020
}  // namespace detail
3021
}  // namespace nlohmann
3022

3023
// #include <nlohmann/detail/macro_scope.hpp>
3024

3025
// #include <nlohmann/detail/meta/cpp_future.hpp>
3026

3027

3028
#include <cstddef> // size_t
3029
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
3030
#include <utility> // index_sequence, make_index_sequence, index_sequence_for
3031

3032
// #include <nlohmann/detail/macro_scope.hpp>
3033

3034

3035
namespace nlohmann
3036
{
3037
namespace detail
3038
{
3039

3040
template<typename T>
3041
using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3042

3043
#ifdef JSON_HAS_CPP_14
3044

3045
// the following utilities are natively available in C++14
3046
using std::enable_if_t;
3047
using std::index_sequence;
3048
using std::make_index_sequence;
3049
using std::index_sequence_for;
3050

3051
#else
3052

3053
// alias templates to reduce boilerplate
3054
template<bool B, typename T = void>
3055
using enable_if_t = typename std::enable_if<B, T>::type;
3056

3057
// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
3058
// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
3059

3060
//// START OF CODE FROM GOOGLE ABSEIL
3061

3062
// integer_sequence
3063
//
3064
// Class template representing a compile-time integer sequence. An instantiation
3065
// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
3066
// type through its template arguments (which is a common need when
3067
// working with C++11 variadic templates). `absl::integer_sequence` is designed
3068
// to be a drop-in replacement for C++14's `std::integer_sequence`.
3069
//
3070
// Example:
3071
//
3072
//   template< class T, T... Ints >
3073
//   void user_function(integer_sequence<T, Ints...>);
3074
//
3075
//   int main()
3076
//   {
3077
//     // user_function's `T` will be deduced to `int` and `Ints...`
3078
//     // will be deduced to `0, 1, 2, 3, 4`.
3079
//     user_function(make_integer_sequence<int, 5>());
3080
//   }
3081
template <typename T, T... Ints>
3082
struct integer_sequence
3083
{
3084
    using value_type = T;
3085
    static constexpr std::size_t size() noexcept
3086
    {
3087
        return sizeof...(Ints);
3088
    }
3089
};
3090

3091
// index_sequence
3092
//
3093
// A helper template for an `integer_sequence` of `size_t`,
3094
// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
3095
// `std::index_sequence`.
3096
template <size_t... Ints>
3097
using index_sequence = integer_sequence<size_t, Ints...>;
3098

3099
namespace utility_internal
3100
{
3101

3102
template <typename Seq, size_t SeqSize, size_t Rem>
3103
struct Extend;
3104

3105
// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
3106
template <typename T, T... Ints, size_t SeqSize>
3107
struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3108
{
3109
    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3110
};
3111

3112
template <typename T, T... Ints, size_t SeqSize>
3113
struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3114
{
3115
    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3116
};
3117

3118
// Recursion helper for 'make_integer_sequence<T, N>'.
3119
// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
3120
template <typename T, size_t N>
3121
struct Gen
3122
{
3123
    using type =
3124
        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3125
};
3126

3127
template <typename T>
3128
struct Gen<T, 0>
3129
{
3130
    using type = integer_sequence<T>;
3131
};
3132

3133
}  // namespace utility_internal
3134

3135
// Compile-time sequences of integers
3136

3137
// make_integer_sequence
3138
//
3139
// This template alias is equivalent to
3140
// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
3141
// replacement for C++14's `std::make_integer_sequence`.
3142
template <typename T, T N>
3143
using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
3144

3145
// make_index_sequence
3146
//
3147
// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
3148
// and is designed to be a drop-in replacement for C++14's
3149
// `std::make_index_sequence`.
3150
template <size_t N>
3151
using make_index_sequence = make_integer_sequence<size_t, N>;
3152

3153
// index_sequence_for
3154
//
3155
// Converts a typename pack into an index sequence of the same length, and
3156
// is designed to be a drop-in replacement for C++14's
3157
// `std::index_sequence_for()`
3158
template <typename... Ts>
3159
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
3160

3161
//// END OF CODE FROM GOOGLE ABSEIL
3162

3163
#endif
3164

3165
// dispatch utility (taken from ranges-v3)
3166
template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
3167
template<> struct priority_tag<0> {};
3168

3169
// taken from ranges-v3
3170
template<typename T>
3171
struct static_const
3172
{
3173
    static constexpr T value{};
3174
};
3175

3176
template<typename T>
3177
constexpr T static_const<T>::value; // NOLINT(readability-redundant-declaration)
3178

3179
}  // namespace detail
3180
}  // namespace nlohmann
3181

3182
// #include <nlohmann/detail/meta/identity_tag.hpp>
3183

3184

3185
namespace nlohmann
3186
{
3187
namespace detail
3188
{
3189
// dispatching helper struct
3190
template <class T> struct identity_tag {};
3191
}  // namespace detail
3192
}  // namespace nlohmann
3193

3194
// #include <nlohmann/detail/meta/type_traits.hpp>
3195

3196

3197
#include <limits> // numeric_limits
3198
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
3199
#include <utility> // declval
3200
#include <tuple> // tuple
3201

3202
// #include <nlohmann/detail/macro_scope.hpp>
3203

3204

3205
// #include <nlohmann/detail/iterators/iterator_traits.hpp>
3206

3207

3208
#include <iterator> // random_access_iterator_tag
3209

3210
// #include <nlohmann/detail/meta/void_t.hpp>
3211

3212
// #include <nlohmann/detail/meta/cpp_future.hpp>
3213

3214

3215
namespace nlohmann
3216
{
3217
namespace detail
3218
{
3219
template<typename It, typename = void>
3220
struct iterator_types {};
3221

3222
template<typename It>
3223
struct iterator_types <
3224
    It,
3225
    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3226
    typename It::reference, typename It::iterator_category >>
3227
{
3228
    using difference_type = typename It::difference_type;
3229
    using value_type = typename It::value_type;
3230
    using pointer = typename It::pointer;
3231
    using reference = typename It::reference;
3232
    using iterator_category = typename It::iterator_category;
3233
};
3234

3235
// This is required as some compilers implement std::iterator_traits in a way that
3236
// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
3237
template<typename T, typename = void>
3238
struct iterator_traits
3239
{
3240
};
3241

3242
template<typename T>
3243
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3244
            : iterator_types<T>
3245
{
3246
};
3247

3248
template<typename T>
3249
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3250
{
3251
    using iterator_category = std::random_access_iterator_tag;
3252
    using value_type = T;
3253
    using difference_type = ptrdiff_t;
3254
    using pointer = T*;
3255
    using reference = T&;
3256
};
3257
} // namespace detail
3258
} // namespace nlohmann
3259

3260
// #include <nlohmann/detail/meta/call_std/begin.hpp>
3261

3262

3263
// #include <nlohmann/detail/macro_scope.hpp>
3264

3265

3266
namespace nlohmann
3267
{
3268
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
3269
} // namespace nlohmann
3270

3271
// #include <nlohmann/detail/meta/call_std/end.hpp>
3272

3273

3274
// #include <nlohmann/detail/macro_scope.hpp>
3275

3276

3277
namespace nlohmann
3278
{
3279
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
3280
}  // namespace nlohmann
3281

3282
// #include <nlohmann/detail/meta/cpp_future.hpp>
3283

3284
// #include <nlohmann/detail/meta/detected.hpp>
3285

3286
// #include <nlohmann/json_fwd.hpp>
3287
#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3288
#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3289

3290
#include <cstdint> // int64_t, uint64_t
3291
#include <map> // map
3292
#include <memory> // allocator
3293
#include <string> // string
3294
#include <vector> // vector
3295

3296
/*!
3297
@brief namespace for Niels Lohmann
3298
@see https://github.com/nlohmann
3299
@since version 1.0.0
3300
*/
3301
namespace nlohmann
3302
{
3303
/*!
3304
@brief default JSONSerializer template argument
3305

3306
This serializer ignores the template arguments and uses ADL
3307
([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
3308
for serialization.
3309
*/
3310
template<typename T = void, typename SFINAE = void>
3311
struct adl_serializer;
3312

3313
/// a class to store JSON values
3314
/// @sa https://json.nlohmann.me/api/basic_json/
3315
template<template<typename U, typename V, typename... Args> class ObjectType =
3316
         std::map,
3317
         template<typename U, typename... Args> class ArrayType = std::vector,
3318
         class StringType = std::string, class BooleanType = bool,
3319
         class NumberIntegerType = std::int64_t,
3320
         class NumberUnsignedType = std::uint64_t,
3321
         class NumberFloatType = double,
3322
         template<typename U> class AllocatorType = std::allocator,
3323
         template<typename T, typename SFINAE = void> class JSONSerializer =
3324
         adl_serializer,
3325
         class BinaryType = std::vector<std::uint8_t>>
3326
class basic_json;
3327

3328
/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
3329
/// @sa https://json.nlohmann.me/api/json_pointer/
3330
template<typename BasicJsonType>
3331
class json_pointer;
3332

3333
/*!
3334
@brief default specialization
3335
@sa https://json.nlohmann.me/api/json/
3336
*/
3337
using json = basic_json<>;
3338

3339
/// @brief a minimal map-like container that preserves insertion order
3340
/// @sa https://json.nlohmann.me/api/ordered_map/
3341
template<class Key, class T, class IgnoredLess, class Allocator>
3342
struct ordered_map;
3343

3344
/// @brief specialization that maintains the insertion order of object keys
3345
/// @sa https://json.nlohmann.me/api/ordered_json/
3346
using ordered_json = basic_json<nlohmann::ordered_map>;
3347

3348
}  // namespace nlohmann
3349

3350
#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
3351

3352

3353
namespace nlohmann
3354
{
3355
/*!
3356
@brief detail namespace with internal helper functions
3357

3358
This namespace collects functions that should not be exposed,
3359
implementations of some @ref basic_json methods, and meta-programming helpers.
3360

3361
@since version 2.1.0
3362
*/
3363
namespace detail
3364
{
3365
/////////////
3366
// helpers //
3367
/////////////
3368

3369
// Note to maintainers:
3370
//
3371
// Every trait in this file expects a non CV-qualified type.
3372
// The only exceptions are in the 'aliases for detected' section
3373
// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
3374
//
3375
// In this case, T has to be properly CV-qualified to constraint the function arguments
3376
// (e.g. to_json(BasicJsonType&, const T&))
3377

3378
template<typename> struct is_basic_json : std::false_type {};
3379

3380
NLOHMANN_BASIC_JSON_TPL_DECLARATION
3381
struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3382

3383
//////////////////////
3384
// json_ref helpers //
3385
//////////////////////
3386

3387
template<typename>
3388
class json_ref;
3389

3390
template<typename>
3391
struct is_json_ref : std::false_type {};
3392

3393
template<typename T>
3394
struct is_json_ref<json_ref<T>> : std::true_type {};
3395

3396
//////////////////////////
3397
// aliases for detected //
3398
//////////////////////////
3399

3400
template<typename T>
3401
using mapped_type_t = typename T::mapped_type;
3402

3403
template<typename T>
3404
using key_type_t = typename T::key_type;
3405

3406
template<typename T>
3407
using value_type_t = typename T::value_type;
3408

3409
template<typename T>
3410
using difference_type_t = typename T::difference_type;
3411

3412
template<typename T>
3413
using pointer_t = typename T::pointer;
3414

3415
template<typename T>
3416
using reference_t = typename T::reference;
3417

3418
template<typename T>
3419
using iterator_category_t = typename T::iterator_category;
3420

3421
template<typename T, typename... Args>
3422
using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3423

3424
template<typename T, typename... Args>
3425
using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3426

3427
template<typename T, typename U>
3428
using get_template_function = decltype(std::declval<T>().template get<U>());
3429

3430
// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3431
template<typename BasicJsonType, typename T, typename = void>
3432
struct has_from_json : std::false_type {};
3433

3434
// trait checking if j.get<T> is valid
3435
// use this trait instead of std::is_constructible or std::is_convertible,
3436
// both rely on, or make use of implicit conversions, and thus fail when T
3437
// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3438
template <typename BasicJsonType, typename T>
3439
struct is_getable
3440
{
3441
    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3442
};
3443

3444
template<typename BasicJsonType, typename T>
3445
struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3446
{
3447
    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3448

3449
    static constexpr bool value =
3450
        is_detected_exact<void, from_json_function, serializer,
3451
        const BasicJsonType&, T&>::value;
3452
};
3453

3454
// This trait checks if JSONSerializer<T>::from_json(json const&) exists
3455
// this overload is used for non-default-constructible user-defined-types
3456
template<typename BasicJsonType, typename T, typename = void>
3457
struct has_non_default_from_json : std::false_type {};
3458

3459
template<typename BasicJsonType, typename T>
3460
struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3461
{
3462
    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3463

3464
    static constexpr bool value =
3465
        is_detected_exact<T, from_json_function, serializer,
3466
        const BasicJsonType&>::value;
3467
};
3468

3469
// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3470
// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3471
template<typename BasicJsonType, typename T, typename = void>
3472
struct has_to_json : std::false_type {};
3473

3474
template<typename BasicJsonType, typename T>
3475
struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3476
{
3477
    using serializer = typename BasicJsonType::template json_serializer<T, void>;
3478

3479
    static constexpr bool value =
3480
        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3481
        T>::value;
3482
};
3483

3484

3485
///////////////////
3486
// is_ functions //
3487
///////////////////
3488

3489
// https://en.cppreference.com/w/cpp/types/conjunction
3490
template<class...> struct conjunction : std::true_type { };
3491
template<class B1> struct conjunction<B1> : B1 { };
3492
template<class B1, class... Bn>
3493
struct conjunction<B1, Bn...>
3494
: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3495

3496
// https://en.cppreference.com/w/cpp/types/negation
3497
template<class B> struct negation : std::integral_constant < bool, !B::value > { };
3498

3499
// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
3500
// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
3501
// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
3502
template <typename T>
3503
struct is_default_constructible : std::is_default_constructible<T> {};
3504

3505
template <typename T1, typename T2>
3506
struct is_default_constructible<std::pair<T1, T2>>
3507
            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3508

3509
template <typename T1, typename T2>
3510
struct is_default_constructible<const std::pair<T1, T2>>
3511
            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3512

3513
template <typename... Ts>
3514
struct is_default_constructible<std::tuple<Ts...>>
3515
            : conjunction<is_default_constructible<Ts>...> {};
3516

3517
template <typename... Ts>
3518
struct is_default_constructible<const std::tuple<Ts...>>
3519
            : conjunction<is_default_constructible<Ts>...> {};
3520

3521

3522
template <typename T, typename... Args>
3523
struct is_constructible : std::is_constructible<T, Args...> {};
3524

3525
template <typename T1, typename T2>
3526
struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3527

3528
template <typename T1, typename T2>
3529
struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3530

3531
template <typename... Ts>
3532
struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3533

3534
template <typename... Ts>
3535
struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3536

3537

3538
template<typename T, typename = void>
3539
struct is_iterator_traits : std::false_type {};
3540

3541
template<typename T>
3542
struct is_iterator_traits<iterator_traits<T>>
3543
{
3544
  private:
3545
    using traits = iterator_traits<T>;
3546

3547
  public:
3548
    static constexpr auto value =
3549
        is_detected<value_type_t, traits>::value &&
3550
        is_detected<difference_type_t, traits>::value &&
3551
        is_detected<pointer_t, traits>::value &&
3552
        is_detected<iterator_category_t, traits>::value &&
3553
        is_detected<reference_t, traits>::value;
3554
};
3555

3556
template<typename T>
3557
struct is_range
3558
{
3559
  private:
3560
    using t_ref = typename std::add_lvalue_reference<T>::type;
3561

3562
    using iterator = detected_t<result_of_begin, t_ref>;
3563
    using sentinel = detected_t<result_of_end, t_ref>;
3564

3565
    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
3566
    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
3567
    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
3568
    static constexpr auto is_iterator_begin =
3569
        is_iterator_traits<iterator_traits<iterator>>::value;
3570

3571
  public:
3572
    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
3573
};
3574

3575
template<typename R>
3576
using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3577

3578
template<typename T>
3579
using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
3580

3581
// The following implementation of is_complete_type is taken from
3582
// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
3583
// and is written by Xiang Fan who agreed to using it in this library.
3584

3585
template<typename T, typename = void>
3586
struct is_complete_type : std::false_type {};
3587

3588
template<typename T>
3589
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3590

3591
template<typename BasicJsonType, typename CompatibleObjectType,
3592
         typename = void>
3593
struct is_compatible_object_type_impl : std::false_type {};
3594

3595
template<typename BasicJsonType, typename CompatibleObjectType>
3596
struct is_compatible_object_type_impl <
3597
    BasicJsonType, CompatibleObjectType,
3598
    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3599
    is_detected<key_type_t, CompatibleObjectType>::value >>
3600
{
3601
    using object_t = typename BasicJsonType::object_t;
3602

3603
    // macOS's is_constructible does not play well with nonesuch...
3604
    static constexpr bool value =
3605
        is_constructible<typename object_t::key_type,
3606
        typename CompatibleObjectType::key_type>::value &&
3607
        is_constructible<typename object_t::mapped_type,
3608
        typename CompatibleObjectType::mapped_type>::value;
3609
};
3610

3611
template<typename BasicJsonType, typename CompatibleObjectType>
3612
struct is_compatible_object_type
3613
    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3614

3615
template<typename BasicJsonType, typename ConstructibleObjectType,
3616
         typename = void>
3617
struct is_constructible_object_type_impl : std::false_type {};
3618

3619
template<typename BasicJsonType, typename ConstructibleObjectType>
3620
struct is_constructible_object_type_impl <
3621
    BasicJsonType, ConstructibleObjectType,
3622
    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3623
    is_detected<key_type_t, ConstructibleObjectType>::value >>
3624
{
3625
    using object_t = typename BasicJsonType::object_t;
3626

3627
    static constexpr bool value =
3628
        (is_default_constructible<ConstructibleObjectType>::value &&
3629
         (std::is_move_assignable<ConstructibleObjectType>::value ||
3630
          std::is_copy_assignable<ConstructibleObjectType>::value) &&
3631
         (is_constructible<typename ConstructibleObjectType::key_type,
3632
          typename object_t::key_type>::value &&
3633
          std::is_same <
3634
          typename object_t::mapped_type,
3635
          typename ConstructibleObjectType::mapped_type >::value)) ||
3636
        (has_from_json<BasicJsonType,
3637
         typename ConstructibleObjectType::mapped_type>::value ||
3638
         has_non_default_from_json <
3639
         BasicJsonType,
3640
         typename ConstructibleObjectType::mapped_type >::value);
3641
};
3642

3643
template<typename BasicJsonType, typename ConstructibleObjectType>
3644
struct is_constructible_object_type
3645
    : is_constructible_object_type_impl<BasicJsonType,
3646
      ConstructibleObjectType> {};
3647

3648
template<typename BasicJsonType, typename CompatibleStringType>
3649
struct is_compatible_string_type
3650
{
3651
    static constexpr auto value =
3652
        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3653
};
3654

3655
template<typename BasicJsonType, typename ConstructibleStringType>
3656
struct is_constructible_string_type
3657
{
3658
    static constexpr auto value =
3659
        is_constructible<ConstructibleStringType,
3660
        typename BasicJsonType::string_t>::value;
3661
};
3662

3663
template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3664
struct is_compatible_array_type_impl : std::false_type {};
3665

3666
template<typename BasicJsonType, typename CompatibleArrayType>
3667
struct is_compatible_array_type_impl <
3668
    BasicJsonType, CompatibleArrayType,
3669
    enable_if_t <
3670
    is_detected<iterator_t, CompatibleArrayType>::value&&
3671
    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
3672
// special case for types like std::filesystem::path whose iterator's value_type are themselves
3673
// c.f. https://github.com/nlohmann/json/pull/3073
3674
    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3675
{
3676
    static constexpr bool value =
3677
        is_constructible<BasicJsonType,
3678
        range_value_t<CompatibleArrayType>>::value;
3679
};
3680

3681
template<typename BasicJsonType, typename CompatibleArrayType>
3682
struct is_compatible_array_type
3683
    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3684

3685
template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3686
struct is_constructible_array_type_impl : std::false_type {};
3687

3688
template<typename BasicJsonType, typename ConstructibleArrayType>
3689
struct is_constructible_array_type_impl <
3690
    BasicJsonType, ConstructibleArrayType,
3691
    enable_if_t<std::is_same<ConstructibleArrayType,
3692
    typename BasicJsonType::value_type>::value >>
3693
            : std::true_type {};
3694

3695
template<typename BasicJsonType, typename ConstructibleArrayType>
3696
struct is_constructible_array_type_impl <
3697
    BasicJsonType, ConstructibleArrayType,
3698
    enable_if_t < !std::is_same<ConstructibleArrayType,
3699
    typename BasicJsonType::value_type>::value&&
3700
    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3701
    is_default_constructible<ConstructibleArrayType>::value&&
3702
(std::is_move_assignable<ConstructibleArrayType>::value ||
3703
 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3704
is_detected<iterator_t, ConstructibleArrayType>::value&&
3705
is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
3706
is_detected<range_value_t, ConstructibleArrayType>::value&&
3707
// special case for types like std::filesystem::path whose iterator's value_type are themselves
3708
// c.f. https://github.com/nlohmann/json/pull/3073
3709
!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
3710
        is_complete_type <
3711
        detected_t<range_value_t, ConstructibleArrayType >>::value >>
3712
{
3713
    using value_type = range_value_t<ConstructibleArrayType>;
3714

3715
    static constexpr bool value =
3716
        std::is_same<value_type,
3717
        typename BasicJsonType::array_t::value_type>::value ||
3718
        has_from_json<BasicJsonType,
3719
        value_type>::value ||
3720
        has_non_default_from_json <
3721
        BasicJsonType,
3722
        value_type >::value;
3723
};
3724

3725
template<typename BasicJsonType, typename ConstructibleArrayType>
3726
struct is_constructible_array_type
3727
    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3728

3729
template<typename RealIntegerType, typename CompatibleNumberIntegerType,
3730
         typename = void>
3731
struct is_compatible_integer_type_impl : std::false_type {};
3732

3733
template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3734
struct is_compatible_integer_type_impl <
3735
    RealIntegerType, CompatibleNumberIntegerType,
3736
    enable_if_t < std::is_integral<RealIntegerType>::value&&
3737
    std::is_integral<CompatibleNumberIntegerType>::value&&
3738
    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3739
{
3740
    // is there an assert somewhere on overflows?
3741
    using RealLimits = std::numeric_limits<RealIntegerType>;
3742
    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3743

3744
    static constexpr auto value =
3745
        is_constructible<RealIntegerType,
3746
        CompatibleNumberIntegerType>::value &&
3747
        CompatibleLimits::is_integer &&
3748
        RealLimits::is_signed == CompatibleLimits::is_signed;
3749
};
3750

3751
template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3752
struct is_compatible_integer_type
3753
    : is_compatible_integer_type_impl<RealIntegerType,
3754
      CompatibleNumberIntegerType> {};
3755

3756
template<typename BasicJsonType, typename CompatibleType, typename = void>
3757
struct is_compatible_type_impl: std::false_type {};
3758

3759
template<typename BasicJsonType, typename CompatibleType>
3760
struct is_compatible_type_impl <
3761
    BasicJsonType, CompatibleType,
3762
    enable_if_t<is_complete_type<CompatibleType>::value >>
3763
{
3764
    static constexpr bool value =
3765
        has_to_json<BasicJsonType, CompatibleType>::value;
3766
};
3767

3768
template<typename BasicJsonType, typename CompatibleType>
3769
struct is_compatible_type
3770
    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3771

3772
template<typename T1, typename T2>
3773
struct is_constructible_tuple : std::false_type {};
3774

3775
template<typename T1, typename... Args>
3776
struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3777

3778
// a naive helper to check if a type is an ordered_map (exploits the fact that
3779
// ordered_map inherits capacity() from std::vector)
3780
template <typename T>
3781
struct is_ordered_map
3782
{
3783
    using one = char;
3784

3785
    struct two
3786
    {
3787
        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
3788
    };
3789

3790
    template <typename C> static one test( decltype(&C::capacity) ) ;
3791
    template <typename C> static two test(...);
3792

3793
    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
3794
};
3795

3796
// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
3797
template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
3798
T conditional_static_cast(U value)
3799
{
3800
    return static_cast<T>(value);
3801
}
3802

3803
template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
3804
T conditional_static_cast(U value)
3805
{
3806
    return value;
3807
}
3808

3809
}  // namespace detail
3810
}  // namespace nlohmann
3811

3812
// #include <nlohmann/detail/value_t.hpp>
3813

3814

3815
#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
3816
#include <experimental/filesystem>
3817
namespace nlohmann::detail
3818
{
3819
namespace std_fs = std::experimental::filesystem;
3820
} // namespace nlohmann::detail
3821
#elif JSON_HAS_FILESYSTEM
3822
#include <filesystem>
3823
namespace nlohmann::detail
3824
{
3825
namespace std_fs = std::filesystem;
3826
} // namespace nlohmann::detail
3827
#endif
3828

3829
namespace nlohmann
3830
{
3831
namespace detail
3832
{
3833
template<typename BasicJsonType>
3834
void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
3835
{
3836
    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3837
    {
3838
        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), j));
3839
    }
3840
    n = nullptr;
3841
}
3842

3843
// overloads for basic_json template parameters
3844
template < typename BasicJsonType, typename ArithmeticType,
3845
           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3846
                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3847
                         int > = 0 >
3848
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
3849
{
3850
    switch (static_cast<value_t>(j))
3851
    {
3852
        case value_t::number_unsigned:
3853
        {
3854
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3855
            break;
3856
        }
3857
        case value_t::number_integer:
3858
        {
3859
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3860
            break;
3861
        }
3862
        case value_t::number_float:
3863
        {
3864
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3865
            break;
3866
        }
3867

3868
        case value_t::null:
3869
        case value_t::object:
3870
        case value_t::array:
3871
        case value_t::string:
3872
        case value_t::boolean:
3873
        case value_t::binary:
3874
        case value_t::discarded:
3875
        default:
3876
            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
3877
    }
3878
}
3879

3880
template<typename BasicJsonType>
3881
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
3882
{
3883
    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3884
    {
3885
        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), j));
3886
    }
3887
    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3888
}
3889

3890
template<typename BasicJsonType>
3891
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
3892
{
3893
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3894
    {
3895
        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
3896
    }
3897
    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3898
}
3899

3900
template <
3901
    typename BasicJsonType, typename ConstructibleStringType,
3902
    enable_if_t <
3903
        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3904
        !std::is_same<typename BasicJsonType::string_t,
3905
                      ConstructibleStringType>::value,
3906
        int > = 0 >
3907
void from_json(const BasicJsonType& j, ConstructibleStringType& s)
3908
{
3909
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3910
    {
3911
        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
3912
    }
3913

3914
    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3915
}
3916

3917
template<typename BasicJsonType>
3918
void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
3919
{
3920
    get_arithmetic_value(j, val);
3921
}
3922

3923
template<typename BasicJsonType>
3924
void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
3925
{
3926
    get_arithmetic_value(j, val);
3927
}
3928

3929
template<typename BasicJsonType>
3930
void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
3931
{
3932
    get_arithmetic_value(j, val);
3933
}
3934

3935
template<typename BasicJsonType, typename EnumType,
3936
         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
3937
void from_json(const BasicJsonType& j, EnumType& e)
3938
{
3939
    typename std::underlying_type<EnumType>::type val;
3940
    get_arithmetic_value(j, val);
3941
    e = static_cast<EnumType>(val);
3942
}
3943

3944
// forward_list doesn't have an insert method
3945
template<typename BasicJsonType, typename T, typename Allocator,
3946
         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
3947
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3948
{
3949
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3950
    {
3951
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
3952
    }
3953
    l.clear();
3954
    std::transform(j.rbegin(), j.rend(),
3955
                   std::front_inserter(l), [](const BasicJsonType & i)
3956
    {
3957
        return i.template get<T>();
3958
    });
3959
}
3960

3961
// valarray doesn't have an insert method
3962
template<typename BasicJsonType, typename T,
3963
         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
3964
void from_json(const BasicJsonType& j, std::valarray<T>& l)
3965
{
3966
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3967
    {
3968
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
3969
    }
3970
    l.resize(j.size());
3971
    std::transform(j.begin(), j.end(), std::begin(l),
3972
                   [](const BasicJsonType & elem)
3973
    {
3974
        return elem.template get<T>();
3975
    });
3976
}
3977

3978
template<typename BasicJsonType, typename T, std::size_t N>
3979
auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
3980
-> decltype(j.template get<T>(), void())
3981
{
3982
    for (std::size_t i = 0; i < N; ++i)
3983
    {
3984
        arr[i] = j.at(i).template get<T>();
3985
    }
3986
}
3987

3988
template<typename BasicJsonType>
3989
void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
3990
{
3991
    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3992
}
3993

3994
template<typename BasicJsonType, typename T, std::size_t N>
3995
auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
3996
                          priority_tag<2> /*unused*/)
3997
-> decltype(j.template get<T>(), void())
3998
{
3999
    for (std::size_t i = 0; i < N; ++i)
4000
    {
4001
        arr[i] = j.at(i).template get<T>();
4002
    }
4003
}
4004

4005
template<typename BasicJsonType, typename ConstructibleArrayType,
4006
         enable_if_t<
4007
             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4008
             int> = 0>
4009
auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
4010
-> decltype(
4011
    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4012
    j.template get<typename ConstructibleArrayType::value_type>(),
4013
    void())
4014
{
4015
    using std::end;
4016

4017
    ConstructibleArrayType ret;
4018
    ret.reserve(j.size());
4019
    std::transform(j.begin(), j.end(),
4020
                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
4021
    {
4022
        // get<BasicJsonType>() returns *this, this won't call a from_json
4023
        // method when value_type is BasicJsonType
4024
        return i.template get<typename ConstructibleArrayType::value_type>();
4025
    });
4026
    arr = std::move(ret);
4027
}
4028

4029
template<typename BasicJsonType, typename ConstructibleArrayType,
4030
         enable_if_t<
4031
             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4032
             int> = 0>
4033
void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
4034
                          priority_tag<0> /*unused*/)
4035
{
4036
    using std::end;
4037

4038
    ConstructibleArrayType ret;
4039
    std::transform(
4040
        j.begin(), j.end(), std::inserter(ret, end(ret)),
4041
        [](const BasicJsonType & i)
4042
    {
4043
        // get<BasicJsonType>() returns *this, this won't call a from_json
4044
        // method when value_type is BasicJsonType
4045
        return i.template get<typename ConstructibleArrayType::value_type>();
4046
    });
4047
    arr = std::move(ret);
4048
}
4049

4050
template < typename BasicJsonType, typename ConstructibleArrayType,
4051
           enable_if_t <
4052
               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
4053
               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
4054
               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4055
               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4056
               !is_basic_json<ConstructibleArrayType>::value,
4057
               int > = 0 >
4058
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
4059
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
4060
j.template get<typename ConstructibleArrayType::value_type>(),
4061
void())
4062
{
4063
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4064
    {
4065
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4066
    }
4067

4068
    from_json_array_impl(j, arr, priority_tag<3> {});
4069
}
4070

4071
template < typename BasicJsonType, typename T, std::size_t... Idx >
4072
std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4073
        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
4074
{
4075
    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4076
}
4077

4078
template < typename BasicJsonType, typename T, std::size_t N >
4079
auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4080
-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4081
{
4082
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4083
    {
4084
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4085
    }
4086

4087
    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4088
}
4089

4090
template<typename BasicJsonType>
4091
void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
4092
{
4093
    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
4094
    {
4095
        JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), j));
4096
    }
4097

4098
    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4099
}
4100

4101
template<typename BasicJsonType, typename ConstructibleObjectType,
4102
         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
4103
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
4104
{
4105
    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
4106
    {
4107
        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), j));
4108
    }
4109

4110
    ConstructibleObjectType ret;
4111
    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4112
    using value_type = typename ConstructibleObjectType::value_type;
4113
    std::transform(
4114
        inner_object->begin(), inner_object->end(),
4115
        std::inserter(ret, ret.begin()),
4116
        [](typename BasicJsonType::object_t::value_type const & p)
4117
    {
4118
        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4119
    });
4120
    obj = std::move(ret);
4121
}
4122

4123
// overload for arithmetic types, not chosen for basic_json template arguments
4124
// (BooleanType, etc..); note: Is it really necessary to provide explicit
4125
// overloads for boolean_t etc. in case of a custom BooleanType which is not
4126
// an arithmetic type?
4127
template < typename BasicJsonType, typename ArithmeticType,
4128
           enable_if_t <
4129
               std::is_arithmetic<ArithmeticType>::value&&
4130
               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4131
               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4132
               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4133
               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4134
               int > = 0 >
4135
void from_json(const BasicJsonType& j, ArithmeticType& val)
4136
{
4137
    switch (static_cast<value_t>(j))
4138
    {
4139
        case value_t::number_unsigned:
4140
        {
4141
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4142
            break;
4143
        }
4144
        case value_t::number_integer:
4145
        {
4146
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4147
            break;
4148
        }
4149
        case value_t::number_float:
4150
        {
4151
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4152
            break;
4153
        }
4154
        case value_t::boolean:
4155
        {
4156
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4157
            break;
4158
        }
4159

4160
        case value_t::null:
4161
        case value_t::object:
4162
        case value_t::array:
4163
        case value_t::string:
4164
        case value_t::binary:
4165
        case value_t::discarded:
4166
        default:
4167
            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
4168
    }
4169
}
4170

4171
template<typename BasicJsonType, typename... Args, std::size_t... Idx>
4172
std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
4173
{
4174
    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
4175
}
4176

4177
template < typename BasicJsonType, class A1, class A2 >
4178
std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
4179
{
4180
    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4181
            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4182
}
4183

4184
template<typename BasicJsonType, typename A1, typename A2>
4185
void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
4186
{
4187
    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
4188
}
4189

4190
template<typename BasicJsonType, typename... Args>
4191
std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
4192
{
4193
    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4194
}
4195

4196
template<typename BasicJsonType, typename... Args>
4197
void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
4198
{
4199
    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4200
}
4201

4202
template<typename BasicJsonType, typename TupleRelated>
4203
auto from_json(BasicJsonType&& j, TupleRelated&& t)
4204
-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
4205
{
4206
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4207
    {
4208
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4209
    }
4210

4211
    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4212
}
4213

4214
template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
4215
           typename = enable_if_t < !std::is_constructible <
4216
                                        typename BasicJsonType::string_t, Key >::value >>
4217
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4218
{
4219
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4220
    {
4221
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4222
    }
4223
    m.clear();
4224
    for (const auto& p : j)
4225
    {
4226
        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4227
        {
4228
            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
4229
        }
4230
        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4231
    }
4232
}
4233

4234
template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
4235
           typename = enable_if_t < !std::is_constructible <
4236
                                        typename BasicJsonType::string_t, Key >::value >>
4237
void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
4238
{
4239
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4240
    {
4241
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4242
    }
4243
    m.clear();
4244
    for (const auto& p : j)
4245
    {
4246
        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4247
        {
4248
            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
4249
        }
4250
        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4251
    }
4252
}
4253

4254
#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
4255
template<typename BasicJsonType>
4256
void from_json(const BasicJsonType& j, std_fs::path& p)
4257
{
4258
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4259
    {
4260
        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
4261
    }
4262
    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4263
}
4264
#endif
4265

4266
struct from_json_fn
4267
{
4268
    template<typename BasicJsonType, typename T>
4269
    auto operator()(const BasicJsonType& j, T&& val) const
4270
    noexcept(noexcept(from_json(j, std::forward<T>(val))))
4271
    -> decltype(from_json(j, std::forward<T>(val)))
4272
    {
4273
        return from_json(j, std::forward<T>(val));
4274
    }
4275
};
4276
}  // namespace detail
4277

4278
/// namespace to hold default `from_json` function
4279
/// to see why this is required:
4280
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
4281
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
4282
{
4283
constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value; // NOLINT(misc-definitions-in-headers)
4284
} // namespace
4285
} // namespace nlohmann
4286

4287
// #include <nlohmann/detail/conversions/to_json.hpp>
4288

4289

4290
#include <algorithm> // copy
4291
#include <iterator> // begin, end
4292
#include <string> // string
4293
#include <tuple> // tuple, get
4294
#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
4295
#include <utility> // move, forward, declval, pair
4296
#include <valarray> // valarray
4297
#include <vector> // vector
4298

4299
// #include <nlohmann/detail/macro_scope.hpp>
4300

4301
// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
4302

4303

4304
#include <cstddef> // size_t
4305
#include <iterator> // input_iterator_tag
4306
#include <string> // string, to_string
4307
#include <tuple> // tuple_size, get, tuple_element
4308
#include <utility> // move
4309

4310
// #include <nlohmann/detail/meta/type_traits.hpp>
4311

4312
// #include <nlohmann/detail/value_t.hpp>
4313

4314

4315
namespace nlohmann
4316
{
4317
namespace detail
4318
{
4319
template<typename string_type>
4320
void int_to_string( string_type& target, std::size_t value )
4321
{
4322
    // For ADL
4323
    using std::to_string;
4324
    target = to_string(value);
4325
}
4326
template<typename IteratorType> class iteration_proxy_value
4327
{
4328
  public:
4329
    using difference_type = std::ptrdiff_t;
4330
    using value_type = iteration_proxy_value;
4331
    using pointer = value_type * ;
4332
    using reference = value_type & ;
4333
    using iterator_category = std::input_iterator_tag;
4334
    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
4335

4336
  private:
4337
    /// the iterator
4338
    IteratorType anchor;
4339
    /// an index for arrays (used to create key names)
4340
    std::size_t array_index = 0;
4341
    /// last stringified array index
4342
    mutable std::size_t array_index_last = 0;
4343
    /// a string representation of the array index
4344
    mutable string_type array_index_str = "0";
4345
    /// an empty string (to return a reference for primitive values)
4346
    const string_type empty_str{};
4347

4348
  public:
4349
    explicit iteration_proxy_value(IteratorType it) noexcept
4350
        : anchor(std::move(it))
4351
    {}
4352

4353
    /// dereference operator (needed for range-based for)
4354
    iteration_proxy_value& operator*()
4355
    {
4356
        return *this;
4357
    }
4358

4359
    /// increment operator (needed for range-based for)
4360
    iteration_proxy_value& operator++()
4361
    {
4362
        ++anchor;
4363
        ++array_index;
4364

4365
        return *this;
4366
    }
4367

4368
    /// equality operator (needed for InputIterator)
4369
    bool operator==(const iteration_proxy_value& o) const
4370
    {
4371
        return anchor == o.anchor;
4372
    }
4373

4374
    /// inequality operator (needed for range-based for)
4375
    bool operator!=(const iteration_proxy_value& o) const
4376
    {
4377
        return anchor != o.anchor;
4378
    }
4379

4380
    /// return key of the iterator
4381
    const string_type& key() const
4382
    {
4383
        JSON_ASSERT(anchor.m_object != nullptr);
4384

4385
        switch (anchor.m_object->type())
4386
        {
4387
            // use integer array index as key
4388
            case value_t::array:
4389
            {
4390
                if (array_index != array_index_last)
4391
                {
4392
                    int_to_string( array_index_str, array_index );
4393
                    array_index_last = array_index;
4394
                }
4395
                return array_index_str;
4396
            }
4397

4398
            // use key from the object
4399
            case value_t::object:
4400
                return anchor.key();
4401

4402
            // use an empty key for all primitive types
4403
            case value_t::null:
4404
            case value_t::string:
4405
            case value_t::boolean:
4406
            case value_t::number_integer:
4407
            case value_t::number_unsigned:
4408
            case value_t::number_float:
4409
            case value_t::binary:
4410
            case value_t::discarded:
4411
            default:
4412
                return empty_str;
4413
        }
4414
    }
4415

4416
    /// return value of the iterator
4417
    typename IteratorType::reference value() const
4418
    {
4419
        return anchor.value();
4420
    }
4421
};
4422

4423
/// proxy class for the items() function
4424
template<typename IteratorType> class iteration_proxy
4425
{
4426
  private:
4427
    /// the container to iterate
4428
    typename IteratorType::reference container;
4429

4430
  public:
4431
    /// construct iteration proxy from a container
4432
    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
4433
        : container(cont) {}
4434

4435
    /// return iterator begin (needed for range-based for)
4436
    iteration_proxy_value<IteratorType> begin() noexcept
4437
    {
4438
        return iteration_proxy_value<IteratorType>(container.begin());
4439
    }
4440

4441
    /// return iterator end (needed for range-based for)
4442
    iteration_proxy_value<IteratorType> end() noexcept
4443
    {
4444
        return iteration_proxy_value<IteratorType>(container.end());
4445
    }
4446
};
4447
// Structured Bindings Support
4448
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
4449
// And see https://github.com/nlohmann/json/pull/1391
4450
template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
4451
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
4452
{
4453
    return i.key();
4454
}
4455
// Structured Bindings Support
4456
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
4457
// And see https://github.com/nlohmann/json/pull/1391
4458
template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
4459
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
4460
{
4461
    return i.value();
4462
}
4463
}  // namespace detail
4464
}  // namespace nlohmann
4465

4466
// The Addition to the STD Namespace is required to add
4467
// Structured Bindings Support to the iteration_proxy_value class
4468
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
4469
// And see https://github.com/nlohmann/json/pull/1391
4470
namespace std
4471
{
4472
#if defined(__clang__)
4473
    // Fix: https://github.com/nlohmann/json/issues/1401
4474
    #pragma clang diagnostic push
4475
    #pragma clang diagnostic ignored "-Wmismatched-tags"
4476
#endif
4477
template<typename IteratorType>
4478
class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
4479
            : public std::integral_constant<std::size_t, 2> {};
4480

4481
template<std::size_t N, typename IteratorType>
4482
class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
4483
{
4484
  public:
4485
    using type = decltype(
4486
                     get<N>(std::declval <
4487
                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
4488
};
4489
#if defined(__clang__)
4490
    #pragma clang diagnostic pop
4491
#endif
4492
} // namespace std
4493

4494
// #include <nlohmann/detail/meta/cpp_future.hpp>
4495

4496
// #include <nlohmann/detail/meta/type_traits.hpp>
4497

4498
// #include <nlohmann/detail/value_t.hpp>
4499

4500

4501
#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
4502
#include <experimental/filesystem>
4503
namespace nlohmann::detail
4504
{
4505
namespace std_fs = std::experimental::filesystem;
4506
} // namespace nlohmann::detail
4507
#elif JSON_HAS_FILESYSTEM
4508
#include <filesystem>
4509
namespace nlohmann::detail
4510
{
4511
namespace std_fs = std::filesystem;
4512
} // namespace nlohmann::detail
4513
#endif
4514

4515
namespace nlohmann
4516
{
4517
namespace detail
4518
{
4519
//////////////////
4520
// constructors //
4521
//////////////////
4522

4523
/*
4524
 * Note all external_constructor<>::construct functions need to call
4525
 * j.m_value.destroy(j.m_type) to avoid a memory leak in case j contains an
4526
 * allocated value (e.g., a string). See bug issue
4527
 * https://github.com/nlohmann/json/issues/2865 for more information.
4528
 */
4529

4530
template<value_t> struct external_constructor;
4531

4532
template<>
4533
struct external_constructor<value_t::boolean>
4534
{
4535
    template<typename BasicJsonType>
4536
    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
4537
    {
4538
        j.m_value.destroy(j.m_type);
4539
        j.m_type = value_t::boolean;
4540
        j.m_value = b;
4541
        j.assert_invariant();
4542
    }
4543
};
4544

4545
template<>
4546
struct external_constructor<value_t::string>
4547
{
4548
    template<typename BasicJsonType>
4549
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
4550
    {
4551
        j.m_value.destroy(j.m_type);
4552
        j.m_type = value_t::string;
4553
        j.m_value = s;
4554
        j.assert_invariant();
4555
    }
4556

4557
    template<typename BasicJsonType>
4558
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4559
    {
4560
        j.m_value.destroy(j.m_type);
4561
        j.m_type = value_t::string;
4562
        j.m_value = std::move(s);
4563
        j.assert_invariant();
4564
    }
4565

4566
    template < typename BasicJsonType, typename CompatibleStringType,
4567
               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4568
                             int > = 0 >
4569
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
4570
    {
4571
        j.m_value.destroy(j.m_type);
4572
        j.m_type = value_t::string;
4573
        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4574
        j.assert_invariant();
4575
    }
4576
};
4577

4578
template<>
4579
struct external_constructor<value_t::binary>
4580
{
4581
    template<typename BasicJsonType>
4582
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
4583
    {
4584
        j.m_value.destroy(j.m_type);
4585
        j.m_type = value_t::binary;
4586
        j.m_value = typename BasicJsonType::binary_t(b);
4587
        j.assert_invariant();
4588
    }
4589

4590
    template<typename BasicJsonType>
4591
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
4592
    {
4593
        j.m_value.destroy(j.m_type);
4594
        j.m_type = value_t::binary;
4595
        j.m_value = typename BasicJsonType::binary_t(std::move(b));
4596
        j.assert_invariant();
4597
    }
4598
};
4599

4600
template<>
4601
struct external_constructor<value_t::number_float>
4602
{
4603
    template<typename BasicJsonType>
4604
    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
4605
    {
4606
        j.m_value.destroy(j.m_type);
4607
        j.m_type = value_t::number_float;
4608
        j.m_value = val;
4609
        j.assert_invariant();
4610
    }
4611
};
4612

4613
template<>
4614
struct external_constructor<value_t::number_unsigned>
4615
{
4616
    template<typename BasicJsonType>
4617
    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
4618
    {
4619
        j.m_value.destroy(j.m_type);
4620
        j.m_type = value_t::number_unsigned;
4621
        j.m_value = val;
4622
        j.assert_invariant();
4623
    }
4624
};
4625

4626
template<>
4627
struct external_constructor<value_t::number_integer>
4628
{
4629
    template<typename BasicJsonType>
4630
    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
4631
    {
4632
        j.m_value.destroy(j.m_type);
4633
        j.m_type = value_t::number_integer;
4634
        j.m_value = val;
4635
        j.assert_invariant();
4636
    }
4637
};
4638

4639
template<>
4640
struct external_constructor<value_t::array>
4641
{
4642
    template<typename BasicJsonType>
4643
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
4644
    {
4645
        j.m_value.destroy(j.m_type);
4646
        j.m_type = value_t::array;
4647
        j.m_value = arr;
4648
        j.set_parents();
4649
        j.assert_invariant();
4650
    }
4651

4652
    template<typename BasicJsonType>
4653
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4654
    {
4655
        j.m_value.destroy(j.m_type);
4656
        j.m_type = value_t::array;
4657
        j.m_value = std::move(arr);
4658
        j.set_parents();
4659
        j.assert_invariant();
4660
    }
4661

4662
    template < typename BasicJsonType, typename CompatibleArrayType,
4663
               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4664
                             int > = 0 >
4665
    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
4666
    {
4667
        using std::begin;
4668
        using std::end;
4669

4670
        j.m_value.destroy(j.m_type);
4671
        j.m_type = value_t::array;
4672
        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4673
        j.set_parents();
4674
        j.assert_invariant();
4675
    }
4676

4677
    template<typename BasicJsonType>
4678
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
4679
    {
4680
        j.m_value.destroy(j.m_type);
4681
        j.m_type = value_t::array;
4682
        j.m_value = value_t::array;
4683
        j.m_value.array->reserve(arr.size());
4684
        for (const bool x : arr)
4685
        {
4686
            j.m_value.array->push_back(x);
4687
            j.set_parent(j.m_value.array->back());
4688
        }
4689
        j.assert_invariant();
4690
    }
4691

4692
    template<typename BasicJsonType, typename T,
4693
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
4694
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
4695
    {
4696
        j.m_value.destroy(j.m_type);
4697
        j.m_type = value_t::array;
4698
        j.m_value = value_t::array;
4699
        j.m_value.array->resize(arr.size());
4700
        if (arr.size() > 0)
4701
        {
4702
            std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4703
        }
4704
        j.set_parents();
4705
        j.assert_invariant();
4706
    }
4707
};
4708

4709
template<>
4710
struct external_constructor<value_t::object>
4711
{
4712
    template<typename BasicJsonType>
4713
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
4714
    {
4715
        j.m_value.destroy(j.m_type);
4716
        j.m_type = value_t::object;
4717
        j.m_value = obj;
4718
        j.set_parents();
4719
        j.assert_invariant();
4720
    }
4721

4722
    template<typename BasicJsonType>
4723
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4724
    {
4725
        j.m_value.destroy(j.m_type);
4726
        j.m_type = value_t::object;
4727
        j.m_value = std::move(obj);
4728
        j.set_parents();
4729
        j.assert_invariant();
4730
    }
4731

4732
    template < typename BasicJsonType, typename CompatibleObjectType,
4733
               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
4734
    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
4735
    {
4736
        using std::begin;
4737
        using std::end;
4738

4739
        j.m_value.destroy(j.m_type);
4740
        j.m_type = value_t::object;
4741
        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4742
        j.set_parents();
4743
        j.assert_invariant();
4744
    }
4745
};
4746

4747
/////////////
4748
// to_json //
4749
/////////////
4750

4751
template<typename BasicJsonType, typename T,
4752
         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
4753
void to_json(BasicJsonType& j, T b) noexcept
4754
{
4755
    external_constructor<value_t::boolean>::construct(j, b);
4756
}
4757

4758
template<typename BasicJsonType, typename CompatibleString,
4759
         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
4760
void to_json(BasicJsonType& j, const CompatibleString& s)
4761
{
4762
    external_constructor<value_t::string>::construct(j, s);
4763
}
4764

4765
template<typename BasicJsonType>
4766
void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4767
{
4768
    external_constructor<value_t::string>::construct(j, std::move(s));
4769
}
4770

4771
template<typename BasicJsonType, typename FloatType,
4772
         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
4773
void to_json(BasicJsonType& j, FloatType val) noexcept
4774
{
4775
    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
4776
}
4777

4778
template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
4779
         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
4780
void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4781
{
4782
    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
4783
}
4784

4785
template<typename BasicJsonType, typename CompatibleNumberIntegerType,
4786
         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
4787
void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4788
{
4789
    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
4790
}
4791

4792
template<typename BasicJsonType, typename EnumType,
4793
         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
4794
void to_json(BasicJsonType& j, EnumType e) noexcept
4795
{
4796
    using underlying_type = typename std::underlying_type<EnumType>::type;
4797
    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
4798
}
4799

4800
template<typename BasicJsonType>
4801
void to_json(BasicJsonType& j, const std::vector<bool>& e)
4802
{
4803
    external_constructor<value_t::array>::construct(j, e);
4804
}
4805

4806
template < typename BasicJsonType, typename CompatibleArrayType,
4807
           enable_if_t < is_compatible_array_type<BasicJsonType,
4808
                         CompatibleArrayType>::value&&
4809
                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4810
                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4811
                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4812
                         !is_basic_json<CompatibleArrayType>::value,
4813
                         int > = 0 >
4814
void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
4815
{
4816
    external_constructor<value_t::array>::construct(j, arr);
4817
}
4818

4819
template<typename BasicJsonType>
4820
void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
4821
{
4822
    external_constructor<value_t::binary>::construct(j, bin);
4823
}
4824

4825
template<typename BasicJsonType, typename T,
4826
         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
4827
void to_json(BasicJsonType& j, const std::valarray<T>& arr)
4828
{
4829
    external_constructor<value_t::array>::construct(j, std::move(arr));
4830
}
4831

4832
template<typename BasicJsonType>
4833
void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4834
{
4835
    external_constructor<value_t::array>::construct(j, std::move(arr));
4836
}
4837

4838
template < typename BasicJsonType, typename CompatibleObjectType,
4839
           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
4840
void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
4841
{
4842
    external_constructor<value_t::object>::construct(j, obj);
4843
}
4844

4845
template<typename BasicJsonType>
4846
void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4847
{
4848
    external_constructor<value_t::object>::construct(j, std::move(obj));
4849
}
4850

4851
template <
4852
    typename BasicJsonType, typename T, std::size_t N,
4853
    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
4854
                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4855
                  int > = 0 >
4856
void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4857
{
4858
    external_constructor<value_t::array>::construct(j, arr);
4859
}
4860

4861
template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
4862
void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
4863
{
4864
    j = { p.first, p.second };
4865
}
4866

4867
// for https://github.com/nlohmann/json/pull/1134
4868
template<typename BasicJsonType, typename T,
4869
         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
4870
void to_json(BasicJsonType& j, const T& b)
4871
{
4872
    j = { {b.key(), b.value()} };
4873
}
4874

4875
template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
4876
void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
4877
{
4878
    j = { std::get<Idx>(t)... };
4879
}
4880

4881
template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
4882
void to_json(BasicJsonType& j, const T& t)
4883
{
4884
    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4885
}
4886

4887
#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
4888
template<typename BasicJsonType>
4889
void to_json(BasicJsonType& j, const std_fs::path& p)
4890
{
4891
    j = p.string();
4892
}
4893
#endif
4894

4895
struct to_json_fn
4896
{
4897
    template<typename BasicJsonType, typename T>
4898
    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
4899
    -> decltype(to_json(j, std::forward<T>(val)), void())
4900
    {
4901
        return to_json(j, std::forward<T>(val));
4902
    }
4903
};
4904
}  // namespace detail
4905

4906
/// namespace to hold default `to_json` function
4907
/// to see why this is required:
4908
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
4909
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
4910
{
4911
constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value; // NOLINT(misc-definitions-in-headers)
4912
} // namespace
4913
} // namespace nlohmann
4914

4915
// #include <nlohmann/detail/meta/identity_tag.hpp>
4916

4917
// #include <nlohmann/detail/meta/type_traits.hpp>
4918

4919

4920
namespace nlohmann
4921
{
4922

4923
/// @sa https://json.nlohmann.me/api/adl_serializer/
4924
template<typename ValueType, typename>
4925
struct adl_serializer
4926
{
4927
    /// @brief convert a JSON value to any value type
4928
    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
4929
    template<typename BasicJsonType, typename TargetType = ValueType>
4930
    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
4931
        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4932
    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
4933
    {
4934
        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4935
    }
4936

4937
    /// @brief convert a JSON value to any value type
4938
    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
4939
    template<typename BasicJsonType, typename TargetType = ValueType>
4940
    static auto from_json(BasicJsonType && j) noexcept(
4941
    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
4942
    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
4943
    {
4944
        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
4945
    }
4946

4947
    /// @brief convert any value type to a JSON value
4948
    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
4949
    template<typename BasicJsonType, typename TargetType = ValueType>
4950
    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
4951
        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
4952
    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
4953
    {
4954
        ::nlohmann::to_json(j, std::forward<TargetType>(val));
4955
    }
4956
};
4957
}  // namespace nlohmann
4958

4959
// #include <nlohmann/byte_container_with_subtype.hpp>
4960

4961

4962
#include <cstdint> // uint8_t, uint64_t
4963
#include <tuple> // tie
4964
#include <utility> // move
4965

4966
namespace nlohmann
4967
{
4968

4969
/// @brief an internal type for a backed binary type
4970
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
4971
template<typename BinaryType>
4972
class byte_container_with_subtype : public BinaryType
4973
{
4974
  public:
4975
    using container_type = BinaryType;
4976
    using subtype_type = std::uint64_t;
4977

4978
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4979
    byte_container_with_subtype() noexcept(noexcept(container_type()))
4980
        : container_type()
4981
    {}
4982

4983
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4984
    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
4985
        : container_type(b)
4986
    {}
4987

4988
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4989
    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
4990
        : container_type(std::move(b))
4991
    {}
4992

4993
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4994
    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
4995
        : container_type(b)
4996
        , m_subtype(subtype_)
4997
        , m_has_subtype(true)
4998
    {}
4999

5000
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
5001
    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
5002
        : container_type(std::move(b))
5003
        , m_subtype(subtype_)
5004
        , m_has_subtype(true)
5005
    {}
5006

5007
    bool operator==(const byte_container_with_subtype& rhs) const
5008
    {
5009
        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
5010
               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
5011
    }
5012

5013
    bool operator!=(const byte_container_with_subtype& rhs) const
5014
    {
5015
        return !(rhs == *this);
5016
    }
5017

5018
    /// @brief sets the binary subtype
5019
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
5020
    void set_subtype(subtype_type subtype_) noexcept
5021
    {
5022
        m_subtype = subtype_;
5023
        m_has_subtype = true;
5024
    }
5025

5026
    /// @brief return the binary subtype
5027
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
5028
    constexpr subtype_type subtype() const noexcept
5029
    {
5030
        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
5031
    }
5032

5033
    /// @brief return whether the value has a subtype
5034
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
5035
    constexpr bool has_subtype() const noexcept
5036
    {
5037
        return m_has_subtype;
5038
    }
5039

5040
    /// @brief clears the binary subtype
5041
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
5042
    void clear_subtype() noexcept
5043
    {
5044
        m_subtype = 0;
5045
        m_has_subtype = false;
5046
    }
5047

5048
  private:
5049
    subtype_type m_subtype = 0;
5050
    bool m_has_subtype = false;
5051
};
5052

5053
}  // namespace nlohmann
5054

5055
// #include <nlohmann/detail/conversions/from_json.hpp>
5056

5057
// #include <nlohmann/detail/conversions/to_json.hpp>
5058

5059
// #include <nlohmann/detail/exceptions.hpp>
5060

5061
// #include <nlohmann/detail/hash.hpp>
5062

5063

5064
#include <cstdint> // uint8_t
5065
#include <cstddef> // size_t
5066
#include <functional> // hash
5067

5068
// #include <nlohmann/detail/macro_scope.hpp>
5069

5070
// #include <nlohmann/detail/value_t.hpp>
5071

5072

5073
namespace nlohmann
5074
{
5075
namespace detail
5076
{
5077

5078
// boost::hash_combine
5079
inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
5080
{
5081
    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
5082
    return seed;
5083
}
5084

5085
/*!
5086
@brief hash a JSON value
5087

5088
The hash function tries to rely on std::hash where possible. Furthermore, the
5089
type of the JSON value is taken into account to have different hash values for
5090
null, 0, 0U, and false, etc.
5091

5092
@tparam BasicJsonType basic_json specialization
5093
@param j JSON value to hash
5094
@return hash value of j
5095
*/
5096
template<typename BasicJsonType>
5097
std::size_t hash(const BasicJsonType& j)
5098
{
5099
    using string_t = typename BasicJsonType::string_t;
5100
    using number_integer_t = typename BasicJsonType::number_integer_t;
5101
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5102
    using number_float_t = typename BasicJsonType::number_float_t;
5103

5104
    const auto type = static_cast<std::size_t>(j.type());
5105
    switch (j.type())
5106
    {
5107
        case BasicJsonType::value_t::null:
5108
        case BasicJsonType::value_t::discarded:
5109
        {
5110
            return combine(type, 0);
5111
        }
5112

5113
        case BasicJsonType::value_t::object:
5114
        {
5115
            auto seed = combine(type, j.size());
5116
            for (const auto& element : j.items())
5117
            {
5118
                const auto h = std::hash<string_t> {}(element.key());
5119
                seed = combine(seed, h);
5120
                seed = combine(seed, hash(element.value()));
5121
            }
5122
            return seed;
5123
        }
5124

5125
        case BasicJsonType::value_t::array:
5126
        {
5127
            auto seed = combine(type, j.size());
5128
            for (const auto& element : j)
5129
            {
5130
                seed = combine(seed, hash(element));
5131
            }
5132
            return seed;
5133
        }
5134

5135
        case BasicJsonType::value_t::string:
5136
        {
5137
            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5138
            return combine(type, h);
5139
        }
5140

5141
        case BasicJsonType::value_t::boolean:
5142
        {
5143
            const auto h = std::hash<bool> {}(j.template get<bool>());
5144
            return combine(type, h);
5145
        }
5146

5147
        case BasicJsonType::value_t::number_integer:
5148
        {
5149
            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
5150
            return combine(type, h);
5151
        }
5152

5153
        case BasicJsonType::value_t::number_unsigned:
5154
        {
5155
            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
5156
            return combine(type, h);
5157
        }
5158

5159
        case BasicJsonType::value_t::number_float:
5160
        {
5161
            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
5162
            return combine(type, h);
5163
        }
5164

5165
        case BasicJsonType::value_t::binary:
5166
        {
5167
            auto seed = combine(type, j.get_binary().size());
5168
            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
5169
            seed = combine(seed, h);
5170
            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
5171
            for (const auto byte : j.get_binary())
5172
            {
5173
                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
5174
            }
5175
            return seed;
5176
        }
5177

5178
        default:                   // LCOV_EXCL_LINE
5179
            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
5180
            return 0;              // LCOV_EXCL_LINE
5181
    }
5182
}
5183

5184
}  // namespace detail
5185
}  // namespace nlohmann
5186

5187
// #include <nlohmann/detail/input/binary_reader.hpp>
5188

5189

5190
#include <algorithm> // generate_n
5191
#include <array> // array
5192
#include <cmath> // ldexp
5193
#include <cstddef> // size_t
5194
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
5195
#include <cstdio> // snprintf
5196
#include <cstring> // memcpy
5197
#include <iterator> // back_inserter
5198
#include <limits> // numeric_limits
5199
#include <string> // char_traits, string
5200
#include <utility> // make_pair, move
5201
#include <vector> // vector
5202

5203
// #include <nlohmann/detail/exceptions.hpp>
5204

5205
// #include <nlohmann/detail/input/input_adapters.hpp>
5206

5207

5208
#include <array> // array
5209
#include <cstddef> // size_t
5210
#include <cstring> // strlen
5211
#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
5212
#include <memory> // shared_ptr, make_shared, addressof
5213
#include <numeric> // accumulate
5214
#include <string> // string, char_traits
5215
#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
5216
#include <utility> // pair, declval
5217

5218
#ifndef JSON_NO_IO
5219
    #include <cstdio>   // FILE *
5220
    #include <istream>  // istream
5221
#endif                  // JSON_NO_IO
5222

5223
// #include <nlohmann/detail/iterators/iterator_traits.hpp>
5224

5225
// #include <nlohmann/detail/macro_scope.hpp>
5226

5227

5228
namespace nlohmann
5229
{
5230
namespace detail
5231
{
5232
/// the supported input formats
5233
enum class input_format_t { json, cbor, msgpack, ubjson, bson };
5234

5235
////////////////////
5236
// input adapters //
5237
////////////////////
5238

5239
#ifndef JSON_NO_IO
5240
/*!
5241
Input adapter for stdio file access. This adapter read only 1 byte and do not use any
5242
 buffer. This adapter is a very low level adapter.
5243
*/
5244
class file_input_adapter
5245
{
5246
  public:
5247
    using char_type = char;
5248

5249
    JSON_HEDLEY_NON_NULL(2)
5250
    explicit file_input_adapter(std::FILE* f) noexcept
5251
        : m_file(f)
5252
    {}
5253

5254
    // make class move-only
5255
    file_input_adapter(const file_input_adapter&) = delete;
5256
    file_input_adapter(file_input_adapter&&) noexcept = default;
5257
    file_input_adapter& operator=(const file_input_adapter&) = delete;
5258
    file_input_adapter& operator=(file_input_adapter&&) = delete;
5259
    ~file_input_adapter() = default;
5260

5261
    std::char_traits<char>::int_type get_character() noexcept
5262
    {
5263
        return std::fgetc(m_file);
5264
    }
5265

5266
  private:
5267
    /// the file pointer to read from
5268
    std::FILE* m_file;
5269
};
5270

5271

5272
/*!
5273
Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
5274
beginning of input. Does not support changing the underlying std::streambuf
5275
in mid-input. Maintains underlying std::istream and std::streambuf to support
5276
subsequent use of standard std::istream operations to process any input
5277
characters following those used in parsing the JSON input.  Clears the
5278
std::istream flags; any input errors (e.g., EOF) will be detected by the first
5279
subsequent call for input from the std::istream.
5280
*/
5281
class input_stream_adapter
5282
{
5283
  public:
5284
    using char_type = char;
5285

5286
    ~input_stream_adapter()
5287
    {
5288
        // clear stream flags; we use underlying streambuf I/O, do not
5289
        // maintain ifstream flags, except eof
5290
        if (is != nullptr)
5291
        {
5292
            is->clear(is->rdstate() & std::ios::eofbit);
5293
        }
5294
    }
5295

5296
    explicit input_stream_adapter(std::istream& i)
5297
        : is(&i), sb(i.rdbuf())
5298
    {}
5299

5300
    // delete because of pointer members
5301
    input_stream_adapter(const input_stream_adapter&) = delete;
5302
    input_stream_adapter& operator=(input_stream_adapter&) = delete;
5303
    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
5304

5305
    input_stream_adapter(input_stream_adapter&& rhs) noexcept
5306
        : is(rhs.is), sb(rhs.sb)
5307
    {
5308
        rhs.is = nullptr;
5309
        rhs.sb = nullptr;
5310
    }
5311

5312
    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
5313
    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
5314
    // end up as the same value, e.g. 0xFFFFFFFF.
5315
    std::char_traits<char>::int_type get_character()
5316
    {
5317
        auto res = sb->sbumpc();
5318
        // set eof manually, as we don't use the istream interface.
5319
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
5320
        {
5321
            is->clear(is->rdstate() | std::ios::eofbit);
5322
        }
5323
        return res;
5324
    }
5325

5326
  private:
5327
    /// the associated input stream
5328
    std::istream* is = nullptr;
5329
    std::streambuf* sb = nullptr;
5330
};
5331
#endif  // JSON_NO_IO
5332

5333
// General-purpose iterator-based adapter. It might not be as fast as
5334
// theoretically possible for some containers, but it is extremely versatile.
5335
template<typename IteratorType>
5336
class iterator_input_adapter
5337
{
5338
  public:
5339
    using char_type = typename std::iterator_traits<IteratorType>::value_type;
5340

5341
    iterator_input_adapter(IteratorType first, IteratorType last)
5342
        : current(std::move(first)), end(std::move(last))
5343
    {}
5344

5345
    typename std::char_traits<char_type>::int_type get_character()
5346
    {
5347
        if (JSON_HEDLEY_LIKELY(current != end))
5348
        {
5349
            auto result = std::char_traits<char_type>::to_int_type(*current);
5350
            std::advance(current, 1);
5351
            return result;
5352
        }
5353

5354
        return std::char_traits<char_type>::eof();
5355
    }
5356

5357
  private:
5358
    IteratorType current;
5359
    IteratorType end;
5360

5361
    template<typename BaseInputAdapter, size_t T>
5362
    friend struct wide_string_input_helper;
5363

5364
    bool empty() const
5365
    {
5366
        return current == end;
5367
    }
5368
};
5369

5370

5371
template<typename BaseInputAdapter, size_t T>
5372
struct wide_string_input_helper;
5373

5374
template<typename BaseInputAdapter>
5375
struct wide_string_input_helper<BaseInputAdapter, 4>
5376
{
5377
    // UTF-32
5378
    static void fill_buffer(BaseInputAdapter& input,
5379
                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5380
                            size_t& utf8_bytes_index,
5381
                            size_t& utf8_bytes_filled)
5382
    {
5383
        utf8_bytes_index = 0;
5384

5385
        if (JSON_HEDLEY_UNLIKELY(input.empty()))
5386
        {
5387
            utf8_bytes[0] = std::char_traits<char>::eof();
5388
            utf8_bytes_filled = 1;
5389
        }
5390
        else
5391
        {
5392
            // get the current character
5393
            const auto wc = input.get_character();
5394

5395
            // UTF-32 to UTF-8 encoding
5396
            if (wc < 0x80)
5397
            {
5398
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5399
                utf8_bytes_filled = 1;
5400
            }
5401
            else if (wc <= 0x7FF)
5402
            {
5403
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
5404
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5405
                utf8_bytes_filled = 2;
5406
            }
5407
            else if (wc <= 0xFFFF)
5408
            {
5409
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
5410
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5411
                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5412
                utf8_bytes_filled = 3;
5413
            }
5414
            else if (wc <= 0x10FFFF)
5415
            {
5416
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
5417
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
5418
                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5419
                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5420
                utf8_bytes_filled = 4;
5421
            }
5422
            else
5423
            {
5424
                // unknown character
5425
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5426
                utf8_bytes_filled = 1;
5427
            }
5428
        }
5429
    }
5430
};
5431

5432
template<typename BaseInputAdapter>
5433
struct wide_string_input_helper<BaseInputAdapter, 2>
5434
{
5435
    // UTF-16
5436
    static void fill_buffer(BaseInputAdapter& input,
5437
                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5438
                            size_t& utf8_bytes_index,
5439
                            size_t& utf8_bytes_filled)
5440
    {
5441
        utf8_bytes_index = 0;
5442

5443
        if (JSON_HEDLEY_UNLIKELY(input.empty()))
5444
        {
5445
            utf8_bytes[0] = std::char_traits<char>::eof();
5446
            utf8_bytes_filled = 1;
5447
        }
5448
        else
5449
        {
5450
            // get the current character
5451
            const auto wc = input.get_character();
5452

5453
            // UTF-16 to UTF-8 encoding
5454
            if (wc < 0x80)
5455
            {
5456
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5457
                utf8_bytes_filled = 1;
5458
            }
5459
            else if (wc <= 0x7FF)
5460
            {
5461
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
5462
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5463
                utf8_bytes_filled = 2;
5464
            }
5465
            else if (0xD800 > wc || wc >= 0xE000)
5466
            {
5467
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
5468
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5469
                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5470
                utf8_bytes_filled = 3;
5471
            }
5472
            else
5473
            {
5474
                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
5475
                {
5476
                    const auto wc2 = static_cast<unsigned int>(input.get_character());
5477
                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
5478
                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
5479
                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
5480
                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
5481
                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
5482
                    utf8_bytes_filled = 4;
5483
                }
5484
                else
5485
                {
5486
                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5487
                    utf8_bytes_filled = 1;
5488
                }
5489
            }
5490
        }
5491
    }
5492
};
5493

5494
// Wraps another input apdater to convert wide character types into individual bytes.
5495
template<typename BaseInputAdapter, typename WideCharType>
5496
class wide_string_input_adapter
5497
{
5498
  public:
5499
    using char_type = char;
5500

5501
    wide_string_input_adapter(BaseInputAdapter base)
5502
        : base_adapter(base) {}
5503

5504
    typename std::char_traits<char>::int_type get_character() noexcept
5505
    {
5506
        // check if buffer needs to be filled
5507
        if (utf8_bytes_index == utf8_bytes_filled)
5508
        {
5509
            fill_buffer<sizeof(WideCharType)>();
5510

5511
            JSON_ASSERT(utf8_bytes_filled > 0);
5512
            JSON_ASSERT(utf8_bytes_index == 0);
5513
        }
5514

5515
        // use buffer
5516
        JSON_ASSERT(utf8_bytes_filled > 0);
5517
        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5518
        return utf8_bytes[utf8_bytes_index++];
5519
    }
5520

5521
  private:
5522
    BaseInputAdapter base_adapter;
5523

5524
    template<size_t T>
5525
    void fill_buffer()
5526
    {
5527
        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
5528
    }
5529

5530
    /// a buffer for UTF-8 bytes
5531
    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5532

5533
    /// index to the utf8_codes array for the next valid byte
5534
    std::size_t utf8_bytes_index = 0;
5535
    /// number of valid bytes in the utf8_codes array
5536
    std::size_t utf8_bytes_filled = 0;
5537
};
5538

5539

5540
template<typename IteratorType, typename Enable = void>
5541
struct iterator_input_adapter_factory
5542
{
5543
    using iterator_type = IteratorType;
5544
    using char_type = typename std::iterator_traits<iterator_type>::value_type;
5545
    using adapter_type = iterator_input_adapter<iterator_type>;
5546

5547
    static adapter_type create(IteratorType first, IteratorType last)
5548
    {
5549
        return adapter_type(std::move(first), std::move(last));
5550
    }
5551
};
5552

5553
template<typename T>
5554
struct is_iterator_of_multibyte
5555
{
5556
    using value_type = typename std::iterator_traits<T>::value_type;
5557
    enum
5558
    {
5559
        value = sizeof(value_type) > 1
5560
    };
5561
};
5562

5563
template<typename IteratorType>
5564
struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5565
{
5566
    using iterator_type = IteratorType;
5567
    using char_type = typename std::iterator_traits<iterator_type>::value_type;
5568
    using base_adapter_type = iterator_input_adapter<iterator_type>;
5569
    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
5570

5571
    static adapter_type create(IteratorType first, IteratorType last)
5572
    {
5573
        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5574
    }
5575
};
5576

5577
// General purpose iterator-based input
5578
template<typename IteratorType>
5579
typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5580
{
5581
    using factory_type = iterator_input_adapter_factory<IteratorType>;
5582
    return factory_type::create(first, last);
5583
}
5584

5585
// Convenience shorthand from container to iterator
5586
// Enables ADL on begin(container) and end(container)
5587
// Encloses the using declarations in namespace for not to leak them to outside scope
5588

5589
namespace container_input_adapter_factory_impl
5590
{
5591

5592
using std::begin;
5593
using std::end;
5594

5595
template<typename ContainerType, typename Enable = void>
5596
struct container_input_adapter_factory {};
5597

5598
template<typename ContainerType>
5599
struct container_input_adapter_factory< ContainerType,
5600
       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
5601
       {
5602
           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
5603

5604
           static adapter_type create(const ContainerType& container)
5605
{
5606
    return input_adapter(begin(container), end(container));
5607
}
5608
       };
5609

5610
} // namespace container_input_adapter_factory_impl
5611

5612
template<typename ContainerType>
5613
typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
5614
{
5615
    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
5616
}
5617

5618
#ifndef JSON_NO_IO
5619
// Special cases with fast paths
5620
inline file_input_adapter input_adapter(std::FILE* file)
5621
{
5622
    return file_input_adapter(file);
5623
}
5624

5625
inline input_stream_adapter input_adapter(std::istream& stream)
5626
{
5627
    return input_stream_adapter(stream);
5628
}
5629

5630
inline input_stream_adapter input_adapter(std::istream&& stream)
5631
{
5632
    return input_stream_adapter(stream);
5633
}
5634
#endif  // JSON_NO_IO
5635

5636
using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5637

5638
// Null-delimited strings, and the like.
5639
template < typename CharT,
5640
           typename std::enable_if <
5641
               std::is_pointer<CharT>::value&&
5642
               !std::is_array<CharT>::value&&
5643
               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5644
               sizeof(typename std::remove_pointer<CharT>::type) == 1,
5645
               int >::type = 0 >
5646
contiguous_bytes_input_adapter input_adapter(CharT b)
5647
{
5648
    auto length = std::strlen(reinterpret_cast<const char*>(b));
5649
    const auto* ptr = reinterpret_cast<const char*>(b);
5650
    return input_adapter(ptr, ptr + length);
5651
}
5652

5653
template<typename T, std::size_t N>
5654
auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5655
{
5656
    return input_adapter(array, array + N);
5657
}
5658

5659
// This class only handles inputs of input_buffer_adapter type.
5660
// It's required so that expressions like {ptr, len} can be implicitly cast
5661
// to the correct adapter.
5662
class span_input_adapter
5663
{
5664
  public:
5665
    template < typename CharT,
5666
               typename std::enable_if <
5667
                   std::is_pointer<CharT>::value&&
5668
                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5669
                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
5670
                   int >::type = 0 >
5671
    span_input_adapter(CharT b, std::size_t l)
5672
        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5673

5674
    template<class IteratorType,
5675
             typename std::enable_if<
5676
                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5677
                 int>::type = 0>
5678
    span_input_adapter(IteratorType first, IteratorType last)
5679
        : ia(input_adapter(first, last)) {}
5680

5681
    contiguous_bytes_input_adapter&& get()
5682
    {
5683
        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
5684
    }
5685

5686
  private:
5687
    contiguous_bytes_input_adapter ia;
5688
};
5689
}  // namespace detail
5690
}  // namespace nlohmann
5691

5692
// #include <nlohmann/detail/input/json_sax.hpp>
5693

5694

5695
#include <cstddef>
5696
#include <string> // string
5697
#include <utility> // move
5698
#include <vector> // vector
5699

5700
// #include <nlohmann/detail/exceptions.hpp>
5701

5702
// #include <nlohmann/detail/macro_scope.hpp>
5703

5704

5705
namespace nlohmann
5706
{
5707

5708
/*!
5709
@brief SAX interface
5710

5711
This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
5712
Each function is called in different situations while the input is parsed. The
5713
boolean return value informs the parser whether to continue processing the
5714
input.
5715
*/
5716
template<typename BasicJsonType>
5717
struct json_sax
5718
{
5719
    using number_integer_t = typename BasicJsonType::number_integer_t;
5720
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5721
    using number_float_t = typename BasicJsonType::number_float_t;
5722
    using string_t = typename BasicJsonType::string_t;
5723
    using binary_t = typename BasicJsonType::binary_t;
5724

5725
    /*!
5726
    @brief a null value was read
5727
    @return whether parsing should proceed
5728
    */
5729
    virtual bool null() = 0;
5730

5731
    /*!
5732
    @brief a boolean value was read
5733
    @param[in] val  boolean value
5734
    @return whether parsing should proceed
5735
    */
5736
    virtual bool boolean(bool val) = 0;
5737

5738
    /*!
5739
    @brief an integer number was read
5740
    @param[in] val  integer value
5741
    @return whether parsing should proceed
5742
    */
5743
    virtual bool number_integer(number_integer_t val) = 0;
5744

5745
    /*!
5746
    @brief an unsigned integer number was read
5747
    @param[in] val  unsigned integer value
5748
    @return whether parsing should proceed
5749
    */
5750
    virtual bool number_unsigned(number_unsigned_t val) = 0;
5751

5752
    /*!
5753
    @brief a floating-point number was read
5754
    @param[in] val  floating-point value
5755
    @param[in] s    raw token value
5756
    @return whether parsing should proceed
5757
    */
5758
    virtual bool number_float(number_float_t val, const string_t& s) = 0;
5759

5760
    /*!
5761
    @brief a string value was read
5762
    @param[in] val  string value
5763
    @return whether parsing should proceed
5764
    @note It is safe to move the passed string value.
5765
    */
5766
    virtual bool string(string_t& val) = 0;
5767

5768
    /*!
5769
    @brief a binary value was read
5770
    @param[in] val  binary value
5771
    @return whether parsing should proceed
5772
    @note It is safe to move the passed binary value.
5773
    */
5774
    virtual bool binary(binary_t& val) = 0;
5775

5776
    /*!
5777
    @brief the beginning of an object was read
5778
    @param[in] elements  number of object elements or -1 if unknown
5779
    @return whether parsing should proceed
5780
    @note binary formats may report the number of elements
5781
    */
5782
    virtual bool start_object(std::size_t elements) = 0;
5783

5784
    /*!
5785
    @brief an object key was read
5786
    @param[in] val  object key
5787
    @return whether parsing should proceed
5788
    @note It is safe to move the passed string.
5789
    */
5790
    virtual bool key(string_t& val) = 0;
5791

5792
    /*!
5793
    @brief the end of an object was read
5794
    @return whether parsing should proceed
5795
    */
5796
    virtual bool end_object() = 0;
5797

5798
    /*!
5799
    @brief the beginning of an array was read
5800
    @param[in] elements  number of array elements or -1 if unknown
5801
    @return whether parsing should proceed
5802
    @note binary formats may report the number of elements
5803
    */
5804
    virtual bool start_array(std::size_t elements) = 0;
5805

5806
    /*!
5807
    @brief the end of an array was read
5808
    @return whether parsing should proceed
5809
    */
5810
    virtual bool end_array() = 0;
5811

5812
    /*!
5813
    @brief a parse error occurred
5814
    @param[in] position    the position in the input where the error occurs
5815
    @param[in] last_token  the last read token
5816
    @param[in] ex          an exception object describing the error
5817
    @return whether parsing should proceed (must return false)
5818
    */
5819
    virtual bool parse_error(std::size_t position,
5820
                             const std::string& last_token,
5821
                             const detail::exception& ex) = 0;
5822

5823
    json_sax() = default;
5824
    json_sax(const json_sax&) = default;
5825
    json_sax(json_sax&&) noexcept = default;
5826
    json_sax& operator=(const json_sax&) = default;
5827
    json_sax& operator=(json_sax&&) noexcept = default;
5828
    virtual ~json_sax() = default;
5829
};
5830

5831

5832
namespace detail
5833
{
5834
/*!
5835
@brief SAX implementation to create a JSON value from SAX events
5836

5837
This class implements the @ref json_sax interface and processes the SAX events
5838
to create a JSON value which makes it basically a DOM parser. The structure or
5839
hierarchy of the JSON value is managed by the stack `ref_stack` which contains
5840
a pointer to the respective array or object for each recursion depth.
5841

5842
After successful parsing, the value that is passed by reference to the
5843
constructor contains the parsed value.
5844

5845
@tparam BasicJsonType  the JSON type
5846
*/
5847
template<typename BasicJsonType>
5848
class json_sax_dom_parser
5849
{
5850
  public:
5851
    using number_integer_t = typename BasicJsonType::number_integer_t;
5852
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5853
    using number_float_t = typename BasicJsonType::number_float_t;
5854
    using string_t = typename BasicJsonType::string_t;
5855
    using binary_t = typename BasicJsonType::binary_t;
5856

5857
    /*!
5858
    @param[in,out] r  reference to a JSON value that is manipulated while
5859
                       parsing
5860
    @param[in] allow_exceptions_  whether parse errors yield exceptions
5861
    */
5862
    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
5863
        : root(r), allow_exceptions(allow_exceptions_)
5864
    {}
5865

5866
    // make class move-only
5867
    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
5868
    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
5869
    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
5870
    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
5871
    ~json_sax_dom_parser() = default;
5872

5873
    bool null()
5874
    {
5875
        handle_value(nullptr);
5876
        return true;
5877
    }
5878

5879
    bool boolean(bool val)
5880
    {
5881
        handle_value(val);
5882
        return true;
5883
    }
5884

5885
    bool number_integer(number_integer_t val)
5886
    {
5887
        handle_value(val);
5888
        return true;
5889
    }
5890

5891
    bool number_unsigned(number_unsigned_t val)
5892
    {
5893
        handle_value(val);
5894
        return true;
5895
    }
5896

5897
    bool number_float(number_float_t val, const string_t& /*unused*/)
5898
    {
5899
        handle_value(val);
5900
        return true;
5901
    }
5902

5903
    bool string(string_t& val)
5904
    {
5905
        handle_value(val);
5906
        return true;
5907
    }
5908

5909
    bool binary(binary_t& val)
5910
    {
5911
        handle_value(std::move(val));
5912
        return true;
5913
    }
5914

5915
    bool start_object(std::size_t len)
5916
    {
5917
        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
5918

5919
        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
5920
        {
5921
            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
5922
        }
5923

5924
        return true;
5925
    }
5926

5927
    bool key(string_t& val)
5928
    {
5929
        // add null at given key and store the reference for later
5930
        object_element = &(ref_stack.back()->m_value.object->operator[](val));
5931
        return true;
5932
    }
5933

5934
    bool end_object()
5935
    {
5936
        ref_stack.back()->set_parents();
5937
        ref_stack.pop_back();
5938
        return true;
5939
    }
5940

5941
    bool start_array(std::size_t len)
5942
    {
5943
        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
5944

5945
        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
5946
        {
5947
            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
5948
        }
5949

5950
        return true;
5951
    }
5952

5953
    bool end_array()
5954
    {
5955
        ref_stack.back()->set_parents();
5956
        ref_stack.pop_back();
5957
        return true;
5958
    }
5959

5960
    template<class Exception>
5961
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
5962
                     const Exception& ex)
5963
    {
5964
        errored = true;
5965
        static_cast<void>(ex);
5966
        if (allow_exceptions)
5967
        {
5968
            JSON_THROW(ex);
5969
        }
5970
        return false;
5971
    }
5972

5973
    constexpr bool is_errored() const
5974
    {
5975
        return errored;
5976
    }
5977

5978
  private:
5979
    /*!
5980
    @invariant If the ref stack is empty, then the passed value will be the new
5981
               root.
5982
    @invariant If the ref stack contains a value, then it is an array or an
5983
               object to which we can add elements
5984
    */
5985
    template<typename Value>
5986
    JSON_HEDLEY_RETURNS_NON_NULL
5987
    BasicJsonType* handle_value(Value&& v)
5988
    {
5989
        if (ref_stack.empty())
5990
        {
5991
            root = BasicJsonType(std::forward<Value>(v));
5992
            return &root;
5993
        }
5994

5995
        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5996

5997
        if (ref_stack.back()->is_array())
5998
        {
5999
            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6000
            return &(ref_stack.back()->m_value.array->back());
6001
        }
6002

6003
        JSON_ASSERT(ref_stack.back()->is_object());
6004
        JSON_ASSERT(object_element);
6005
        *object_element = BasicJsonType(std::forward<Value>(v));
6006
        return object_element;
6007
    }
6008

6009
    /// the parsed JSON value
6010
    BasicJsonType& root;
6011
    /// stack to model hierarchy of values
6012
    std::vector<BasicJsonType*> ref_stack {};
6013
    /// helper to hold the reference for the next object element
6014
    BasicJsonType* object_element = nullptr;
6015
    /// whether a syntax error occurred
6016
    bool errored = false;
6017
    /// whether to throw exceptions in case of errors
6018
    const bool allow_exceptions = true;
6019
};
6020

6021
template<typename BasicJsonType>
6022
class json_sax_dom_callback_parser
6023
{
6024
  public:
6025
    using number_integer_t = typename BasicJsonType::number_integer_t;
6026
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6027
    using number_float_t = typename BasicJsonType::number_float_t;
6028
    using string_t = typename BasicJsonType::string_t;
6029
    using binary_t = typename BasicJsonType::binary_t;
6030
    using parser_callback_t = typename BasicJsonType::parser_callback_t;
6031
    using parse_event_t = typename BasicJsonType::parse_event_t;
6032

6033
    json_sax_dom_callback_parser(BasicJsonType& r,
6034
                                 const parser_callback_t cb,
6035
                                 const bool allow_exceptions_ = true)
6036
        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6037
    {
6038
        keep_stack.push_back(true);
6039
    }
6040

6041
    // make class move-only
6042
    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
6043
    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6044
    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
6045
    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6046
    ~json_sax_dom_callback_parser() = default;
6047

6048
    bool null()
6049
    {
6050
        handle_value(nullptr);
6051
        return true;
6052
    }
6053

6054
    bool boolean(bool val)
6055
    {
6056
        handle_value(val);
6057
        return true;
6058
    }
6059

6060
    bool number_integer(number_integer_t val)
6061
    {
6062
        handle_value(val);
6063
        return true;
6064
    }
6065

6066
    bool number_unsigned(number_unsigned_t val)
6067
    {
6068
        handle_value(val);
6069
        return true;
6070
    }
6071

6072
    bool number_float(number_float_t val, const string_t& /*unused*/)
6073
    {
6074
        handle_value(val);
6075
        return true;
6076
    }
6077

6078
    bool string(string_t& val)
6079
    {
6080
        handle_value(val);
6081
        return true;
6082
    }
6083

6084
    bool binary(binary_t& val)
6085
    {
6086
        handle_value(std::move(val));
6087
        return true;
6088
    }
6089

6090
    bool start_object(std::size_t len)
6091
    {
6092
        // check callback for object start
6093
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
6094
        keep_stack.push_back(keep);
6095

6096
        auto val = handle_value(BasicJsonType::value_t::object, true);
6097
        ref_stack.push_back(val.second);
6098

6099
        // check object limit
6100
        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6101
        {
6102
            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
6103
        }
6104

6105
        return true;
6106
    }
6107

6108
    bool key(string_t& val)
6109
    {
6110
        BasicJsonType k = BasicJsonType(val);
6111

6112
        // check callback for key
6113
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
6114
        key_keep_stack.push_back(keep);
6115

6116
        // add discarded value at given key and store the reference for later
6117
        if (keep && ref_stack.back())
6118
        {
6119
            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
6120
        }
6121

6122
        return true;
6123
    }
6124

6125
    bool end_object()
6126
    {
6127
        if (ref_stack.back())
6128
        {
6129
            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
6130
            {
6131
                // discard object
6132
                *ref_stack.back() = discarded;
6133
            }
6134
            else
6135
            {
6136
                ref_stack.back()->set_parents();
6137
            }
6138
        }
6139

6140
        JSON_ASSERT(!ref_stack.empty());
6141
        JSON_ASSERT(!keep_stack.empty());
6142
        ref_stack.pop_back();
6143
        keep_stack.pop_back();
6144

6145
        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
6146
        {
6147
            // remove discarded value
6148
            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
6149
            {
6150
                if (it->is_discarded())
6151
                {
6152
                    ref_stack.back()->erase(it);
6153
                    break;
6154
                }
6155
            }
6156
        }
6157

6158
        return true;
6159
    }
6160

6161
    bool start_array(std::size_t len)
6162
    {
6163
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
6164
        keep_stack.push_back(keep);
6165

6166
        auto val = handle_value(BasicJsonType::value_t::array, true);
6167
        ref_stack.push_back(val.second);
6168

6169
        // check array limit
6170
        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6171
        {
6172
            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
6173
        }
6174

6175
        return true;
6176
    }
6177

6178
    bool end_array()
6179
    {
6180
        bool keep = true;
6181

6182
        if (ref_stack.back())
6183
        {
6184
            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
6185
            if (keep)
6186
            {
6187
                ref_stack.back()->set_parents();
6188
            }
6189
            else
6190
            {
6191
                // discard array
6192
                *ref_stack.back() = discarded;
6193
            }
6194
        }
6195

6196
        JSON_ASSERT(!ref_stack.empty());
6197
        JSON_ASSERT(!keep_stack.empty());
6198
        ref_stack.pop_back();
6199
        keep_stack.pop_back();
6200

6201
        // remove discarded value
6202
        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
6203
        {
6204
            ref_stack.back()->m_value.array->pop_back();
6205
        }
6206

6207
        return true;
6208
    }
6209

6210
    template<class Exception>
6211
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
6212
                     const Exception& ex)
6213
    {
6214
        errored = true;
6215
        static_cast<void>(ex);
6216
        if (allow_exceptions)
6217
        {
6218
            JSON_THROW(ex);
6219
        }
6220
        return false;
6221
    }
6222

6223
    constexpr bool is_errored() const
6224
    {
6225
        return errored;
6226
    }
6227

6228
  private:
6229
    /*!
6230
    @param[in] v  value to add to the JSON value we build during parsing
6231
    @param[in] skip_callback  whether we should skip calling the callback
6232
               function; this is required after start_array() and
6233
               start_object() SAX events, because otherwise we would call the
6234
               callback function with an empty array or object, respectively.
6235

6236
    @invariant If the ref stack is empty, then the passed value will be the new
6237
               root.
6238
    @invariant If the ref stack contains a value, then it is an array or an
6239
               object to which we can add elements
6240

6241
    @return pair of boolean (whether value should be kept) and pointer (to the
6242
            passed value in the ref_stack hierarchy; nullptr if not kept)
6243
    */
6244
    template<typename Value>
6245
    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
6246
    {
6247
        JSON_ASSERT(!keep_stack.empty());
6248

6249
        // do not handle this value if we know it would be added to a discarded
6250
        // container
6251
        if (!keep_stack.back())
6252
        {
6253
            return {false, nullptr};
6254
        }
6255

6256
        // create value
6257
        auto value = BasicJsonType(std::forward<Value>(v));
6258

6259
        // check callback
6260
        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
6261

6262
        // do not handle this value if we just learnt it shall be discarded
6263
        if (!keep)
6264
        {
6265
            return {false, nullptr};
6266
        }
6267

6268
        if (ref_stack.empty())
6269
        {
6270
            root = std::move(value);
6271
            return {true, &root};
6272
        }
6273

6274
        // skip this value if we already decided to skip the parent
6275
        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
6276
        if (!ref_stack.back())
6277
        {
6278
            return {false, nullptr};
6279
        }
6280

6281
        // we now only expect arrays and objects
6282
        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6283

6284
        // array
6285
        if (ref_stack.back()->is_array())
6286
        {
6287
            ref_stack.back()->m_value.array->emplace_back(std::move(value));
6288
            return {true, &(ref_stack.back()->m_value.array->back())};
6289
        }
6290

6291
        // object
6292
        JSON_ASSERT(ref_stack.back()->is_object());
6293
        // check if we should store an element for the current key
6294
        JSON_ASSERT(!key_keep_stack.empty());
6295
        const bool store_element = key_keep_stack.back();
6296
        key_keep_stack.pop_back();
6297

6298
        if (!store_element)
6299
        {
6300
            return {false, nullptr};
6301
        }
6302

6303
        JSON_ASSERT(object_element);
6304
        *object_element = std::move(value);
6305
        return {true, object_element};
6306
    }
6307

6308
    /// the parsed JSON value
6309
    BasicJsonType& root;
6310
    /// stack to model hierarchy of values
6311
    std::vector<BasicJsonType*> ref_stack {};
6312
    /// stack to manage which values to keep
6313
    std::vector<bool> keep_stack {};
6314
    /// stack to manage which object keys to keep
6315
    std::vector<bool> key_keep_stack {};
6316
    /// helper to hold the reference for the next object element
6317
    BasicJsonType* object_element = nullptr;
6318
    /// whether a syntax error occurred
6319
    bool errored = false;
6320
    /// callback function
6321
    const parser_callback_t callback = nullptr;
6322
    /// whether to throw exceptions in case of errors
6323
    const bool allow_exceptions = true;
6324
    /// a discarded value for the callback
6325
    BasicJsonType discarded = BasicJsonType::value_t::discarded;
6326
};
6327

6328
template<typename BasicJsonType>
6329
class json_sax_acceptor
6330
{
6331
  public:
6332
    using number_integer_t = typename BasicJsonType::number_integer_t;
6333
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6334
    using number_float_t = typename BasicJsonType::number_float_t;
6335
    using string_t = typename BasicJsonType::string_t;
6336
    using binary_t = typename BasicJsonType::binary_t;
6337

6338
    bool null()
6339
    {
6340
        return true;
6341
    }
6342

6343
    bool boolean(bool /*unused*/)
6344
    {
6345
        return true;
6346
    }
6347

6348
    bool number_integer(number_integer_t /*unused*/)
6349
    {
6350
        return true;
6351
    }
6352

6353
    bool number_unsigned(number_unsigned_t /*unused*/)
6354
    {
6355
        return true;
6356
    }
6357

6358
    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
6359
    {
6360
        return true;
6361
    }
6362

6363
    bool string(string_t& /*unused*/)
6364
    {
6365
        return true;
6366
    }
6367

6368
    bool binary(binary_t& /*unused*/)
6369
    {
6370
        return true;
6371
    }
6372

6373
    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
6374
    {
6375
        return true;
6376
    }
6377

6378
    bool key(string_t& /*unused*/)
6379
    {
6380
        return true;
6381
    }
6382

6383
    bool end_object()
6384
    {
6385
        return true;
6386
    }
6387

6388
    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
6389
    {
6390
        return true;
6391
    }
6392

6393
    bool end_array()
6394
    {
6395
        return true;
6396
    }
6397

6398
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
6399
    {
6400
        return false;
6401
    }
6402
};
6403
}  // namespace detail
6404

6405
}  // namespace nlohmann
6406

6407
// #include <nlohmann/detail/input/lexer.hpp>
6408

6409

6410
#include <array> // array
6411
#include <clocale> // localeconv
6412
#include <cstddef> // size_t
6413
#include <cstdio> // snprintf
6414
#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
6415
#include <initializer_list> // initializer_list
6416
#include <string> // char_traits, string
6417
#include <utility> // move
6418
#include <vector> // vector
6419

6420
// #include <nlohmann/detail/input/input_adapters.hpp>
6421

6422
// #include <nlohmann/detail/input/position_t.hpp>
6423

6424
// #include <nlohmann/detail/macro_scope.hpp>
6425

6426

6427
namespace nlohmann
6428
{
6429
namespace detail
6430
{
6431
///////////
6432
// lexer //
6433
///////////
6434

6435
template<typename BasicJsonType>
6436
class lexer_base
6437
{
6438
  public:
6439
    /// token types for the parser
6440
    enum class token_type
6441
    {
6442
        uninitialized,    ///< indicating the scanner is uninitialized
6443
        literal_true,     ///< the `true` literal
6444
        literal_false,    ///< the `false` literal
6445
        literal_null,     ///< the `null` literal
6446
        value_string,     ///< a string -- use get_string() for actual value
6447
        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
6448
        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
6449
        value_float,      ///< an floating point number -- use get_number_float() for actual value
6450
        begin_array,      ///< the character for array begin `[`
6451
        begin_object,     ///< the character for object begin `{`
6452
        end_array,        ///< the character for array end `]`
6453
        end_object,       ///< the character for object end `}`
6454
        name_separator,   ///< the name separator `:`
6455
        value_separator,  ///< the value separator `,`
6456
        parse_error,      ///< indicating a parse error
6457
        end_of_input,     ///< indicating the end of the input buffer
6458
        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
6459
    };
6460

6461
    /// return name of values of type token_type (only used for errors)
6462
    JSON_HEDLEY_RETURNS_NON_NULL
6463
    JSON_HEDLEY_CONST
6464
    static const char* token_type_name(const token_type t) noexcept
6465
    {
6466
        switch (t)
6467
        {
6468
            case token_type::uninitialized:
6469
                return "<uninitialized>";
6470
            case token_type::literal_true:
6471
                return "true literal";
6472
            case token_type::literal_false:
6473
                return "false literal";
6474
            case token_type::literal_null:
6475
                return "null literal";
6476
            case token_type::value_string:
6477
                return "string literal";
6478
            case token_type::value_unsigned:
6479
            case token_type::value_integer:
6480
            case token_type::value_float:
6481
                return "number literal";
6482
            case token_type::begin_array:
6483
                return "'['";
6484
            case token_type::begin_object:
6485
                return "'{'";
6486
            case token_type::end_array:
6487
                return "']'";
6488
            case token_type::end_object:
6489
                return "'}'";
6490
            case token_type::name_separator:
6491
                return "':'";
6492
            case token_type::value_separator:
6493
                return "','";
6494
            case token_type::parse_error:
6495
                return "<parse error>";
6496
            case token_type::end_of_input:
6497
                return "end of input";
6498
            case token_type::literal_or_value:
6499
                return "'[', '{', or a literal";
6500
            // LCOV_EXCL_START
6501
            default: // catch non-enum values
6502
                return "unknown token";
6503
                // LCOV_EXCL_STOP
6504
        }
6505
    }
6506
};
6507
/*!
6508
@brief lexical analysis
6509

6510
This class organizes the lexical analysis during JSON deserialization.
6511
*/
6512
template<typename BasicJsonType, typename InputAdapterType>
6513
class lexer : public lexer_base<BasicJsonType>
6514
{
6515
    using number_integer_t = typename BasicJsonType::number_integer_t;
6516
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6517
    using number_float_t = typename BasicJsonType::number_float_t;
6518
    using string_t = typename BasicJsonType::string_t;
6519
    using char_type = typename InputAdapterType::char_type;
6520
    using char_int_type = typename std::char_traits<char_type>::int_type;
6521

6522
  public:
6523
    using token_type = typename lexer_base<BasicJsonType>::token_type;
6524

6525
    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
6526
        : ia(std::move(adapter))
6527
        , ignore_comments(ignore_comments_)
6528
        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
6529
    {}
6530

6531
    // delete because of pointer members
6532
    lexer(const lexer&) = delete;
6533
    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6534
    lexer& operator=(lexer&) = delete;
6535
    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6536
    ~lexer() = default;
6537

6538
  private:
6539
    /////////////////////
6540
    // locales
6541
    /////////////////////
6542

6543
    /// return the locale-dependent decimal point
6544
    JSON_HEDLEY_PURE
6545
    static char get_decimal_point() noexcept
6546
    {
6547
        const auto* loc = localeconv();
6548
        JSON_ASSERT(loc != nullptr);
6549
        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
6550
    }
6551

6552
    /////////////////////
6553
    // scan functions
6554
    /////////////////////
6555

6556
    /*!
6557
    @brief get codepoint from 4 hex characters following `\u`
6558

6559
    For input "\u c1 c2 c3 c4" the codepoint is:
6560
      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
6561
    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
6562

6563
    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
6564
    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
6565
    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
6566
    between the ASCII value of the character and the desired integer value.
6567

6568
    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
6569
            non-hex character)
6570
    */
6571
    int get_codepoint()
6572
    {
6573
        // this function only makes sense after reading `\u`
6574
        JSON_ASSERT(current == 'u');
6575
        int codepoint = 0;
6576

6577
        const auto factors = { 12u, 8u, 4u, 0u };
6578
        for (const auto factor : factors)
6579
        {
6580
            get();
6581

6582
            if (current >= '0' && current <= '9')
6583
            {
6584
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
6585
            }
6586
            else if (current >= 'A' && current <= 'F')
6587
            {
6588
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
6589
            }
6590
            else if (current >= 'a' && current <= 'f')
6591
            {
6592
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
6593
            }
6594
            else
6595
            {
6596
                return -1;
6597
            }
6598
        }
6599

6600
        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6601
        return codepoint;
6602
    }
6603

6604
    /*!
6605
    @brief check if the next byte(s) are inside a given range
6606

6607
    Adds the current byte and, for each passed range, reads a new byte and
6608
    checks if it is inside the range. If a violation was detected, set up an
6609
    error message and return false. Otherwise, return true.
6610

6611
    @param[in] ranges  list of integers; interpreted as list of pairs of
6612
                       inclusive lower and upper bound, respectively
6613

6614
    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
6615
         1, 2, or 3 pairs. This precondition is enforced by an assertion.
6616

6617
    @return true if and only if no range violation was detected
6618
    */
6619
    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6620
    {
6621
        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6622
        add(current);
6623

6624
        for (auto range = ranges.begin(); range != ranges.end(); ++range)
6625
        {
6626
            get();
6627
            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6628
            {
6629
                add(current);
6630
            }
6631
            else
6632
            {
6633
                error_message = "invalid string: ill-formed UTF-8 byte";
6634
                return false;
6635
            }
6636
        }
6637

6638
        return true;
6639
    }
6640

6641
    /*!
6642
    @brief scan a string literal
6643

6644
    This function scans a string according to Sect. 7 of RFC 8259. While
6645
    scanning, bytes are escaped and copied into buffer token_buffer. Then the
6646
    function returns successfully, token_buffer is *not* null-terminated (as it
6647
    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
6648
    string.
6649

6650
    @return token_type::value_string if string could be successfully scanned,
6651
            token_type::parse_error otherwise
6652

6653
    @note In case of errors, variable error_message contains a textual
6654
          description.
6655
    */
6656
    token_type scan_string()
6657
    {
6658
        // reset token_buffer (ignore opening quote)
6659
        reset();
6660

6661
        // we entered the function by reading an open quote
6662
        JSON_ASSERT(current == '\"');
6663

6664
        while (true)
6665
        {
6666
            // get next character
6667
            switch (get())
6668
            {
6669
                // end of file while parsing string
6670
                case std::char_traits<char_type>::eof():
6671
                {
6672
                    error_message = "invalid string: missing closing quote";
6673
                    return token_type::parse_error;
6674
                }
6675

6676
                // closing quote
6677
                case '\"':
6678
                {
6679
                    return token_type::value_string;
6680
                }
6681

6682
                // escapes
6683
                case '\\':
6684
                {
6685
                    switch (get())
6686
                    {
6687
                        // quotation mark
6688
                        case '\"':
6689
                            add('\"');
6690
                            break;
6691
                        // reverse solidus
6692
                        case '\\':
6693
                            add('\\');
6694
                            break;
6695
                        // solidus
6696
                        case '/':
6697
                            add('/');
6698
                            break;
6699
                        // backspace
6700
                        case 'b':
6701
                            add('\b');
6702
                            break;
6703
                        // form feed
6704
                        case 'f':
6705
                            add('\f');
6706
                            break;
6707
                        // line feed
6708
                        case 'n':
6709
                            add('\n');
6710
                            break;
6711
                        // carriage return
6712
                        case 'r':
6713
                            add('\r');
6714
                            break;
6715
                        // tab
6716
                        case 't':
6717
                            add('\t');
6718
                            break;
6719

6720
                        // unicode escapes
6721
                        case 'u':
6722
                        {
6723
                            const int codepoint1 = get_codepoint();
6724
                            int codepoint = codepoint1; // start with codepoint1
6725

6726
                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6727
                            {
6728
                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6729
                                return token_type::parse_error;
6730
                            }
6731

6732
                            // check if code point is a high surrogate
6733
                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6734
                            {
6735
                                // expect next \uxxxx entry
6736
                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
6737
                                {
6738
                                    const int codepoint2 = get_codepoint();
6739

6740
                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6741
                                    {
6742
                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6743
                                        return token_type::parse_error;
6744
                                    }
6745

6746
                                    // check if codepoint2 is a low surrogate
6747
                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6748
                                    {
6749
                                        // overwrite codepoint
6750
                                        codepoint = static_cast<int>(
6751
                                                        // high surrogate occupies the most significant 22 bits
6752
                                                        (static_cast<unsigned int>(codepoint1) << 10u)
6753
                                                        // low surrogate occupies the least significant 15 bits
6754
                                                        + static_cast<unsigned int>(codepoint2)
6755
                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
6756
                                                        // in the result, so we have to subtract with:
6757
                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
6758
                                                        - 0x35FDC00u);
6759
                                    }
6760
                                    else
6761
                                    {
6762
                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6763
                                        return token_type::parse_error;
6764
                                    }
6765
                                }
6766
                                else
6767
                                {
6768
                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6769
                                    return token_type::parse_error;
6770
                                }
6771
                            }
6772
                            else
6773
                            {
6774
                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6775
                                {
6776
                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6777
                                    return token_type::parse_error;
6778
                                }
6779
                            }
6780

6781
                            // result of the above calculation yields a proper codepoint
6782
                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6783

6784
                            // translate codepoint into bytes
6785
                            if (codepoint < 0x80)
6786
                            {
6787
                                // 1-byte characters: 0xxxxxxx (ASCII)
6788
                                add(static_cast<char_int_type>(codepoint));
6789
                            }
6790
                            else if (codepoint <= 0x7FF)
6791
                            {
6792
                                // 2-byte characters: 110xxxxx 10xxxxxx
6793
                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
6794
                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6795
                            }
6796
                            else if (codepoint <= 0xFFFF)
6797
                            {
6798
                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
6799
                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
6800
                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6801
                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6802
                            }
6803
                            else
6804
                            {
6805
                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
6806
                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
6807
                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6808
                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6809
                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6810
                            }
6811

6812
                            break;
6813
                        }
6814

6815
                        // other characters after escape
6816
                        default:
6817
                            error_message = "invalid string: forbidden character after backslash";
6818
                            return token_type::parse_error;
6819
                    }
6820

6821
                    break;
6822
                }
6823

6824
                // invalid control characters
6825
                case 0x00:
6826
                {
6827
                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6828
                    return token_type::parse_error;
6829
                }
6830

6831
                case 0x01:
6832
                {
6833
                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6834
                    return token_type::parse_error;
6835
                }
6836

6837
                case 0x02:
6838
                {
6839
                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6840
                    return token_type::parse_error;
6841
                }
6842

6843
                case 0x03:
6844
                {
6845
                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6846
                    return token_type::parse_error;
6847
                }
6848

6849
                case 0x04:
6850
                {
6851
                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6852
                    return token_type::parse_error;
6853
                }
6854

6855
                case 0x05:
6856
                {
6857
                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6858
                    return token_type::parse_error;
6859
                }
6860

6861
                case 0x06:
6862
                {
6863
                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6864
                    return token_type::parse_error;
6865
                }
6866

6867
                case 0x07:
6868
                {
6869
                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6870
                    return token_type::parse_error;
6871
                }
6872

6873
                case 0x08:
6874
                {
6875
                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6876
                    return token_type::parse_error;
6877
                }
6878

6879
                case 0x09:
6880
                {
6881
                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6882
                    return token_type::parse_error;
6883
                }
6884

6885
                case 0x0A:
6886
                {
6887
                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6888
                    return token_type::parse_error;
6889
                }
6890

6891
                case 0x0B:
6892
                {
6893
                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
6894
                    return token_type::parse_error;
6895
                }
6896

6897
                case 0x0C:
6898
                {
6899
                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
6900
                    return token_type::parse_error;
6901
                }
6902

6903
                case 0x0D:
6904
                {
6905
                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
6906
                    return token_type::parse_error;
6907
                }
6908

6909
                case 0x0E:
6910
                {
6911
                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
6912
                    return token_type::parse_error;
6913
                }
6914

6915
                case 0x0F:
6916
                {
6917
                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
6918
                    return token_type::parse_error;
6919
                }
6920

6921
                case 0x10:
6922
                {
6923
                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
6924
                    return token_type::parse_error;
6925
                }
6926

6927
                case 0x11:
6928
                {
6929
                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
6930
                    return token_type::parse_error;
6931
                }
6932

6933
                case 0x12:
6934
                {
6935
                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
6936
                    return token_type::parse_error;
6937
                }
6938

6939
                case 0x13:
6940
                {
6941
                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
6942
                    return token_type::parse_error;
6943
                }
6944

6945
                case 0x14:
6946
                {
6947
                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
6948
                    return token_type::parse_error;
6949
                }
6950

6951
                case 0x15:
6952
                {
6953
                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
6954
                    return token_type::parse_error;
6955
                }
6956

6957
                case 0x16:
6958
                {
6959
                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
6960
                    return token_type::parse_error;
6961
                }
6962

6963
                case 0x17:
6964
                {
6965
                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
6966
                    return token_type::parse_error;
6967
                }
6968

6969
                case 0x18:
6970
                {
6971
                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
6972
                    return token_type::parse_error;
6973
                }
6974

6975
                case 0x19:
6976
                {
6977
                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
6978
                    return token_type::parse_error;
6979
                }
6980

6981
                case 0x1A:
6982
                {
6983
                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
6984
                    return token_type::parse_error;
6985
                }
6986

6987
                case 0x1B:
6988
                {
6989
                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
6990
                    return token_type::parse_error;
6991
                }
6992

6993
                case 0x1C:
6994
                {
6995
                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
6996
                    return token_type::parse_error;
6997
                }
6998

6999
                case 0x1D:
7000
                {
7001
                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
7002
                    return token_type::parse_error;
7003
                }
7004

7005
                case 0x1E:
7006
                {
7007
                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
7008
                    return token_type::parse_error;
7009
                }
7010

7011
                case 0x1F:
7012
                {
7013
                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
7014
                    return token_type::parse_error;
7015
                }
7016

7017
                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
7018
                case 0x20:
7019
                case 0x21:
7020
                case 0x23:
7021
                case 0x24:
7022
                case 0x25:
7023
                case 0x26:
7024
                case 0x27:
7025
                case 0x28:
7026
                case 0x29:
7027
                case 0x2A:
7028
                case 0x2B:
7029
                case 0x2C:
7030
                case 0x2D:
7031
                case 0x2E:
7032
                case 0x2F:
7033
                case 0x30:
7034
                case 0x31:
7035
                case 0x32:
7036
                case 0x33:
7037
                case 0x34:
7038
                case 0x35:
7039
                case 0x36:
7040
                case 0x37:
7041
                case 0x38:
7042
                case 0x39:
7043
                case 0x3A:
7044
                case 0x3B:
7045
                case 0x3C:
7046
                case 0x3D:
7047
                case 0x3E:
7048
                case 0x3F:
7049
                case 0x40:
7050
                case 0x41:
7051
                case 0x42:
7052
                case 0x43:
7053
                case 0x44:
7054
                case 0x45:
7055
                case 0x46:
7056
                case 0x47:
7057
                case 0x48:
7058
                case 0x49:
7059
                case 0x4A:
7060
                case 0x4B:
7061
                case 0x4C:
7062
                case 0x4D:
7063
                case 0x4E:
7064
                case 0x4F:
7065
                case 0x50:
7066
                case 0x51:
7067
                case 0x52:
7068
                case 0x53:
7069
                case 0x54:
7070
                case 0x55:
7071
                case 0x56:
7072
                case 0x57:
7073
                case 0x58:
7074
                case 0x59:
7075
                case 0x5A:
7076
                case 0x5B:
7077
                case 0x5D:
7078
                case 0x5E:
7079
                case 0x5F:
7080
                case 0x60:
7081
                case 0x61:
7082
                case 0x62:
7083
                case 0x63:
7084
                case 0x64:
7085
                case 0x65:
7086
                case 0x66:
7087
                case 0x67:
7088
                case 0x68:
7089
                case 0x69:
7090
                case 0x6A:
7091
                case 0x6B:
7092
                case 0x6C:
7093
                case 0x6D:
7094
                case 0x6E:
7095
                case 0x6F:
7096
                case 0x70:
7097
                case 0x71:
7098
                case 0x72:
7099
                case 0x73:
7100
                case 0x74:
7101
                case 0x75:
7102
                case 0x76:
7103
                case 0x77:
7104
                case 0x78:
7105
                case 0x79:
7106
                case 0x7A:
7107
                case 0x7B:
7108
                case 0x7C:
7109
                case 0x7D:
7110
                case 0x7E:
7111
                case 0x7F:
7112
                {
7113
                    add(current);
7114
                    break;
7115
                }
7116

7117
                // U+0080..U+07FF: bytes C2..DF 80..BF
7118
                case 0xC2:
7119
                case 0xC3:
7120
                case 0xC4:
7121
                case 0xC5:
7122
                case 0xC6:
7123
                case 0xC7:
7124
                case 0xC8:
7125
                case 0xC9:
7126
                case 0xCA:
7127
                case 0xCB:
7128
                case 0xCC:
7129
                case 0xCD:
7130
                case 0xCE:
7131
                case 0xCF:
7132
                case 0xD0:
7133
                case 0xD1:
7134
                case 0xD2:
7135
                case 0xD3:
7136
                case 0xD4:
7137
                case 0xD5:
7138
                case 0xD6:
7139
                case 0xD7:
7140
                case 0xD8:
7141
                case 0xD9:
7142
                case 0xDA:
7143
                case 0xDB:
7144
                case 0xDC:
7145
                case 0xDD:
7146
                case 0xDE:
7147
                case 0xDF:
7148
                {
7149
                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
7150
                    {
7151
                        return token_type::parse_error;
7152
                    }
7153
                    break;
7154
                }
7155

7156
                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
7157
                case 0xE0:
7158
                {
7159
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7160
                    {
7161
                        return token_type::parse_error;
7162
                    }
7163
                    break;
7164
                }
7165

7166
                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
7167
                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
7168
                case 0xE1:
7169
                case 0xE2:
7170
                case 0xE3:
7171
                case 0xE4:
7172
                case 0xE5:
7173
                case 0xE6:
7174
                case 0xE7:
7175
                case 0xE8:
7176
                case 0xE9:
7177
                case 0xEA:
7178
                case 0xEB:
7179
                case 0xEC:
7180
                case 0xEE:
7181
                case 0xEF:
7182
                {
7183
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7184
                    {
7185
                        return token_type::parse_error;
7186
                    }
7187
                    break;
7188
                }
7189

7190
                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
7191
                case 0xED:
7192
                {
7193
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7194
                    {
7195
                        return token_type::parse_error;
7196
                    }
7197
                    break;
7198
                }
7199

7200
                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
7201
                case 0xF0:
7202
                {
7203
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7204
                    {
7205
                        return token_type::parse_error;
7206
                    }
7207
                    break;
7208
                }
7209

7210
                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
7211
                case 0xF1:
7212
                case 0xF2:
7213
                case 0xF3:
7214
                {
7215
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7216
                    {
7217
                        return token_type::parse_error;
7218
                    }
7219
                    break;
7220
                }
7221

7222
                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
7223
                case 0xF4:
7224
                {
7225
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7226
                    {
7227
                        return token_type::parse_error;
7228
                    }
7229
                    break;
7230
                }
7231

7232
                // remaining bytes (80..C1 and F5..FF) are ill-formed
7233
                default:
7234
                {
7235
                    error_message = "invalid string: ill-formed UTF-8 byte";
7236
                    return token_type::parse_error;
7237
                }
7238
            }
7239
        }
7240
    }
7241

7242
    /*!
7243
     * @brief scan a comment
7244
     * @return whether comment could be scanned successfully
7245
     */
7246
    bool scan_comment()
7247
    {
7248
        switch (get())
7249
        {
7250
            // single-line comments skip input until a newline or EOF is read
7251
            case '/':
7252
            {
7253
                while (true)
7254
                {
7255
                    switch (get())
7256
                    {
7257
                        case '\n':
7258
                        case '\r':
7259
                        case std::char_traits<char_type>::eof():
7260
                        case '\0':
7261
                            return true;
7262

7263
                        default:
7264
                            break;
7265
                    }
7266
                }
7267
            }
7268

7269
            // multi-line comments skip input until */ is read
7270
            case '*':
7271
            {
7272
                while (true)
7273
                {
7274
                    switch (get())
7275
                    {
7276
                        case std::char_traits<char_type>::eof():
7277
                        case '\0':
7278
                        {
7279
                            error_message = "invalid comment; missing closing '*/'";
7280
                            return false;
7281
                        }
7282

7283
                        case '*':
7284
                        {
7285
                            switch (get())
7286
                            {
7287
                                case '/':
7288
                                    return true;
7289

7290
                                default:
7291
                                {
7292
                                    unget();
7293
                                    continue;
7294
                                }
7295
                            }
7296
                        }
7297

7298
                        default:
7299
                            continue;
7300
                    }
7301
                }
7302
            }
7303

7304
            // unexpected character after reading '/'
7305
            default:
7306
            {
7307
                error_message = "invalid comment; expecting '/' or '*' after '/'";
7308
                return false;
7309
            }
7310
        }
7311
    }
7312

7313
    JSON_HEDLEY_NON_NULL(2)
7314
    static void strtof(float& f, const char* str, char** endptr) noexcept
7315
    {
7316
        f = std::strtof(str, endptr);
7317
    }
7318

7319
    JSON_HEDLEY_NON_NULL(2)
7320
    static void strtof(double& f, const char* str, char** endptr) noexcept
7321
    {
7322
        f = std::strtod(str, endptr);
7323
    }
7324

7325
    JSON_HEDLEY_NON_NULL(2)
7326
    static void strtof(long double& f, const char* str, char** endptr) noexcept
7327
    {
7328
        f = std::strtold(str, endptr);
7329
    }
7330

7331
    /*!
7332
    @brief scan a number literal
7333

7334
    This function scans a string according to Sect. 6 of RFC 8259.
7335

7336
    The function is realized with a deterministic finite state machine derived
7337
    from the grammar described in RFC 8259. Starting in state "init", the
7338
    input is read and used to determined the next state. Only state "done"
7339
    accepts the number. State "error" is a trap state to model errors. In the
7340
    table below, "anything" means any character but the ones listed before.
7341

7342
    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
7343
    ---------|----------|----------|----------|---------|---------|----------|-----------
7344
    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
7345
    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
7346
    zero     | done     | done     | exponent | done    | done    | decimal1 | done
7347
    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
7348
    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
7349
    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
7350
    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
7351
    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
7352
    any2     | any2     | any2     | done     | done    | done    | done     | done
7353

7354
    The state machine is realized with one label per state (prefixed with
7355
    "scan_number_") and `goto` statements between them. The state machine
7356
    contains cycles, but any cycle can be left when EOF is read. Therefore,
7357
    the function is guaranteed to terminate.
7358

7359
    During scanning, the read bytes are stored in token_buffer. This string is
7360
    then converted to a signed integer, an unsigned integer, or a
7361
    floating-point number.
7362

7363
    @return token_type::value_unsigned, token_type::value_integer, or
7364
            token_type::value_float if number could be successfully scanned,
7365
            token_type::parse_error otherwise
7366

7367
    @note The scanner is independent of the current locale. Internally, the
7368
          locale's decimal point is used instead of `.` to work with the
7369
          locale-dependent converters.
7370
    */
7371
    token_type scan_number()  // lgtm [cpp/use-of-goto]
7372
    {
7373
        // reset token_buffer to store the number's bytes
7374
        reset();
7375

7376
        // the type of the parsed number; initially set to unsigned; will be
7377
        // changed if minus sign, decimal point or exponent is read
7378
        token_type number_type = token_type::value_unsigned;
7379

7380
        // state (init): we just found out we need to scan a number
7381
        switch (current)
7382
        {
7383
            case '-':
7384
            {
7385
                add(current);
7386
                goto scan_number_minus;
7387
            }
7388

7389
            case '0':
7390
            {
7391
                add(current);
7392
                goto scan_number_zero;
7393
            }
7394

7395
            case '1':
7396
            case '2':
7397
            case '3':
7398
            case '4':
7399
            case '5':
7400
            case '6':
7401
            case '7':
7402
            case '8':
7403
            case '9':
7404
            {
7405
                add(current);
7406
                goto scan_number_any1;
7407
            }
7408

7409
            // all other characters are rejected outside scan_number()
7410
            default:            // LCOV_EXCL_LINE
7411
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
7412
        }
7413

7414
scan_number_minus:
7415
        // state: we just parsed a leading minus sign
7416
        number_type = token_type::value_integer;
7417
        switch (get())
7418
        {
7419
            case '0':
7420
            {
7421
                add(current);
7422
                goto scan_number_zero;
7423
            }
7424

7425
            case '1':
7426
            case '2':
7427
            case '3':
7428
            case '4':
7429
            case '5':
7430
            case '6':
7431
            case '7':
7432
            case '8':
7433
            case '9':
7434
            {
7435
                add(current);
7436
                goto scan_number_any1;
7437
            }
7438

7439
            default:
7440
            {
7441
                error_message = "invalid number; expected digit after '-'";
7442
                return token_type::parse_error;
7443
            }
7444
        }
7445

7446
scan_number_zero:
7447
        // state: we just parse a zero (maybe with a leading minus sign)
7448
        switch (get())
7449
        {
7450
            case '.':
7451
            {
7452
                add(decimal_point_char);
7453
                goto scan_number_decimal1;
7454
            }
7455

7456
            case 'e':
7457
            case 'E':
7458
            {
7459
                add(current);
7460
                goto scan_number_exponent;
7461
            }
7462

7463
            default:
7464
                goto scan_number_done;
7465
        }
7466

7467
scan_number_any1:
7468
        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
7469
        switch (get())
7470
        {
7471
            case '0':
7472
            case '1':
7473
            case '2':
7474
            case '3':
7475
            case '4':
7476
            case '5':
7477
            case '6':
7478
            case '7':
7479
            case '8':
7480
            case '9':
7481
            {
7482
                add(current);
7483
                goto scan_number_any1;
7484
            }
7485

7486
            case '.':
7487
            {
7488
                add(decimal_point_char);
7489
                goto scan_number_decimal1;
7490
            }
7491

7492
            case 'e':
7493
            case 'E':
7494
            {
7495
                add(current);
7496
                goto scan_number_exponent;
7497
            }
7498

7499
            default:
7500
                goto scan_number_done;
7501
        }
7502

7503
scan_number_decimal1:
7504
        // state: we just parsed a decimal point
7505
        number_type = token_type::value_float;
7506
        switch (get())
7507
        {
7508
            case '0':
7509
            case '1':
7510
            case '2':
7511
            case '3':
7512
            case '4':
7513
            case '5':
7514
            case '6':
7515
            case '7':
7516
            case '8':
7517
            case '9':
7518
            {
7519
                add(current);
7520
                goto scan_number_decimal2;
7521
            }
7522

7523
            default:
7524
            {
7525
                error_message = "invalid number; expected digit after '.'";
7526
                return token_type::parse_error;
7527
            }
7528
        }
7529

7530
scan_number_decimal2:
7531
        // we just parsed at least one number after a decimal point
7532
        switch (get())
7533
        {
7534
            case '0':
7535
            case '1':
7536
            case '2':
7537
            case '3':
7538
            case '4':
7539
            case '5':
7540
            case '6':
7541
            case '7':
7542
            case '8':
7543
            case '9':
7544
            {
7545
                add(current);
7546
                goto scan_number_decimal2;
7547
            }
7548

7549
            case 'e':
7550
            case 'E':
7551
            {
7552
                add(current);
7553
                goto scan_number_exponent;
7554
            }
7555

7556
            default:
7557
                goto scan_number_done;
7558
        }
7559

7560
scan_number_exponent:
7561
        // we just parsed an exponent
7562
        number_type = token_type::value_float;
7563
        switch (get())
7564
        {
7565
            case '+':
7566
            case '-':
7567
            {
7568
                add(current);
7569
                goto scan_number_sign;
7570
            }
7571

7572
            case '0':
7573
            case '1':
7574
            case '2':
7575
            case '3':
7576
            case '4':
7577
            case '5':
7578
            case '6':
7579
            case '7':
7580
            case '8':
7581
            case '9':
7582
            {
7583
                add(current);
7584
                goto scan_number_any2;
7585
            }
7586

7587
            default:
7588
            {
7589
                error_message =
7590
                    "invalid number; expected '+', '-', or digit after exponent";
7591
                return token_type::parse_error;
7592
            }
7593
        }
7594

7595
scan_number_sign:
7596
        // we just parsed an exponent sign
7597
        switch (get())
7598
        {
7599
            case '0':
7600
            case '1':
7601
            case '2':
7602
            case '3':
7603
            case '4':
7604
            case '5':
7605
            case '6':
7606
            case '7':
7607
            case '8':
7608
            case '9':
7609
            {
7610
                add(current);
7611
                goto scan_number_any2;
7612
            }
7613

7614
            default:
7615
            {
7616
                error_message = "invalid number; expected digit after exponent sign";
7617
                return token_type::parse_error;
7618
            }
7619
        }
7620

7621
scan_number_any2:
7622
        // we just parsed a number after the exponent or exponent sign
7623
        switch (get())
7624
        {
7625
            case '0':
7626
            case '1':
7627
            case '2':
7628
            case '3':
7629
            case '4':
7630
            case '5':
7631
            case '6':
7632
            case '7':
7633
            case '8':
7634
            case '9':
7635
            {
7636
                add(current);
7637
                goto scan_number_any2;
7638
            }
7639

7640
            default:
7641
                goto scan_number_done;
7642
        }
7643

7644
scan_number_done:
7645
        // unget the character after the number (we only read it to know that
7646
        // we are done scanning a number)
7647
        unget();
7648

7649
        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
7650
        errno = 0;
7651

7652
        // try to parse integers first and fall back to floats
7653
        if (number_type == token_type::value_unsigned)
7654
        {
7655
            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7656

7657
            // we checked the number format before
7658
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7659

7660
            if (errno == 0)
7661
            {
7662
                value_unsigned = static_cast<number_unsigned_t>(x);
7663
                if (value_unsigned == x)
7664
                {
7665
                    return token_type::value_unsigned;
7666
                }
7667
            }
7668
        }
7669
        else if (number_type == token_type::value_integer)
7670
        {
7671
            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7672

7673
            // we checked the number format before
7674
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7675

7676
            if (errno == 0)
7677
            {
7678
                value_integer = static_cast<number_integer_t>(x);
7679
                if (value_integer == x)
7680
                {
7681
                    return token_type::value_integer;
7682
                }
7683
            }
7684
        }
7685

7686
        // this code is reached if we parse a floating-point number or if an
7687
        // integer conversion above failed
7688
        strtof(value_float, token_buffer.data(), &endptr);
7689

7690
        // we checked the number format before
7691
        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7692

7693
        return token_type::value_float;
7694
    }
7695

7696
    /*!
7697
    @param[in] literal_text  the literal text to expect
7698
    @param[in] length        the length of the passed literal text
7699
    @param[in] return_type   the token type to return on success
7700
    */
7701
    JSON_HEDLEY_NON_NULL(2)
7702
    token_type scan_literal(const char_type* literal_text, const std::size_t length,
7703
                            token_type return_type)
7704
    {
7705
        JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7706
        for (std::size_t i = 1; i < length; ++i)
7707
        {
7708
            if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7709
            {
7710
                error_message = "invalid literal";
7711
                return token_type::parse_error;
7712
            }
7713
        }
7714
        return return_type;
7715
    }
7716

7717
    /////////////////////
7718
    // input management
7719
    /////////////////////
7720

7721
    /// reset token_buffer; current character is beginning of token
7722
    void reset() noexcept
7723
    {
7724
        token_buffer.clear();
7725
        token_string.clear();
7726
        token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7727
    }
7728

7729
    /*
7730
    @brief get next character from the input
7731

7732
    This function provides the interface to the used input adapter. It does
7733
    not throw in case the input reached EOF, but returns a
7734
    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
7735
    for use in error messages.
7736

7737
    @return character read from the input
7738
    */
7739
    char_int_type get()
7740
    {
7741
        ++position.chars_read_total;
7742
        ++position.chars_read_current_line;
7743

7744
        if (next_unget)
7745
        {
7746
            // just reset the next_unget variable and work with current
7747
            next_unget = false;
7748
        }
7749
        else
7750
        {
7751
            current = ia.get_character();
7752
        }
7753

7754
        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7755
        {
7756
            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7757
        }
7758

7759
        if (current == '\n')
7760
        {
7761
            ++position.lines_read;
7762
            position.chars_read_current_line = 0;
7763
        }
7764

7765
        return current;
7766
    }
7767

7768
    /*!
7769
    @brief unget current character (read it again on next get)
7770

7771
    We implement unget by setting variable next_unget to true. The input is not
7772
    changed - we just simulate ungetting by modifying chars_read_total,
7773
    chars_read_current_line, and token_string. The next call to get() will
7774
    behave as if the unget character is read again.
7775
    */
7776
    void unget()
7777
    {
7778
        next_unget = true;
7779

7780
        --position.chars_read_total;
7781

7782
        // in case we "unget" a newline, we have to also decrement the lines_read
7783
        if (position.chars_read_current_line == 0)
7784
        {
7785
            if (position.lines_read > 0)
7786
            {
7787
                --position.lines_read;
7788
            }
7789
        }
7790
        else
7791
        {
7792
            --position.chars_read_current_line;
7793
        }
7794

7795
        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7796
        {
7797
            JSON_ASSERT(!token_string.empty());
7798
            token_string.pop_back();
7799
        }
7800
    }
7801

7802
    /// add a character to token_buffer
7803
    void add(char_int_type c)
7804
    {
7805
        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
7806
    }
7807

7808
  public:
7809
    /////////////////////
7810
    // value getters
7811
    /////////////////////
7812

7813
    /// return integer value
7814
    constexpr number_integer_t get_number_integer() const noexcept
7815
    {
7816
        return value_integer;
7817
    }
7818

7819
    /// return unsigned integer value
7820
    constexpr number_unsigned_t get_number_unsigned() const noexcept
7821
    {
7822
        return value_unsigned;
7823
    }
7824

7825
    /// return floating-point value
7826
    constexpr number_float_t get_number_float() const noexcept
7827
    {
7828
        return value_float;
7829
    }
7830

7831
    /// return current string value (implicitly resets the token; useful only once)
7832
    string_t& get_string()
7833
    {
7834
        return token_buffer;
7835
    }
7836

7837
    /////////////////////
7838
    // diagnostics
7839
    /////////////////////
7840

7841
    /// return position of last read token
7842
    constexpr position_t get_position() const noexcept
7843
    {
7844
        return position;
7845
    }
7846

7847
    /// return the last read token (for errors only).  Will never contain EOF
7848
    /// (an arbitrary value that is not a valid char value, often -1), because
7849
    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
7850
    std::string get_token_string() const
7851
    {
7852
        // escape control characters
7853
        std::string result;
7854
        for (const auto c : token_string)
7855
        {
7856
            if (static_cast<unsigned char>(c) <= '\x1F')
7857
            {
7858
                // escape control characters
7859
                std::array<char, 9> cs{{}};
7860
                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
7861
                result += cs.data();
7862
            }
7863
            else
7864
            {
7865
                // add character as is
7866
                result.push_back(static_cast<std::string::value_type>(c));
7867
            }
7868
        }
7869

7870
        return result;
7871
    }
7872

7873
    /// return syntax error message
7874
    JSON_HEDLEY_RETURNS_NON_NULL
7875
    constexpr const char* get_error_message() const noexcept
7876
    {
7877
        return error_message;
7878
    }
7879

7880
    /////////////////////
7881
    // actual scanner
7882
    /////////////////////
7883

7884
    /*!
7885
    @brief skip the UTF-8 byte order mark
7886
    @return true iff there is no BOM or the correct BOM has been skipped
7887
    */
7888
    bool skip_bom()
7889
    {
7890
        if (get() == 0xEF)
7891
        {
7892
            // check if we completely parse the BOM
7893
            return get() == 0xBB && get() == 0xBF;
7894
        }
7895

7896
        // the first character is not the beginning of the BOM; unget it to
7897
        // process is later
7898
        unget();
7899
        return true;
7900
    }
7901

7902
    void skip_whitespace()
7903
    {
7904
        do
7905
        {
7906
            get();
7907
        }
7908
        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
7909
    }
7910

7911
    token_type scan()
7912
    {
7913
        // initially, skip the BOM
7914
        if (position.chars_read_total == 0 && !skip_bom())
7915
        {
7916
            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
7917
            return token_type::parse_error;
7918
        }
7919

7920
        // read next character and ignore whitespace
7921
        skip_whitespace();
7922

7923
        // ignore comments
7924
        while (ignore_comments && current == '/')
7925
        {
7926
            if (!scan_comment())
7927
            {
7928
                return token_type::parse_error;
7929
            }
7930

7931
            // skip following whitespace
7932
            skip_whitespace();
7933
        }
7934

7935
        switch (current)
7936
        {
7937
            // structural characters
7938
            case '[':
7939
                return token_type::begin_array;
7940
            case ']':
7941
                return token_type::end_array;
7942
            case '{':
7943
                return token_type::begin_object;
7944
            case '}':
7945
                return token_type::end_object;
7946
            case ':':
7947
                return token_type::name_separator;
7948
            case ',':
7949
                return token_type::value_separator;
7950

7951
            // literals
7952
            case 't':
7953
            {
7954
                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
7955
                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
7956
            }
7957
            case 'f':
7958
            {
7959
                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
7960
                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
7961
            }
7962
            case 'n':
7963
            {
7964
                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
7965
                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
7966
            }
7967

7968
            // string
7969
            case '\"':
7970
                return scan_string();
7971

7972
            // number
7973
            case '-':
7974
            case '0':
7975
            case '1':
7976
            case '2':
7977
            case '3':
7978
            case '4':
7979
            case '5':
7980
            case '6':
7981
            case '7':
7982
            case '8':
7983
            case '9':
7984
                return scan_number();
7985

7986
            // end of input (the null byte is needed when parsing from
7987
            // string literals)
7988
            case '\0':
7989
            case std::char_traits<char_type>::eof():
7990
                return token_type::end_of_input;
7991

7992
            // error
7993
            default:
7994
                error_message = "invalid literal";
7995
                return token_type::parse_error;
7996
        }
7997
    }
7998

7999
  private:
8000
    /// input adapter
8001
    InputAdapterType ia;
8002

8003
    /// whether comments should be ignored (true) or signaled as errors (false)
8004
    const bool ignore_comments = false;
8005

8006
    /// the current character
8007
    char_int_type current = std::char_traits<char_type>::eof();
8008

8009
    /// whether the next get() call should just return current
8010
    bool next_unget = false;
8011

8012
    /// the start position of the current token
8013
    position_t position {};
8014

8015
    /// raw input token string (for error messages)
8016
    std::vector<char_type> token_string {};
8017

8018
    /// buffer for variable-length tokens (numbers, strings)
8019
    string_t token_buffer {};
8020

8021
    /// a description of occurred lexer errors
8022
    const char* error_message = "";
8023

8024
    // number values
8025
    number_integer_t value_integer = 0;
8026
    number_unsigned_t value_unsigned = 0;
8027
    number_float_t value_float = 0;
8028

8029
    /// the decimal point
8030
    const char_int_type decimal_point_char = '.';
8031
};
8032
}  // namespace detail
8033
}  // namespace nlohmann
8034

8035
// #include <nlohmann/detail/macro_scope.hpp>
8036

8037
// #include <nlohmann/detail/meta/is_sax.hpp>
8038

8039

8040
#include <cstdint> // size_t
8041
#include <utility> // declval
8042
#include <string> // string
8043

8044
// #include <nlohmann/detail/meta/detected.hpp>
8045

8046
// #include <nlohmann/detail/meta/type_traits.hpp>
8047

8048

8049
namespace nlohmann
8050
{
8051
namespace detail
8052
{
8053
template<typename T>
8054
using null_function_t = decltype(std::declval<T&>().null());
8055

8056
template<typename T>
8057
using boolean_function_t =
8058
    decltype(std::declval<T&>().boolean(std::declval<bool>()));
8059

8060
template<typename T, typename Integer>
8061
using number_integer_function_t =
8062
    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8063

8064
template<typename T, typename Unsigned>
8065
using number_unsigned_function_t =
8066
    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8067

8068
template<typename T, typename Float, typename String>
8069
using number_float_function_t = decltype(std::declval<T&>().number_float(
8070
                                    std::declval<Float>(), std::declval<const String&>()));
8071

8072
template<typename T, typename String>
8073
using string_function_t =
8074
    decltype(std::declval<T&>().string(std::declval<String&>()));
8075

8076
template<typename T, typename Binary>
8077
using binary_function_t =
8078
    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8079

8080
template<typename T>
8081
using start_object_function_t =
8082
    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8083

8084
template<typename T, typename String>
8085
using key_function_t =
8086
    decltype(std::declval<T&>().key(std::declval<String&>()));
8087

8088
template<typename T>
8089
using end_object_function_t = decltype(std::declval<T&>().end_object());
8090

8091
template<typename T>
8092
using start_array_function_t =
8093
    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
8094

8095
template<typename T>
8096
using end_array_function_t = decltype(std::declval<T&>().end_array());
8097

8098
template<typename T, typename Exception>
8099
using parse_error_function_t = decltype(std::declval<T&>().parse_error(
8100
        std::declval<std::size_t>(), std::declval<const std::string&>(),
8101
        std::declval<const Exception&>()));
8102

8103
template<typename SAX, typename BasicJsonType>
8104
struct is_sax
8105
{
8106
  private:
8107
    static_assert(is_basic_json<BasicJsonType>::value,
8108
                  "BasicJsonType must be of type basic_json<...>");
8109

8110
    using number_integer_t = typename BasicJsonType::number_integer_t;
8111
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8112
    using number_float_t = typename BasicJsonType::number_float_t;
8113
    using string_t = typename BasicJsonType::string_t;
8114
    using binary_t = typename BasicJsonType::binary_t;
8115
    using exception_t = typename BasicJsonType::exception;
8116

8117
  public:
8118
    static constexpr bool value =
8119
        is_detected_exact<bool, null_function_t, SAX>::value &&
8120
        is_detected_exact<bool, boolean_function_t, SAX>::value &&
8121
        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
8122
        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
8123
        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
8124
        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
8125
        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
8126
        is_detected_exact<bool, start_object_function_t, SAX>::value &&
8127
        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
8128
        is_detected_exact<bool, end_object_function_t, SAX>::value &&
8129
        is_detected_exact<bool, start_array_function_t, SAX>::value &&
8130
        is_detected_exact<bool, end_array_function_t, SAX>::value &&
8131
        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
8132
};
8133

8134
template<typename SAX, typename BasicJsonType>
8135
struct is_sax_static_asserts
8136
{
8137
  private:
8138
    static_assert(is_basic_json<BasicJsonType>::value,
8139
                  "BasicJsonType must be of type basic_json<...>");
8140

8141
    using number_integer_t = typename BasicJsonType::number_integer_t;
8142
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8143
    using number_float_t = typename BasicJsonType::number_float_t;
8144
    using string_t = typename BasicJsonType::string_t;
8145
    using binary_t = typename BasicJsonType::binary_t;
8146
    using exception_t = typename BasicJsonType::exception;
8147

8148
  public:
8149
    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
8150
                  "Missing/invalid function: bool null()");
8151
    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8152
                  "Missing/invalid function: bool boolean(bool)");
8153
    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8154
                  "Missing/invalid function: bool boolean(bool)");
8155
    static_assert(
8156
        is_detected_exact<bool, number_integer_function_t, SAX,
8157
        number_integer_t>::value,
8158
        "Missing/invalid function: bool number_integer(number_integer_t)");
8159
    static_assert(
8160
        is_detected_exact<bool, number_unsigned_function_t, SAX,
8161
        number_unsigned_t>::value,
8162
        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
8163
    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
8164
                  number_float_t, string_t>::value,
8165
                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
8166
    static_assert(
8167
        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
8168
        "Missing/invalid function: bool string(string_t&)");
8169
    static_assert(
8170
        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
8171
        "Missing/invalid function: bool binary(binary_t&)");
8172
    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
8173
                  "Missing/invalid function: bool start_object(std::size_t)");
8174
    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
8175
                  "Missing/invalid function: bool key(string_t&)");
8176
    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
8177
                  "Missing/invalid function: bool end_object()");
8178
    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
8179
                  "Missing/invalid function: bool start_array(std::size_t)");
8180
    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
8181
                  "Missing/invalid function: bool end_array()");
8182
    static_assert(
8183
        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
8184
        "Missing/invalid function: bool parse_error(std::size_t, const "
8185
        "std::string&, const exception&)");
8186
};
8187
}  // namespace detail
8188
}  // namespace nlohmann
8189

8190
// #include <nlohmann/detail/meta/type_traits.hpp>
8191

8192
// #include <nlohmann/detail/value_t.hpp>
8193

8194

8195
namespace nlohmann
8196
{
8197
namespace detail
8198
{
8199

8200
/// how to treat CBOR tags
8201
enum class cbor_tag_handler_t
8202
{
8203
    error,   ///< throw a parse_error exception in case of a tag
8204
    ignore,  ///< ignore tags
8205
    store    ///< store tags as binary type
8206
};
8207

8208
/*!
8209
@brief determine system byte order
8210

8211
@return true if and only if system's byte order is little endian
8212

8213
@note from https://stackoverflow.com/a/1001328/266378
8214
*/
8215
static inline bool little_endianness(int num = 1) noexcept
8216
{
8217
    return *reinterpret_cast<char*>(&num) == 1;
8218
}
8219

8220

8221
///////////////////
8222
// binary reader //
8223
///////////////////
8224

8225
/*!
8226
@brief deserialization of CBOR, MessagePack, and UBJSON values
8227
*/
8228
template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
8229
class binary_reader
8230
{
8231
    using number_integer_t = typename BasicJsonType::number_integer_t;
8232
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8233
    using number_float_t = typename BasicJsonType::number_float_t;
8234
    using string_t = typename BasicJsonType::string_t;
8235
    using binary_t = typename BasicJsonType::binary_t;
8236
    using json_sax_t = SAX;
8237
    using char_type = typename InputAdapterType::char_type;
8238
    using char_int_type = typename std::char_traits<char_type>::int_type;
8239

8240
  public:
8241
    /*!
8242
    @brief create a binary reader
8243

8244
    @param[in] adapter  input adapter to read from
8245
    */
8246
    explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
8247
    {
8248
        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
8249
    }
8250

8251
    // make class move-only
8252
    binary_reader(const binary_reader&) = delete;
8253
    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
8254
    binary_reader& operator=(const binary_reader&) = delete;
8255
    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
8256
    ~binary_reader() = default;
8257

8258
    /*!
8259
    @param[in] format  the binary format to parse
8260
    @param[in] sax_    a SAX event processor
8261
    @param[in] strict  whether to expect the input to be consumed completed
8262
    @param[in] tag_handler  how to treat CBOR tags
8263

8264
    @return whether parsing was successful
8265
    */
8266
    JSON_HEDLEY_NON_NULL(3)
8267
    bool sax_parse(const input_format_t format,
8268
                   json_sax_t* sax_,
8269
                   const bool strict = true,
8270
                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
8271
    {
8272
        sax = sax_;
8273
        bool result = false;
8274

8275
        switch (format)
8276
        {
8277
            case input_format_t::bson:
8278
                result = parse_bson_internal();
8279
                break;
8280

8281
            case input_format_t::cbor:
8282
                result = parse_cbor_internal(true, tag_handler);
8283
                break;
8284

8285
            case input_format_t::msgpack:
8286
                result = parse_msgpack_internal();
8287
                break;
8288

8289
            case input_format_t::ubjson:
8290
                result = parse_ubjson_internal();
8291
                break;
8292

8293
            case input_format_t::json: // LCOV_EXCL_LINE
8294
            default:            // LCOV_EXCL_LINE
8295
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
8296
        }
8297

8298
        // strict mode: next byte must be EOF
8299
        if (result && strict)
8300
        {
8301
            if (format == input_format_t::ubjson)
8302
            {
8303
                get_ignore_noop();
8304
            }
8305
            else
8306
            {
8307
                get();
8308
            }
8309

8310
            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
8311
            {
8312
                return sax->parse_error(chars_read, get_token_string(),
8313
                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value"), BasicJsonType()));
8314
            }
8315
        }
8316

8317
        return result;
8318
    }
8319

8320
  private:
8321
    //////////
8322
    // BSON //
8323
    //////////
8324

8325
    /*!
8326
    @brief Reads in a BSON-object and passes it to the SAX-parser.
8327
    @return whether a valid BSON-value was passed to the SAX parser
8328
    */
8329
    bool parse_bson_internal()
8330
    {
8331
        std::int32_t document_size{};
8332
        get_number<std::int32_t, true>(input_format_t::bson, document_size);
8333

8334
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
8335
        {
8336
            return false;
8337
        }
8338

8339
        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
8340
        {
8341
            return false;
8342
        }
8343

8344
        return sax->end_object();
8345
    }
8346

8347
    /*!
8348
    @brief Parses a C-style string from the BSON input.
8349
    @param[in,out] result  A reference to the string variable where the read
8350
                            string is to be stored.
8351
    @return `true` if the \x00-byte indicating the end of the string was
8352
             encountered before the EOF; false` indicates an unexpected EOF.
8353
    */
8354
    bool get_bson_cstr(string_t& result)
8355
    {
8356
        auto out = std::back_inserter(result);
8357
        while (true)
8358
        {
8359
            get();
8360
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
8361
            {
8362
                return false;
8363
            }
8364
            if (current == 0x00)
8365
            {
8366
                return true;
8367
            }
8368
            *out++ = static_cast<typename string_t::value_type>(current);
8369
        }
8370
    }
8371

8372
    /*!
8373
    @brief Parses a zero-terminated string of length @a len from the BSON
8374
           input.
8375
    @param[in] len  The length (including the zero-byte at the end) of the
8376
                    string to be read.
8377
    @param[in,out] result  A reference to the string variable where the read
8378
                            string is to be stored.
8379
    @tparam NumberType The type of the length @a len
8380
    @pre len >= 1
8381
    @return `true` if the string was successfully parsed
8382
    */
8383
    template<typename NumberType>
8384
    bool get_bson_string(const NumberType len, string_t& result)
8385
    {
8386
        if (JSON_HEDLEY_UNLIKELY(len < 1))
8387
        {
8388
            auto last_token = get_token_string();
8389
            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string"), BasicJsonType()));
8390
        }
8391

8392
        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
8393
    }
8394

8395
    /*!
8396
    @brief Parses a byte array input of length @a len from the BSON input.
8397
    @param[in] len  The length of the byte array to be read.
8398
    @param[in,out] result  A reference to the binary variable where the read
8399
                            array is to be stored.
8400
    @tparam NumberType The type of the length @a len
8401
    @pre len >= 0
8402
    @return `true` if the byte array was successfully parsed
8403
    */
8404
    template<typename NumberType>
8405
    bool get_bson_binary(const NumberType len, binary_t& result)
8406
    {
8407
        if (JSON_HEDLEY_UNLIKELY(len < 0))
8408
        {
8409
            auto last_token = get_token_string();
8410
            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary"), BasicJsonType()));
8411
        }
8412

8413
        // All BSON binary values have a subtype
8414
        std::uint8_t subtype{};
8415
        get_number<std::uint8_t>(input_format_t::bson, subtype);
8416
        result.set_subtype(subtype);
8417

8418
        return get_binary(input_format_t::bson, len, result);
8419
    }
8420

8421
    /*!
8422
    @brief Read a BSON document element of the given @a element_type.
8423
    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
8424
    @param[in] element_type_parse_position The position in the input stream,
8425
               where the `element_type` was read.
8426
    @warning Not all BSON element types are supported yet. An unsupported
8427
             @a element_type will give rise to a parse_error.114:
8428
             Unsupported BSON record type 0x...
8429
    @return whether a valid BSON-object/array was passed to the SAX parser
8430
    */
8431
    bool parse_bson_element_internal(const char_int_type element_type,
8432
                                     const std::size_t element_type_parse_position)
8433
    {
8434
        switch (element_type)
8435
        {
8436
            case 0x01: // double
8437
            {
8438
                double number{};
8439
                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
8440
            }
8441

8442
            case 0x02: // string
8443
            {
8444
                std::int32_t len{};
8445
                string_t value;
8446
                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
8447
            }
8448

8449
            case 0x03: // object
8450
            {
8451
                return parse_bson_internal();
8452
            }
8453

8454
            case 0x04: // array
8455
            {
8456
                return parse_bson_array();
8457
            }
8458

8459
            case 0x05: // binary
8460
            {
8461
                std::int32_t len{};
8462
                binary_t value;
8463
                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
8464
            }
8465

8466
            case 0x08: // boolean
8467
            {
8468
                return sax->boolean(get() != 0);
8469
            }
8470

8471
            case 0x0A: // null
8472
            {
8473
                return sax->null();
8474
            }
8475

8476
            case 0x10: // int32
8477
            {
8478
                std::int32_t value{};
8479
                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8480
            }
8481

8482
            case 0x12: // int64
8483
            {
8484
                std::int64_t value{};
8485
                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8486
            }
8487

8488
            default: // anything else not supported (yet)
8489
            {
8490
                std::array<char, 3> cr{{}};
8491
                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8492
                return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data()), BasicJsonType()));
8493
            }
8494
        }
8495
    }
8496

8497
    /*!
8498
    @brief Read a BSON element list (as specified in the BSON-spec)
8499

8500
    The same binary layout is used for objects and arrays, hence it must be
8501
    indicated with the argument @a is_array which one is expected
8502
    (true --> array, false --> object).
8503

8504
    @param[in] is_array Determines if the element list being read is to be
8505
                        treated as an object (@a is_array == false), or as an
8506
                        array (@a is_array == true).
8507
    @return whether a valid BSON-object/array was passed to the SAX parser
8508
    */
8509
    bool parse_bson_element_list(const bool is_array)
8510
    {
8511
        string_t key;
8512

8513
        while (auto element_type = get())
8514
        {
8515
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
8516
            {
8517
                return false;
8518
            }
8519

8520
            const std::size_t element_type_parse_position = chars_read;
8521
            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
8522
            {
8523
                return false;
8524
            }
8525

8526
            if (!is_array && !sax->key(key))
8527
            {
8528
                return false;
8529
            }
8530

8531
            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
8532
            {
8533
                return false;
8534
            }
8535

8536
            // get_bson_cstr only appends
8537
            key.clear();
8538
        }
8539

8540
        return true;
8541
    }
8542

8543
    /*!
8544
    @brief Reads an array from the BSON input and passes it to the SAX-parser.
8545
    @return whether a valid BSON-array was passed to the SAX parser
8546
    */
8547
    bool parse_bson_array()
8548
    {
8549
        std::int32_t document_size{};
8550
        get_number<std::int32_t, true>(input_format_t::bson, document_size);
8551

8552
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
8553
        {
8554
            return false;
8555
        }
8556

8557
        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
8558
        {
8559
            return false;
8560
        }
8561

8562
        return sax->end_array();
8563
    }
8564

8565
    //////////
8566
    // CBOR //
8567
    //////////
8568

8569
    /*!
8570
    @param[in] get_char  whether a new character should be retrieved from the
8571
                         input (true) or whether the last read character should
8572
                         be considered instead (false)
8573
    @param[in] tag_handler how CBOR tags should be treated
8574

8575
    @return whether a valid CBOR value was passed to the SAX parser
8576
    */
8577
    bool parse_cbor_internal(const bool get_char,
8578
                             const cbor_tag_handler_t tag_handler)
8579
    {
8580
        switch (get_char ? get() : current)
8581
        {
8582
            // EOF
8583
            case std::char_traits<char_type>::eof():
8584
                return unexpect_eof(input_format_t::cbor, "value");
8585

8586
            // Integer 0x00..0x17 (0..23)
8587
            case 0x00:
8588
            case 0x01:
8589
            case 0x02:
8590
            case 0x03:
8591
            case 0x04:
8592
            case 0x05:
8593
            case 0x06:
8594
            case 0x07:
8595
            case 0x08:
8596
            case 0x09:
8597
            case 0x0A:
8598
            case 0x0B:
8599
            case 0x0C:
8600
            case 0x0D:
8601
            case 0x0E:
8602
            case 0x0F:
8603
            case 0x10:
8604
            case 0x11:
8605
            case 0x12:
8606
            case 0x13:
8607
            case 0x14:
8608
            case 0x15:
8609
            case 0x16:
8610
            case 0x17:
8611
                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
8612

8613
            case 0x18: // Unsigned integer (one-byte uint8_t follows)
8614
            {
8615
                std::uint8_t number{};
8616
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8617
            }
8618

8619
            case 0x19: // Unsigned integer (two-byte uint16_t follows)
8620
            {
8621
                std::uint16_t number{};
8622
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8623
            }
8624

8625
            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
8626
            {
8627
                std::uint32_t number{};
8628
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8629
            }
8630

8631
            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
8632
            {
8633
                std::uint64_t number{};
8634
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8635
            }
8636

8637
            // Negative integer -1-0x00..-1-0x17 (-1..-24)
8638
            case 0x20:
8639
            case 0x21:
8640
            case 0x22:
8641
            case 0x23:
8642
            case 0x24:
8643
            case 0x25:
8644
            case 0x26:
8645
            case 0x27:
8646
            case 0x28:
8647
            case 0x29:
8648
            case 0x2A:
8649
            case 0x2B:
8650
            case 0x2C:
8651
            case 0x2D:
8652
            case 0x2E:
8653
            case 0x2F:
8654
            case 0x30:
8655
            case 0x31:
8656
            case 0x32:
8657
            case 0x33:
8658
            case 0x34:
8659
            case 0x35:
8660
            case 0x36:
8661
            case 0x37:
8662
                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
8663

8664
            case 0x38: // Negative integer (one-byte uint8_t follows)
8665
            {
8666
                std::uint8_t number{};
8667
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8668
            }
8669

8670
            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
8671
            {
8672
                std::uint16_t number{};
8673
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8674
            }
8675

8676
            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
8677
            {
8678
                std::uint32_t number{};
8679
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8680
            }
8681

8682
            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
8683
            {
8684
                std::uint64_t number{};
8685
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
8686
                        - static_cast<number_integer_t>(number));
8687
            }
8688

8689
            // Binary data (0x00..0x17 bytes follow)
8690
            case 0x40:
8691
            case 0x41:
8692
            case 0x42:
8693
            case 0x43:
8694
            case 0x44:
8695
            case 0x45:
8696
            case 0x46:
8697
            case 0x47:
8698
            case 0x48:
8699
            case 0x49:
8700
            case 0x4A:
8701
            case 0x4B:
8702
            case 0x4C:
8703
            case 0x4D:
8704
            case 0x4E:
8705
            case 0x4F:
8706
            case 0x50:
8707
            case 0x51:
8708
            case 0x52:
8709
            case 0x53:
8710
            case 0x54:
8711
            case 0x55:
8712
            case 0x56:
8713
            case 0x57:
8714
            case 0x58: // Binary data (one-byte uint8_t for n follows)
8715
            case 0x59: // Binary data (two-byte uint16_t for n follow)
8716
            case 0x5A: // Binary data (four-byte uint32_t for n follow)
8717
            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
8718
            case 0x5F: // Binary data (indefinite length)
8719
            {
8720
                binary_t b;
8721
                return get_cbor_binary(b) && sax->binary(b);
8722
            }
8723

8724
            // UTF-8 string (0x00..0x17 bytes follow)
8725
            case 0x60:
8726
            case 0x61:
8727
            case 0x62:
8728
            case 0x63:
8729
            case 0x64:
8730
            case 0x65:
8731
            case 0x66:
8732
            case 0x67:
8733
            case 0x68:
8734
            case 0x69:
8735
            case 0x6A:
8736
            case 0x6B:
8737
            case 0x6C:
8738
            case 0x6D:
8739
            case 0x6E:
8740
            case 0x6F:
8741
            case 0x70:
8742
            case 0x71:
8743
            case 0x72:
8744
            case 0x73:
8745
            case 0x74:
8746
            case 0x75:
8747
            case 0x76:
8748
            case 0x77:
8749
            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
8750
            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
8751
            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
8752
            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
8753
            case 0x7F: // UTF-8 string (indefinite length)
8754
            {
8755
                string_t s;
8756
                return get_cbor_string(s) && sax->string(s);
8757
            }
8758

8759
            // array (0x00..0x17 data items follow)
8760
            case 0x80:
8761
            case 0x81:
8762
            case 0x82:
8763
            case 0x83:
8764
            case 0x84:
8765
            case 0x85:
8766
            case 0x86:
8767
            case 0x87:
8768
            case 0x88:
8769
            case 0x89:
8770
            case 0x8A:
8771
            case 0x8B:
8772
            case 0x8C:
8773
            case 0x8D:
8774
            case 0x8E:
8775
            case 0x8F:
8776
            case 0x90:
8777
            case 0x91:
8778
            case 0x92:
8779
            case 0x93:
8780
            case 0x94:
8781
            case 0x95:
8782
            case 0x96:
8783
            case 0x97:
8784
                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8785

8786
            case 0x98: // array (one-byte uint8_t for n follows)
8787
            {
8788
                std::uint8_t len{};
8789
                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8790
            }
8791

8792
            case 0x99: // array (two-byte uint16_t for n follow)
8793
            {
8794
                std::uint16_t len{};
8795
                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8796
            }
8797

8798
            case 0x9A: // array (four-byte uint32_t for n follow)
8799
            {
8800
                std::uint32_t len{};
8801
                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8802
            }
8803

8804
            case 0x9B: // array (eight-byte uint64_t for n follow)
8805
            {
8806
                std::uint64_t len{};
8807
                return get_number(input_format_t::cbor, len) && get_cbor_array(detail::conditional_static_cast<std::size_t>(len), tag_handler);
8808
            }
8809

8810
            case 0x9F: // array (indefinite length)
8811
                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
8812

8813
            // map (0x00..0x17 pairs of data items follow)
8814
            case 0xA0:
8815
            case 0xA1:
8816
            case 0xA2:
8817
            case 0xA3:
8818
            case 0xA4:
8819
            case 0xA5:
8820
            case 0xA6:
8821
            case 0xA7:
8822
            case 0xA8:
8823
            case 0xA9:
8824
            case 0xAA:
8825
            case 0xAB:
8826
            case 0xAC:
8827
            case 0xAD:
8828
            case 0xAE:
8829
            case 0xAF:
8830
            case 0xB0:
8831
            case 0xB1:
8832
            case 0xB2:
8833
            case 0xB3:
8834
            case 0xB4:
8835
            case 0xB5:
8836
            case 0xB6:
8837
            case 0xB7:
8838
                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8839

8840
            case 0xB8: // map (one-byte uint8_t for n follows)
8841
            {
8842
                std::uint8_t len{};
8843
                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8844
            }
8845

8846
            case 0xB9: // map (two-byte uint16_t for n follow)
8847
            {
8848
                std::uint16_t len{};
8849
                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8850
            }
8851

8852
            case 0xBA: // map (four-byte uint32_t for n follow)
8853
            {
8854
                std::uint32_t len{};
8855
                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8856
            }
8857

8858
            case 0xBB: // map (eight-byte uint64_t for n follow)
8859
            {
8860
                std::uint64_t len{};
8861
                return get_number(input_format_t::cbor, len) && get_cbor_object(detail::conditional_static_cast<std::size_t>(len), tag_handler);
8862
            }
8863

8864
            case 0xBF: // map (indefinite length)
8865
                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
8866

8867
            case 0xC6: // tagged item
8868
            case 0xC7:
8869
            case 0xC8:
8870
            case 0xC9:
8871
            case 0xCA:
8872
            case 0xCB:
8873
            case 0xCC:
8874
            case 0xCD:
8875
            case 0xCE:
8876
            case 0xCF:
8877
            case 0xD0:
8878
            case 0xD1:
8879
            case 0xD2:
8880
            case 0xD3:
8881
            case 0xD4:
8882
            case 0xD8: // tagged item (1 bytes follow)
8883
            case 0xD9: // tagged item (2 bytes follow)
8884
            case 0xDA: // tagged item (4 bytes follow)
8885
            case 0xDB: // tagged item (8 bytes follow)
8886
            {
8887
                switch (tag_handler)
8888
                {
8889
                    case cbor_tag_handler_t::error:
8890
                    {
8891
                        auto last_token = get_token_string();
8892
                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
8893
                    }
8894

8895
                    case cbor_tag_handler_t::ignore:
8896
                    {
8897
                        // ignore binary subtype
8898
                        switch (current)
8899
                        {
8900
                            case 0xD8:
8901
                            {
8902
                                std::uint8_t subtype_to_ignore{};
8903
                                get_number(input_format_t::cbor, subtype_to_ignore);
8904
                                break;
8905
                            }
8906
                            case 0xD9:
8907
                            {
8908
                                std::uint16_t subtype_to_ignore{};
8909
                                get_number(input_format_t::cbor, subtype_to_ignore);
8910
                                break;
8911
                            }
8912
                            case 0xDA:
8913
                            {
8914
                                std::uint32_t subtype_to_ignore{};
8915
                                get_number(input_format_t::cbor, subtype_to_ignore);
8916
                                break;
8917
                            }
8918
                            case 0xDB:
8919
                            {
8920
                                std::uint64_t subtype_to_ignore{};
8921
                                get_number(input_format_t::cbor, subtype_to_ignore);
8922
                                break;
8923
                            }
8924
                            default:
8925
                                break;
8926
                        }
8927
                        return parse_cbor_internal(true, tag_handler);
8928
                    }
8929

8930
                    case cbor_tag_handler_t::store:
8931
                    {
8932
                        binary_t b;
8933
                        // use binary subtype and store in binary container
8934
                        switch (current)
8935
                        {
8936
                            case 0xD8:
8937
                            {
8938
                                std::uint8_t subtype{};
8939
                                get_number(input_format_t::cbor, subtype);
8940
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8941
                                break;
8942
                            }
8943
                            case 0xD9:
8944
                            {
8945
                                std::uint16_t subtype{};
8946
                                get_number(input_format_t::cbor, subtype);
8947
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8948
                                break;
8949
                            }
8950
                            case 0xDA:
8951
                            {
8952
                                std::uint32_t subtype{};
8953
                                get_number(input_format_t::cbor, subtype);
8954
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8955
                                break;
8956
                            }
8957
                            case 0xDB:
8958
                            {
8959
                                std::uint64_t subtype{};
8960
                                get_number(input_format_t::cbor, subtype);
8961
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8962
                                break;
8963
                            }
8964
                            default:
8965
                                return parse_cbor_internal(true, tag_handler);
8966
                        }
8967
                        get();
8968
                        return get_cbor_binary(b) && sax->binary(b);
8969
                    }
8970

8971
                    default:                 // LCOV_EXCL_LINE
8972
                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
8973
                        return false;        // LCOV_EXCL_LINE
8974
                }
8975
            }
8976

8977
            case 0xF4: // false
8978
                return sax->boolean(false);
8979

8980
            case 0xF5: // true
8981
                return sax->boolean(true);
8982

8983
            case 0xF6: // null
8984
                return sax->null();
8985

8986
            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
8987
            {
8988
                const auto byte1_raw = get();
8989
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8990
                {
8991
                    return false;
8992
                }
8993
                const auto byte2_raw = get();
8994
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8995
                {
8996
                    return false;
8997
                }
8998

8999
                const auto byte1 = static_cast<unsigned char>(byte1_raw);
9000
                const auto byte2 = static_cast<unsigned char>(byte2_raw);
9001

9002
                // code from RFC 7049, Appendix D, Figure 3:
9003
                // As half-precision floating-point numbers were only added
9004
                // to IEEE 754 in 2008, today's programming platforms often
9005
                // still only have limited support for them. It is very
9006
                // easy to include at least decoding support for them even
9007
                // without such support. An example of a small decoder for
9008
                // half-precision floating-point numbers in the C language
9009
                // is shown in Fig. 3.
9010
                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
9011
                const double val = [&half]
9012
                {
9013
                    const int exp = (half >> 10u) & 0x1Fu;
9014
                    const unsigned int mant = half & 0x3FFu;
9015
                    JSON_ASSERT(0 <= exp&& exp <= 32);
9016
                    JSON_ASSERT(mant <= 1024);
9017
                    switch (exp)
9018
                    {
9019
                        case 0:
9020
                            return std::ldexp(mant, -24);
9021
                        case 31:
9022
                            return (mant == 0)
9023
                            ? std::numeric_limits<double>::infinity()
9024
                            : std::numeric_limits<double>::quiet_NaN();
9025
                        default:
9026
                            return std::ldexp(mant + 1024, exp - 25);
9027
                    }
9028
                }();
9029
                return sax->number_float((half & 0x8000u) != 0
9030
                                         ? static_cast<number_float_t>(-val)
9031
                                         : static_cast<number_float_t>(val), "");
9032
            }
9033

9034
            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
9035
            {
9036
                float number{};
9037
                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
9038
            }
9039

9040
            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
9041
            {
9042
                double number{};
9043
                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
9044
            }
9045

9046
            default: // anything else (0xFF is handled inside the other types)
9047
            {
9048
                auto last_token = get_token_string();
9049
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
9050
            }
9051
        }
9052
    }
9053

9054
    /*!
9055
    @brief reads a CBOR string
9056

9057
    This function first reads starting bytes to determine the expected
9058
    string length and then copies this number of bytes into a string.
9059
    Additionally, CBOR's strings with indefinite lengths are supported.
9060

9061
    @param[out] result  created string
9062

9063
    @return whether string creation completed
9064
    */
9065
    bool get_cbor_string(string_t& result)
9066
    {
9067
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
9068
        {
9069
            return false;
9070
        }
9071

9072
        switch (current)
9073
        {
9074
            // UTF-8 string (0x00..0x17 bytes follow)
9075
            case 0x60:
9076
            case 0x61:
9077
            case 0x62:
9078
            case 0x63:
9079
            case 0x64:
9080
            case 0x65:
9081
            case 0x66:
9082
            case 0x67:
9083
            case 0x68:
9084
            case 0x69:
9085
            case 0x6A:
9086
            case 0x6B:
9087
            case 0x6C:
9088
            case 0x6D:
9089
            case 0x6E:
9090
            case 0x6F:
9091
            case 0x70:
9092
            case 0x71:
9093
            case 0x72:
9094
            case 0x73:
9095
            case 0x74:
9096
            case 0x75:
9097
            case 0x76:
9098
            case 0x77:
9099
            {
9100
                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
9101
            }
9102

9103
            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
9104
            {
9105
                std::uint8_t len{};
9106
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9107
            }
9108

9109
            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
9110
            {
9111
                std::uint16_t len{};
9112
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9113
            }
9114

9115
            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
9116
            {
9117
                std::uint32_t len{};
9118
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9119
            }
9120

9121
            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
9122
            {
9123
                std::uint64_t len{};
9124
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9125
            }
9126

9127
            case 0x7F: // UTF-8 string (indefinite length)
9128
            {
9129
                while (get() != 0xFF)
9130
                {
9131
                    string_t chunk;
9132
                    if (!get_cbor_string(chunk))
9133
                    {
9134
                        return false;
9135
                    }
9136
                    result.append(chunk);
9137
                }
9138
                return true;
9139
            }
9140

9141
            default:
9142
            {
9143
                auto last_token = get_token_string();
9144
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string"), BasicJsonType()));
9145
            }
9146
        }
9147
    }
9148

9149
    /*!
9150
    @brief reads a CBOR byte array
9151

9152
    This function first reads starting bytes to determine the expected
9153
    byte array length and then copies this number of bytes into the byte array.
9154
    Additionally, CBOR's byte arrays with indefinite lengths are supported.
9155

9156
    @param[out] result  created byte array
9157

9158
    @return whether byte array creation completed
9159
    */
9160
    bool get_cbor_binary(binary_t& result)
9161
    {
9162
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
9163
        {
9164
            return false;
9165
        }
9166

9167
        switch (current)
9168
        {
9169
            // Binary data (0x00..0x17 bytes follow)
9170
            case 0x40:
9171
            case 0x41:
9172
            case 0x42:
9173
            case 0x43:
9174
            case 0x44:
9175
            case 0x45:
9176
            case 0x46:
9177
            case 0x47:
9178
            case 0x48:
9179
            case 0x49:
9180
            case 0x4A:
9181
            case 0x4B:
9182
            case 0x4C:
9183
            case 0x4D:
9184
            case 0x4E:
9185
            case 0x4F:
9186
            case 0x50:
9187
            case 0x51:
9188
            case 0x52:
9189
            case 0x53:
9190
            case 0x54:
9191
            case 0x55:
9192
            case 0x56:
9193
            case 0x57:
9194
            {
9195
                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
9196
            }
9197

9198
            case 0x58: // Binary data (one-byte uint8_t for n follows)
9199
            {
9200
                std::uint8_t len{};
9201
                return get_number(input_format_t::cbor, len) &&
9202
                       get_binary(input_format_t::cbor, len, result);
9203
            }
9204

9205
            case 0x59: // Binary data (two-byte uint16_t for n follow)
9206
            {
9207
                std::uint16_t len{};
9208
                return get_number(input_format_t::cbor, len) &&
9209
                       get_binary(input_format_t::cbor, len, result);
9210
            }
9211

9212
            case 0x5A: // Binary data (four-byte uint32_t for n follow)
9213
            {
9214
                std::uint32_t len{};
9215
                return get_number(input_format_t::cbor, len) &&
9216
                       get_binary(input_format_t::cbor, len, result);
9217
            }
9218

9219
            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
9220
            {
9221
                std::uint64_t len{};
9222
                return get_number(input_format_t::cbor, len) &&
9223
                       get_binary(input_format_t::cbor, len, result);
9224
            }
9225

9226
            case 0x5F: // Binary data (indefinite length)
9227
            {
9228
                while (get() != 0xFF)
9229
                {
9230
                    binary_t chunk;
9231
                    if (!get_cbor_binary(chunk))
9232
                    {
9233
                        return false;
9234
                    }
9235
                    result.insert(result.end(), chunk.begin(), chunk.end());
9236
                }
9237
                return true;
9238
            }
9239

9240
            default:
9241
            {
9242
                auto last_token = get_token_string();
9243
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary"), BasicJsonType()));
9244
            }
9245
        }
9246
    }
9247

9248
    /*!
9249
    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
9250
                    array of indefinite size
9251
    @param[in] tag_handler how CBOR tags should be treated
9252
    @return whether array creation completed
9253
    */
9254
    bool get_cbor_array(const std::size_t len,
9255
                        const cbor_tag_handler_t tag_handler)
9256
    {
9257
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9258
        {
9259
            return false;
9260
        }
9261

9262
        if (len != static_cast<std::size_t>(-1))
9263
        {
9264
            for (std::size_t i = 0; i < len; ++i)
9265
            {
9266
                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
9267
                {
9268
                    return false;
9269
                }
9270
            }
9271
        }
9272
        else
9273
        {
9274
            while (get() != 0xFF)
9275
            {
9276
                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
9277
                {
9278
                    return false;
9279
                }
9280
            }
9281
        }
9282

9283
        return sax->end_array();
9284
    }
9285

9286
    /*!
9287
    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
9288
                    object of indefinite size
9289
    @param[in] tag_handler how CBOR tags should be treated
9290
    @return whether object creation completed
9291
    */
9292
    bool get_cbor_object(const std::size_t len,
9293
                         const cbor_tag_handler_t tag_handler)
9294
    {
9295
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9296
        {
9297
            return false;
9298
        }
9299

9300
        if (len != 0)
9301
        {
9302
            string_t key;
9303
            if (len != static_cast<std::size_t>(-1))
9304
            {
9305
                for (std::size_t i = 0; i < len; ++i)
9306
                {
9307
                    get();
9308
                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9309
                    {
9310
                        return false;
9311
                    }
9312

9313
                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
9314
                    {
9315
                        return false;
9316
                    }
9317
                    key.clear();
9318
                }
9319
            }
9320
            else
9321
            {
9322
                while (get() != 0xFF)
9323
                {
9324
                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9325
                    {
9326
                        return false;
9327
                    }
9328

9329
                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
9330
                    {
9331
                        return false;
9332
                    }
9333
                    key.clear();
9334
                }
9335
            }
9336
        }
9337

9338
        return sax->end_object();
9339
    }
9340

9341
    /////////////
9342
    // MsgPack //
9343
    /////////////
9344

9345
    /*!
9346
    @return whether a valid MessagePack value was passed to the SAX parser
9347
    */
9348
    bool parse_msgpack_internal()
9349
    {
9350
        switch (get())
9351
        {
9352
            // EOF
9353
            case std::char_traits<char_type>::eof():
9354
                return unexpect_eof(input_format_t::msgpack, "value");
9355

9356
            // positive fixint
9357
            case 0x00:
9358
            case 0x01:
9359
            case 0x02:
9360
            case 0x03:
9361
            case 0x04:
9362
            case 0x05:
9363
            case 0x06:
9364
            case 0x07:
9365
            case 0x08:
9366
            case 0x09:
9367
            case 0x0A:
9368
            case 0x0B:
9369
            case 0x0C:
9370
            case 0x0D:
9371
            case 0x0E:
9372
            case 0x0F:
9373
            case 0x10:
9374
            case 0x11:
9375
            case 0x12:
9376
            case 0x13:
9377
            case 0x14:
9378
            case 0x15:
9379
            case 0x16:
9380
            case 0x17:
9381
            case 0x18:
9382
            case 0x19:
9383
            case 0x1A:
9384
            case 0x1B:
9385
            case 0x1C:
9386
            case 0x1D:
9387
            case 0x1E:
9388
            case 0x1F:
9389
            case 0x20:
9390
            case 0x21:
9391
            case 0x22:
9392
            case 0x23:
9393
            case 0x24:
9394
            case 0x25:
9395
            case 0x26:
9396
            case 0x27:
9397
            case 0x28:
9398
            case 0x29:
9399
            case 0x2A:
9400
            case 0x2B:
9401
            case 0x2C:
9402
            case 0x2D:
9403
            case 0x2E:
9404
            case 0x2F:
9405
            case 0x30:
9406
            case 0x31:
9407
            case 0x32:
9408
            case 0x33:
9409
            case 0x34:
9410
            case 0x35:
9411
            case 0x36:
9412
            case 0x37:
9413
            case 0x38:
9414
            case 0x39:
9415
            case 0x3A:
9416
            case 0x3B:
9417
            case 0x3C:
9418
            case 0x3D:
9419
            case 0x3E:
9420
            case 0x3F:
9421
            case 0x40:
9422
            case 0x41:
9423
            case 0x42:
9424
            case 0x43:
9425
            case 0x44:
9426
            case 0x45:
9427
            case 0x46:
9428
            case 0x47:
9429
            case 0x48:
9430
            case 0x49:
9431
            case 0x4A:
9432
            case 0x4B:
9433
            case 0x4C:
9434
            case 0x4D:
9435
            case 0x4E:
9436
            case 0x4F:
9437
            case 0x50:
9438
            case 0x51:
9439
            case 0x52:
9440
            case 0x53:
9441
            case 0x54:
9442
            case 0x55:
9443
            case 0x56:
9444
            case 0x57:
9445
            case 0x58:
9446
            case 0x59:
9447
            case 0x5A:
9448
            case 0x5B:
9449
            case 0x5C:
9450
            case 0x5D:
9451
            case 0x5E:
9452
            case 0x5F:
9453
            case 0x60:
9454
            case 0x61:
9455
            case 0x62:
9456
            case 0x63:
9457
            case 0x64:
9458
            case 0x65:
9459
            case 0x66:
9460
            case 0x67:
9461
            case 0x68:
9462
            case 0x69:
9463
            case 0x6A:
9464
            case 0x6B:
9465
            case 0x6C:
9466
            case 0x6D:
9467
            case 0x6E:
9468
            case 0x6F:
9469
            case 0x70:
9470
            case 0x71:
9471
            case 0x72:
9472
            case 0x73:
9473
            case 0x74:
9474
            case 0x75:
9475
            case 0x76:
9476
            case 0x77:
9477
            case 0x78:
9478
            case 0x79:
9479
            case 0x7A:
9480
            case 0x7B:
9481
            case 0x7C:
9482
            case 0x7D:
9483
            case 0x7E:
9484
            case 0x7F:
9485
                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
9486

9487
            // fixmap
9488
            case 0x80:
9489
            case 0x81:
9490
            case 0x82:
9491
            case 0x83:
9492
            case 0x84:
9493
            case 0x85:
9494
            case 0x86:
9495
            case 0x87:
9496
            case 0x88:
9497
            case 0x89:
9498
            case 0x8A:
9499
            case 0x8B:
9500
            case 0x8C:
9501
            case 0x8D:
9502
            case 0x8E:
9503
            case 0x8F:
9504
                return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
9505

9506
            // fixarray
9507
            case 0x90:
9508
            case 0x91:
9509
            case 0x92:
9510
            case 0x93:
9511
            case 0x94:
9512
            case 0x95:
9513
            case 0x96:
9514
            case 0x97:
9515
            case 0x98:
9516
            case 0x99:
9517
            case 0x9A:
9518
            case 0x9B:
9519
            case 0x9C:
9520
            case 0x9D:
9521
            case 0x9E:
9522
            case 0x9F:
9523
                return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
9524

9525
            // fixstr
9526
            case 0xA0:
9527
            case 0xA1:
9528
            case 0xA2:
9529
            case 0xA3:
9530
            case 0xA4:
9531
            case 0xA5:
9532
            case 0xA6:
9533
            case 0xA7:
9534
            case 0xA8:
9535
            case 0xA9:
9536
            case 0xAA:
9537
            case 0xAB:
9538
            case 0xAC:
9539
            case 0xAD:
9540
            case 0xAE:
9541
            case 0xAF:
9542
            case 0xB0:
9543
            case 0xB1:
9544
            case 0xB2:
9545
            case 0xB3:
9546
            case 0xB4:
9547
            case 0xB5:
9548
            case 0xB6:
9549
            case 0xB7:
9550
            case 0xB8:
9551
            case 0xB9:
9552
            case 0xBA:
9553
            case 0xBB:
9554
            case 0xBC:
9555
            case 0xBD:
9556
            case 0xBE:
9557
            case 0xBF:
9558
            case 0xD9: // str 8
9559
            case 0xDA: // str 16
9560
            case 0xDB: // str 32
9561
            {
9562
                string_t s;
9563
                return get_msgpack_string(s) && sax->string(s);
9564
            }
9565

9566
            case 0xC0: // nil
9567
                return sax->null();
9568

9569
            case 0xC2: // false
9570
                return sax->boolean(false);
9571

9572
            case 0xC3: // true
9573
                return sax->boolean(true);
9574

9575
            case 0xC4: // bin 8
9576
            case 0xC5: // bin 16
9577
            case 0xC6: // bin 32
9578
            case 0xC7: // ext 8
9579
            case 0xC8: // ext 16
9580
            case 0xC9: // ext 32
9581
            case 0xD4: // fixext 1
9582
            case 0xD5: // fixext 2
9583
            case 0xD6: // fixext 4
9584
            case 0xD7: // fixext 8
9585
            case 0xD8: // fixext 16
9586
            {
9587
                binary_t b;
9588
                return get_msgpack_binary(b) && sax->binary(b);
9589
            }
9590

9591
            case 0xCA: // float 32
9592
            {
9593
                float number{};
9594
                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9595
            }
9596

9597
            case 0xCB: // float 64
9598
            {
9599
                double number{};
9600
                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9601
            }
9602

9603
            case 0xCC: // uint 8
9604
            {
9605
                std::uint8_t number{};
9606
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9607
            }
9608

9609
            case 0xCD: // uint 16
9610
            {
9611
                std::uint16_t number{};
9612
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9613
            }
9614

9615
            case 0xCE: // uint 32
9616
            {
9617
                std::uint32_t number{};
9618
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9619
            }
9620

9621
            case 0xCF: // uint 64
9622
            {
9623
                std::uint64_t number{};
9624
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9625
            }
9626

9627
            case 0xD0: // int 8
9628
            {
9629
                std::int8_t number{};
9630
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9631
            }
9632

9633
            case 0xD1: // int 16
9634
            {
9635
                std::int16_t number{};
9636
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9637
            }
9638

9639
            case 0xD2: // int 32
9640
            {
9641
                std::int32_t number{};
9642
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9643
            }
9644

9645
            case 0xD3: // int 64
9646
            {
9647
                std::int64_t number{};
9648
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9649
            }
9650

9651
            case 0xDC: // array 16
9652
            {
9653
                std::uint16_t len{};
9654
                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9655
            }
9656

9657
            case 0xDD: // array 32
9658
            {
9659
                std::uint32_t len{};
9660
                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9661
            }
9662

9663
            case 0xDE: // map 16
9664
            {
9665
                std::uint16_t len{};
9666
                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9667
            }
9668

9669
            case 0xDF: // map 32
9670
            {
9671
                std::uint32_t len{};
9672
                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9673
            }
9674

9675
            // negative fixint
9676
            case 0xE0:
9677
            case 0xE1:
9678
            case 0xE2:
9679
            case 0xE3:
9680
            case 0xE4:
9681
            case 0xE5:
9682
            case 0xE6:
9683
            case 0xE7:
9684
            case 0xE8:
9685
            case 0xE9:
9686
            case 0xEA:
9687
            case 0xEB:
9688
            case 0xEC:
9689
            case 0xED:
9690
            case 0xEE:
9691
            case 0xEF:
9692
            case 0xF0:
9693
            case 0xF1:
9694
            case 0xF2:
9695
            case 0xF3:
9696
            case 0xF4:
9697
            case 0xF5:
9698
            case 0xF6:
9699
            case 0xF7:
9700
            case 0xF8:
9701
            case 0xF9:
9702
            case 0xFA:
9703
            case 0xFB:
9704
            case 0xFC:
9705
            case 0xFD:
9706
            case 0xFE:
9707
            case 0xFF:
9708
                return sax->number_integer(static_cast<std::int8_t>(current));
9709

9710
            default: // anything else
9711
            {
9712
                auto last_token = get_token_string();
9713
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
9714
            }
9715
        }
9716
    }
9717

9718
    /*!
9719
    @brief reads a MessagePack string
9720

9721
    This function first reads starting bytes to determine the expected
9722
    string length and then copies this number of bytes into a string.
9723

9724
    @param[out] result  created string
9725

9726
    @return whether string creation completed
9727
    */
9728
    bool get_msgpack_string(string_t& result)
9729
    {
9730
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
9731
        {
9732
            return false;
9733
        }
9734

9735
        switch (current)
9736
        {
9737
            // fixstr
9738
            case 0xA0:
9739
            case 0xA1:
9740
            case 0xA2:
9741
            case 0xA3:
9742
            case 0xA4:
9743
            case 0xA5:
9744
            case 0xA6:
9745
            case 0xA7:
9746
            case 0xA8:
9747
            case 0xA9:
9748
            case 0xAA:
9749
            case 0xAB:
9750
            case 0xAC:
9751
            case 0xAD:
9752
            case 0xAE:
9753
            case 0xAF:
9754
            case 0xB0:
9755
            case 0xB1:
9756
            case 0xB2:
9757
            case 0xB3:
9758
            case 0xB4:
9759
            case 0xB5:
9760
            case 0xB6:
9761
            case 0xB7:
9762
            case 0xB8:
9763
            case 0xB9:
9764
            case 0xBA:
9765
            case 0xBB:
9766
            case 0xBC:
9767
            case 0xBD:
9768
            case 0xBE:
9769
            case 0xBF:
9770
            {
9771
                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
9772
            }
9773

9774
            case 0xD9: // str 8
9775
            {
9776
                std::uint8_t len{};
9777
                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9778
            }
9779

9780
            case 0xDA: // str 16
9781
            {
9782
                std::uint16_t len{};
9783
                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9784
            }
9785

9786
            case 0xDB: // str 32
9787
            {
9788
                std::uint32_t len{};
9789
                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9790
            }
9791

9792
            default:
9793
            {
9794
                auto last_token = get_token_string();
9795
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string"), BasicJsonType()));
9796
            }
9797
        }
9798
    }
9799

9800
    /*!
9801
    @brief reads a MessagePack byte array
9802

9803
    This function first reads starting bytes to determine the expected
9804
    byte array length and then copies this number of bytes into a byte array.
9805

9806
    @param[out] result  created byte array
9807

9808
    @return whether byte array creation completed
9809
    */
9810
    bool get_msgpack_binary(binary_t& result)
9811
    {
9812
        // helper function to set the subtype
9813
        auto assign_and_return_true = [&result](std::int8_t subtype)
9814
        {
9815
            result.set_subtype(static_cast<std::uint8_t>(subtype));
9816
            return true;
9817
        };
9818

9819
        switch (current)
9820
        {
9821
            case 0xC4: // bin 8
9822
            {
9823
                std::uint8_t len{};
9824
                return get_number(input_format_t::msgpack, len) &&
9825
                       get_binary(input_format_t::msgpack, len, result);
9826
            }
9827

9828
            case 0xC5: // bin 16
9829
            {
9830
                std::uint16_t len{};
9831
                return get_number(input_format_t::msgpack, len) &&
9832
                       get_binary(input_format_t::msgpack, len, result);
9833
            }
9834

9835
            case 0xC6: // bin 32
9836
            {
9837
                std::uint32_t len{};
9838
                return get_number(input_format_t::msgpack, len) &&
9839
                       get_binary(input_format_t::msgpack, len, result);
9840
            }
9841

9842
            case 0xC7: // ext 8
9843
            {
9844
                std::uint8_t len{};
9845
                std::int8_t subtype{};
9846
                return get_number(input_format_t::msgpack, len) &&
9847
                       get_number(input_format_t::msgpack, subtype) &&
9848
                       get_binary(input_format_t::msgpack, len, result) &&
9849
                       assign_and_return_true(subtype);
9850
            }
9851

9852
            case 0xC8: // ext 16
9853
            {
9854
                std::uint16_t len{};
9855
                std::int8_t subtype{};
9856
                return get_number(input_format_t::msgpack, len) &&
9857
                       get_number(input_format_t::msgpack, subtype) &&
9858
                       get_binary(input_format_t::msgpack, len, result) &&
9859
                       assign_and_return_true(subtype);
9860
            }
9861

9862
            case 0xC9: // ext 32
9863
            {
9864
                std::uint32_t len{};
9865
                std::int8_t subtype{};
9866
                return get_number(input_format_t::msgpack, len) &&
9867
                       get_number(input_format_t::msgpack, subtype) &&
9868
                       get_binary(input_format_t::msgpack, len, result) &&
9869
                       assign_and_return_true(subtype);
9870
            }
9871

9872
            case 0xD4: // fixext 1
9873
            {
9874
                std::int8_t subtype{};
9875
                return get_number(input_format_t::msgpack, subtype) &&
9876
                       get_binary(input_format_t::msgpack, 1, result) &&
9877
                       assign_and_return_true(subtype);
9878
            }
9879

9880
            case 0xD5: // fixext 2
9881
            {
9882
                std::int8_t subtype{};
9883
                return get_number(input_format_t::msgpack, subtype) &&
9884
                       get_binary(input_format_t::msgpack, 2, result) &&
9885
                       assign_and_return_true(subtype);
9886
            }
9887

9888
            case 0xD6: // fixext 4
9889
            {
9890
                std::int8_t subtype{};
9891
                return get_number(input_format_t::msgpack, subtype) &&
9892
                       get_binary(input_format_t::msgpack, 4, result) &&
9893
                       assign_and_return_true(subtype);
9894
            }
9895

9896
            case 0xD7: // fixext 8
9897
            {
9898
                std::int8_t subtype{};
9899
                return get_number(input_format_t::msgpack, subtype) &&
9900
                       get_binary(input_format_t::msgpack, 8, result) &&
9901
                       assign_and_return_true(subtype);
9902
            }
9903

9904
            case 0xD8: // fixext 16
9905
            {
9906
                std::int8_t subtype{};
9907
                return get_number(input_format_t::msgpack, subtype) &&
9908
                       get_binary(input_format_t::msgpack, 16, result) &&
9909
                       assign_and_return_true(subtype);
9910
            }
9911

9912
            default:           // LCOV_EXCL_LINE
9913
                return false;  // LCOV_EXCL_LINE
9914
        }
9915
    }
9916

9917
    /*!
9918
    @param[in] len  the length of the array
9919
    @return whether array creation completed
9920
    */
9921
    bool get_msgpack_array(const std::size_t len)
9922
    {
9923
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9924
        {
9925
            return false;
9926
        }
9927

9928
        for (std::size_t i = 0; i < len; ++i)
9929
        {
9930
            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9931
            {
9932
                return false;
9933
            }
9934
        }
9935

9936
        return sax->end_array();
9937
    }
9938

9939
    /*!
9940
    @param[in] len  the length of the object
9941
    @return whether object creation completed
9942
    */
9943
    bool get_msgpack_object(const std::size_t len)
9944
    {
9945
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9946
        {
9947
            return false;
9948
        }
9949

9950
        string_t key;
9951
        for (std::size_t i = 0; i < len; ++i)
9952
        {
9953
            get();
9954
            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
9955
            {
9956
                return false;
9957
            }
9958

9959
            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9960
            {
9961
                return false;
9962
            }
9963
            key.clear();
9964
        }
9965

9966
        return sax->end_object();
9967
    }
9968

9969
    ////////////
9970
    // UBJSON //
9971
    ////////////
9972

9973
    /*!
9974
    @param[in] get_char  whether a new character should be retrieved from the
9975
                         input (true, default) or whether the last read
9976
                         character should be considered instead
9977

9978
    @return whether a valid UBJSON value was passed to the SAX parser
9979
    */
9980
    bool parse_ubjson_internal(const bool get_char = true)
9981
    {
9982
        return get_ubjson_value(get_char ? get_ignore_noop() : current);
9983
    }
9984

9985
    /*!
9986
    @brief reads a UBJSON string
9987

9988
    This function is either called after reading the 'S' byte explicitly
9989
    indicating a string, or in case of an object key where the 'S' byte can be
9990
    left out.
9991

9992
    @param[out] result   created string
9993
    @param[in] get_char  whether a new character should be retrieved from the
9994
                         input (true, default) or whether the last read
9995
                         character should be considered instead
9996

9997
    @return whether string creation completed
9998
    */
9999
    bool get_ubjson_string(string_t& result, const bool get_char = true)
10000
    {
10001
        if (get_char)
10002
        {
10003
            get();  // TODO(niels): may we ignore N here?
10004
        }
10005

10006
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
10007
        {
10008
            return false;
10009
        }
10010

10011
        switch (current)
10012
        {
10013
            case 'U':
10014
            {
10015
                std::uint8_t len{};
10016
                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10017
            }
10018

10019
            case 'i':
10020
            {
10021
                std::int8_t len{};
10022
                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10023
            }
10024

10025
            case 'I':
10026
            {
10027
                std::int16_t len{};
10028
                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10029
            }
10030

10031
            case 'l':
10032
            {
10033
                std::int32_t len{};
10034
                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10035
            }
10036

10037
            case 'L':
10038
            {
10039
                std::int64_t len{};
10040
                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10041
            }
10042

10043
            default:
10044
                auto last_token = get_token_string();
10045
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string"), BasicJsonType()));
10046
        }
10047
    }
10048

10049
    /*!
10050
    @param[out] result  determined size
10051
    @return whether size determination completed
10052
    */
10053
    bool get_ubjson_size_value(std::size_t& result)
10054
    {
10055
        switch (get_ignore_noop())
10056
        {
10057
            case 'U':
10058
            {
10059
                std::uint8_t number{};
10060
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10061
                {
10062
                    return false;
10063
                }
10064
                result = static_cast<std::size_t>(number);
10065
                return true;
10066
            }
10067

10068
            case 'i':
10069
            {
10070
                std::int8_t number{};
10071
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10072
                {
10073
                    return false;
10074
                }
10075
                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
10076
                return true;
10077
            }
10078

10079
            case 'I':
10080
            {
10081
                std::int16_t number{};
10082
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10083
                {
10084
                    return false;
10085
                }
10086
                result = static_cast<std::size_t>(number);
10087
                return true;
10088
            }
10089

10090
            case 'l':
10091
            {
10092
                std::int32_t number{};
10093
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10094
                {
10095
                    return false;
10096
                }
10097
                result = static_cast<std::size_t>(number);
10098
                return true;
10099
            }
10100

10101
            case 'L':
10102
            {
10103
                std::int64_t number{};
10104
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10105
                {
10106
                    return false;
10107
                }
10108
                result = static_cast<std::size_t>(number);
10109
                return true;
10110
            }
10111

10112
            default:
10113
            {
10114
                auto last_token = get_token_string();
10115
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size"), BasicJsonType()));
10116
            }
10117
        }
10118
    }
10119

10120
    /*!
10121
    @brief determine the type and size for a container
10122

10123
    In the optimized UBJSON format, a type and a size can be provided to allow
10124
    for a more compact representation.
10125

10126
    @param[out] result  pair of the size and the type
10127

10128
    @return whether pair creation completed
10129
    */
10130
    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
10131
    {
10132
        result.first = string_t::npos; // size
10133
        result.second = 0; // type
10134

10135
        get_ignore_noop();
10136

10137
        if (current == '$')
10138
        {
10139
            result.second = get();  // must not ignore 'N', because 'N' maybe the type
10140
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
10141
            {
10142
                return false;
10143
            }
10144

10145
            get_ignore_noop();
10146
            if (JSON_HEDLEY_UNLIKELY(current != '#'))
10147
            {
10148
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
10149
                {
10150
                    return false;
10151
                }
10152
                auto last_token = get_token_string();
10153
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size"), BasicJsonType()));
10154
            }
10155

10156
            return get_ubjson_size_value(result.first);
10157
        }
10158

10159
        if (current == '#')
10160
        {
10161
            return get_ubjson_size_value(result.first);
10162
        }
10163

10164
        return true;
10165
    }
10166

10167
    /*!
10168
    @param prefix  the previously read or set type prefix
10169
    @return whether value creation completed
10170
    */
10171
    bool get_ubjson_value(const char_int_type prefix)
10172
    {
10173
        switch (prefix)
10174
        {
10175
            case std::char_traits<char_type>::eof():  // EOF
10176
                return unexpect_eof(input_format_t::ubjson, "value");
10177

10178
            case 'T':  // true
10179
                return sax->boolean(true);
10180
            case 'F':  // false
10181
                return sax->boolean(false);
10182

10183
            case 'Z':  // null
10184
                return sax->null();
10185

10186
            case 'U':
10187
            {
10188
                std::uint8_t number{};
10189
                return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
10190
            }
10191

10192
            case 'i':
10193
            {
10194
                std::int8_t number{};
10195
                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10196
            }
10197

10198
            case 'I':
10199
            {
10200
                std::int16_t number{};
10201
                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10202
            }
10203

10204
            case 'l':
10205
            {
10206
                std::int32_t number{};
10207
                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10208
            }
10209

10210
            case 'L':
10211
            {
10212
                std::int64_t number{};
10213
                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10214
            }
10215

10216
            case 'd':
10217
            {
10218
                float number{};
10219
                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
10220
            }
10221

10222
            case 'D':
10223
            {
10224
                double number{};
10225
                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
10226
            }
10227

10228
            case 'H':
10229
            {
10230
                return get_ubjson_high_precision_number();
10231
            }
10232

10233
            case 'C':  // char
10234
            {
10235
                get();
10236
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
10237
                {
10238
                    return false;
10239
                }
10240
                if (JSON_HEDLEY_UNLIKELY(current > 127))
10241
                {
10242
                    auto last_token = get_token_string();
10243
                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char"), BasicJsonType()));
10244
                }
10245
                string_t s(1, static_cast<typename string_t::value_type>(current));
10246
                return sax->string(s);
10247
            }
10248

10249
            case 'S':  // string
10250
            {
10251
                string_t s;
10252
                return get_ubjson_string(s) && sax->string(s);
10253
            }
10254

10255
            case '[':  // array
10256
                return get_ubjson_array();
10257

10258
            case '{':  // object
10259
                return get_ubjson_object();
10260

10261
            default: // anything else
10262
            {
10263
                auto last_token = get_token_string();
10264
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
10265
            }
10266
        }
10267
    }
10268

10269
    /*!
10270
    @return whether array creation completed
10271
    */
10272
    bool get_ubjson_array()
10273
    {
10274
        std::pair<std::size_t, char_int_type> size_and_type;
10275
        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10276
        {
10277
            return false;
10278
        }
10279

10280
        if (size_and_type.first != string_t::npos)
10281
        {
10282
            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
10283
            {
10284
                return false;
10285
            }
10286

10287
            if (size_and_type.second != 0)
10288
            {
10289
                if (size_and_type.second != 'N')
10290
                {
10291
                    for (std::size_t i = 0; i < size_and_type.first; ++i)
10292
                    {
10293
                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10294
                        {
10295
                            return false;
10296
                        }
10297
                    }
10298
                }
10299
            }
10300
            else
10301
            {
10302
                for (std::size_t i = 0; i < size_and_type.first; ++i)
10303
                {
10304
                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10305
                    {
10306
                        return false;
10307
                    }
10308
                }
10309
            }
10310
        }
10311
        else
10312
        {
10313
            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
10314
            {
10315
                return false;
10316
            }
10317

10318
            while (current != ']')
10319
            {
10320
                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
10321
                {
10322
                    return false;
10323
                }
10324
                get_ignore_noop();
10325
            }
10326
        }
10327

10328
        return sax->end_array();
10329
    }
10330

10331
    /*!
10332
    @return whether object creation completed
10333
    */
10334
    bool get_ubjson_object()
10335
    {
10336
        std::pair<std::size_t, char_int_type> size_and_type;
10337
        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10338
        {
10339
            return false;
10340
        }
10341

10342
        string_t key;
10343
        if (size_and_type.first != string_t::npos)
10344
        {
10345
            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
10346
            {
10347
                return false;
10348
            }
10349

10350
            if (size_and_type.second != 0)
10351
            {
10352
                for (std::size_t i = 0; i < size_and_type.first; ++i)
10353
                {
10354
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10355
                    {
10356
                        return false;
10357
                    }
10358
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10359
                    {
10360
                        return false;
10361
                    }
10362
                    key.clear();
10363
                }
10364
            }
10365
            else
10366
            {
10367
                for (std::size_t i = 0; i < size_and_type.first; ++i)
10368
                {
10369
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10370
                    {
10371
                        return false;
10372
                    }
10373
                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10374
                    {
10375
                        return false;
10376
                    }
10377
                    key.clear();
10378
                }
10379
            }
10380
        }
10381
        else
10382
        {
10383
            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
10384
            {
10385
                return false;
10386
            }
10387

10388
            while (current != '}')
10389
            {
10390
                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
10391
                {
10392
                    return false;
10393
                }
10394
                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10395
                {
10396
                    return false;
10397
                }
10398
                get_ignore_noop();
10399
                key.clear();
10400
            }
10401
        }
10402

10403
        return sax->end_object();
10404
    }
10405

10406
    // Note, no reader for UBJSON binary types is implemented because they do
10407
    // not exist
10408

10409
    bool get_ubjson_high_precision_number()
10410
    {
10411
        // get size of following number string
10412
        std::size_t size{};
10413
        auto res = get_ubjson_size_value(size);
10414
        if (JSON_HEDLEY_UNLIKELY(!res))
10415
        {
10416
            return res;
10417
        }
10418

10419
        // get number string
10420
        std::vector<char> number_vector;
10421
        for (std::size_t i = 0; i < size; ++i)
10422
        {
10423
            get();
10424
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
10425
            {
10426
                return false;
10427
            }
10428
            number_vector.push_back(static_cast<char>(current));
10429
        }
10430

10431
        // parse number string
10432
        using ia_type = decltype(detail::input_adapter(number_vector));
10433
        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
10434
        const auto result_number = number_lexer.scan();
10435
        const auto number_string = number_lexer.get_token_string();
10436
        const auto result_remainder = number_lexer.scan();
10437

10438
        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
10439

10440
        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
10441
        {
10442
            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
10443
        }
10444

10445
        switch (result_number)
10446
        {
10447
            case token_type::value_integer:
10448
                return sax->number_integer(number_lexer.get_number_integer());
10449
            case token_type::value_unsigned:
10450
                return sax->number_unsigned(number_lexer.get_number_unsigned());
10451
            case token_type::value_float:
10452
                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
10453
            case token_type::uninitialized:
10454
            case token_type::literal_true:
10455
            case token_type::literal_false:
10456
            case token_type::literal_null:
10457
            case token_type::value_string:
10458
            case token_type::begin_array:
10459
            case token_type::begin_object:
10460
            case token_type::end_array:
10461
            case token_type::end_object:
10462
            case token_type::name_separator:
10463
            case token_type::value_separator:
10464
            case token_type::parse_error:
10465
            case token_type::end_of_input:
10466
            case token_type::literal_or_value:
10467
            default:
10468
                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
10469
        }
10470
    }
10471

10472
    ///////////////////////
10473
    // Utility functions //
10474
    ///////////////////////
10475

10476
    /*!
10477
    @brief get next character from the input
10478

10479
    This function provides the interface to the used input adapter. It does
10480
    not throw in case the input reached EOF, but returns a -'ve valued
10481
    `std::char_traits<char_type>::eof()` in that case.
10482

10483
    @return character read from the input
10484
    */
10485
    char_int_type get()
10486
    {
10487
        ++chars_read;
10488
        return current = ia.get_character();
10489
    }
10490

10491
    /*!
10492
    @return character read from the input after ignoring all 'N' entries
10493
    */
10494
    char_int_type get_ignore_noop()
10495
    {
10496
        do
10497
        {
10498
            get();
10499
        }
10500
        while (current == 'N');
10501

10502
        return current;
10503
    }
10504

10505
    /*
10506
    @brief read a number from the input
10507

10508
    @tparam NumberType the type of the number
10509
    @param[in] format   the current format (for diagnostics)
10510
    @param[out] result  number of type @a NumberType
10511

10512
    @return whether conversion completed
10513

10514
    @note This function needs to respect the system's endianness, because
10515
          bytes in CBOR, MessagePack, and UBJSON are stored in network order
10516
          (big endian) and therefore need reordering on little endian systems.
10517
    */
10518
    template<typename NumberType, bool InputIsLittleEndian = false>
10519
    bool get_number(const input_format_t format, NumberType& result)
10520
    {
10521
        // step 1: read input into array with system's byte order
10522
        std::array<std::uint8_t, sizeof(NumberType)> vec{};
10523
        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
10524
        {
10525
            get();
10526
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
10527
            {
10528
                return false;
10529
            }
10530

10531
            // reverse byte order prior to conversion if necessary
10532
            if (is_little_endian != InputIsLittleEndian)
10533
            {
10534
                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
10535
            }
10536
            else
10537
            {
10538
                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
10539
            }
10540
        }
10541

10542
        // step 2: convert array into number of type T and return
10543
        std::memcpy(&result, vec.data(), sizeof(NumberType));
10544
        return true;
10545
    }
10546

10547
    /*!
10548
    @brief create a string by reading characters from the input
10549

10550
    @tparam NumberType the type of the number
10551
    @param[in] format the current format (for diagnostics)
10552
    @param[in] len number of characters to read
10553
    @param[out] result string created by reading @a len bytes
10554

10555
    @return whether string creation completed
10556

10557
    @note We can not reserve @a len bytes for the result, because @a len
10558
          may be too large. Usually, @ref unexpect_eof() detects the end of
10559
          the input before we run out of string memory.
10560
    */
10561
    template<typename NumberType>
10562
    bool get_string(const input_format_t format,
10563
                    const NumberType len,
10564
                    string_t& result)
10565
    {
10566
        bool success = true;
10567
        for (NumberType i = 0; i < len; i++)
10568
        {
10569
            get();
10570
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
10571
            {
10572
                success = false;
10573
                break;
10574
            }
10575
            result.push_back(static_cast<typename string_t::value_type>(current));
10576
        }
10577
        return success;
10578
    }
10579

10580
    /*!
10581
    @brief create a byte array by reading bytes from the input
10582

10583
    @tparam NumberType the type of the number
10584
    @param[in] format the current format (for diagnostics)
10585
    @param[in] len number of bytes to read
10586
    @param[out] result byte array created by reading @a len bytes
10587

10588
    @return whether byte array creation completed
10589

10590
    @note We can not reserve @a len bytes for the result, because @a len
10591
          may be too large. Usually, @ref unexpect_eof() detects the end of
10592
          the input before we run out of memory.
10593
    */
10594
    template<typename NumberType>
10595
    bool get_binary(const input_format_t format,
10596
                    const NumberType len,
10597
                    binary_t& result)
10598
    {
10599
        bool success = true;
10600
        for (NumberType i = 0; i < len; i++)
10601
        {
10602
            get();
10603
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
10604
            {
10605
                success = false;
10606
                break;
10607
            }
10608
            result.push_back(static_cast<std::uint8_t>(current));
10609
        }
10610
        return success;
10611
    }
10612

10613
    /*!
10614
    @param[in] format   the current format (for diagnostics)
10615
    @param[in] context  further context information (for diagnostics)
10616
    @return whether the last read character is not EOF
10617
    */
10618
    JSON_HEDLEY_NON_NULL(3)
10619
    bool unexpect_eof(const input_format_t format, const char* context) const
10620
    {
10621
        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10622
        {
10623
            return sax->parse_error(chars_read, "<end of file>",
10624
                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), BasicJsonType()));
10625
        }
10626
        return true;
10627
    }
10628

10629
    /*!
10630
    @return a string representation of the last read byte
10631
    */
10632
    std::string get_token_string() const
10633
    {
10634
        std::array<char, 3> cr{{}};
10635
        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
10636
        return std::string{cr.data()};
10637
    }
10638

10639
    /*!
10640
    @param[in] format   the current format
10641
    @param[in] detail   a detailed error message
10642
    @param[in] context  further context information
10643
    @return a message string to use in the parse_error exceptions
10644
    */
10645
    std::string exception_message(const input_format_t format,
10646
                                  const std::string& detail,
10647
                                  const std::string& context) const
10648
    {
10649
        std::string error_msg = "syntax error while parsing ";
10650

10651
        switch (format)
10652
        {
10653
            case input_format_t::cbor:
10654
                error_msg += "CBOR";
10655
                break;
10656

10657
            case input_format_t::msgpack:
10658
                error_msg += "MessagePack";
10659
                break;
10660

10661
            case input_format_t::ubjson:
10662
                error_msg += "UBJSON";
10663
                break;
10664

10665
            case input_format_t::bson:
10666
                error_msg += "BSON";
10667
                break;
10668

10669
            case input_format_t::json: // LCOV_EXCL_LINE
10670
            default:            // LCOV_EXCL_LINE
10671
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
10672
        }
10673

10674
        return error_msg + " " + context + ": " + detail;
10675
    }
10676

10677
  private:
10678
    /// input adapter
10679
    InputAdapterType ia;
10680

10681
    /// the current character
10682
    char_int_type current = std::char_traits<char_type>::eof();
10683

10684
    /// the number of characters read
10685
    std::size_t chars_read = 0;
10686

10687
    /// whether we can assume little endianness
10688
    const bool is_little_endian = little_endianness();
10689

10690
    /// the SAX parser
10691
    json_sax_t* sax = nullptr;
10692
};
10693
}  // namespace detail
10694
}  // namespace nlohmann
10695

10696
// #include <nlohmann/detail/input/input_adapters.hpp>
10697

10698
// #include <nlohmann/detail/input/lexer.hpp>
10699

10700
// #include <nlohmann/detail/input/parser.hpp>
10701

10702

10703
#include <cmath> // isfinite
10704
#include <cstdint> // uint8_t
10705
#include <functional> // function
10706
#include <string> // string
10707
#include <utility> // move
10708
#include <vector> // vector
10709

10710
// #include <nlohmann/detail/exceptions.hpp>
10711

10712
// #include <nlohmann/detail/input/input_adapters.hpp>
10713

10714
// #include <nlohmann/detail/input/json_sax.hpp>
10715

10716
// #include <nlohmann/detail/input/lexer.hpp>
10717

10718
// #include <nlohmann/detail/macro_scope.hpp>
10719

10720
// #include <nlohmann/detail/meta/is_sax.hpp>
10721

10722
// #include <nlohmann/detail/value_t.hpp>
10723

10724

10725
namespace nlohmann
10726
{
10727
namespace detail
10728
{
10729
////////////
10730
// parser //
10731
////////////
10732

10733
enum class parse_event_t : std::uint8_t
10734
{
10735
    /// the parser read `{` and started to process a JSON object
10736
    object_start,
10737
    /// the parser read `}` and finished processing a JSON object
10738
    object_end,
10739
    /// the parser read `[` and started to process a JSON array
10740
    array_start,
10741
    /// the parser read `]` and finished processing a JSON array
10742
    array_end,
10743
    /// the parser read a key of a value in an object
10744
    key,
10745
    /// the parser finished reading a JSON value
10746
    value
10747
};
10748

10749
template<typename BasicJsonType>
10750
using parser_callback_t =
10751
    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
10752

10753
/*!
10754
@brief syntax analysis
10755

10756
This class implements a recursive descent parser.
10757
*/
10758
template<typename BasicJsonType, typename InputAdapterType>
10759
class parser
10760
{
10761
    using number_integer_t = typename BasicJsonType::number_integer_t;
10762
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
10763
    using number_float_t = typename BasicJsonType::number_float_t;
10764
    using string_t = typename BasicJsonType::string_t;
10765
    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
10766
    using token_type = typename lexer_t::token_type;
10767

10768
  public:
10769
    /// a parser reading from an input adapter
10770
    explicit parser(InputAdapterType&& adapter,
10771
                    const parser_callback_t<BasicJsonType> cb = nullptr,
10772
                    const bool allow_exceptions_ = true,
10773
                    const bool skip_comments = false)
10774
        : callback(cb)
10775
        , m_lexer(std::move(adapter), skip_comments)
10776
        , allow_exceptions(allow_exceptions_)
10777
    {
10778
        // read first token
10779
        get_token();
10780
    }
10781

10782
    /*!
10783
    @brief public parser interface
10784

10785
    @param[in] strict      whether to expect the last token to be EOF
10786
    @param[in,out] result  parsed JSON value
10787

10788
    @throw parse_error.101 in case of an unexpected token
10789
    @throw parse_error.102 if to_unicode fails or surrogate error
10790
    @throw parse_error.103 if to_unicode fails
10791
    */
10792
    void parse(const bool strict, BasicJsonType& result)
10793
    {
10794
        if (callback)
10795
        {
10796
            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
10797
            sax_parse_internal(&sdp);
10798

10799
            // in strict mode, input must be completely read
10800
            if (strict && (get_token() != token_type::end_of_input))
10801
            {
10802
                sdp.parse_error(m_lexer.get_position(),
10803
                                m_lexer.get_token_string(),
10804
                                parse_error::create(101, m_lexer.get_position(),
10805
                                                    exception_message(token_type::end_of_input, "value"), BasicJsonType()));
10806
            }
10807

10808
            // in case of an error, return discarded value
10809
            if (sdp.is_errored())
10810
            {
10811
                result = value_t::discarded;
10812
                return;
10813
            }
10814

10815
            // set top-level value to null if it was discarded by the callback
10816
            // function
10817
            if (result.is_discarded())
10818
            {
10819
                result = nullptr;
10820
            }
10821
        }
10822
        else
10823
        {
10824
            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
10825
            sax_parse_internal(&sdp);
10826

10827
            // in strict mode, input must be completely read
10828
            if (strict && (get_token() != token_type::end_of_input))
10829
            {
10830
                sdp.parse_error(m_lexer.get_position(),
10831
                                m_lexer.get_token_string(),
10832
                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
10833
            }
10834

10835
            // in case of an error, return discarded value
10836
            if (sdp.is_errored())
10837
            {
10838
                result = value_t::discarded;
10839
                return;
10840
            }
10841
        }
10842

10843
        result.assert_invariant();
10844
    }
10845

10846
    /*!
10847
    @brief public accept interface
10848

10849
    @param[in] strict  whether to expect the last token to be EOF
10850
    @return whether the input is a proper JSON text
10851
    */
10852
    bool accept(const bool strict = true)
10853
    {
10854
        json_sax_acceptor<BasicJsonType> sax_acceptor;
10855
        return sax_parse(&sax_acceptor, strict);
10856
    }
10857

10858
    template<typename SAX>
10859
    JSON_HEDLEY_NON_NULL(2)
10860
    bool sax_parse(SAX* sax, const bool strict = true)
10861
    {
10862
        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
10863
        const bool result = sax_parse_internal(sax);
10864

10865
        // strict mode: next byte must be EOF
10866
        if (result && strict && (get_token() != token_type::end_of_input))
10867
        {
10868
            return sax->parse_error(m_lexer.get_position(),
10869
                                    m_lexer.get_token_string(),
10870
                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
10871
        }
10872

10873
        return result;
10874
    }
10875

10876
  private:
10877
    template<typename SAX>
10878
    JSON_HEDLEY_NON_NULL(2)
10879
    bool sax_parse_internal(SAX* sax)
10880
    {
10881
        // stack to remember the hierarchy of structured values we are parsing
10882
        // true = array; false = object
10883
        std::vector<bool> states;
10884
        // value to avoid a goto (see comment where set to true)
10885
        bool skip_to_state_evaluation = false;
10886

10887
        while (true)
10888
        {
10889
            if (!skip_to_state_evaluation)
10890
            {
10891
                // invariant: get_token() was called before each iteration
10892
                switch (last_token)
10893
                {
10894
                    case token_type::begin_object:
10895
                    {
10896
                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
10897
                        {
10898
                            return false;
10899
                        }
10900

10901
                        // closing } -> we are done
10902
                        if (get_token() == token_type::end_object)
10903
                        {
10904
                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10905
                            {
10906
                                return false;
10907
                            }
10908
                            break;
10909
                        }
10910

10911
                        // parse key
10912
                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
10913
                        {
10914
                            return sax->parse_error(m_lexer.get_position(),
10915
                                                    m_lexer.get_token_string(),
10916
                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), BasicJsonType()));
10917
                        }
10918
                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10919
                        {
10920
                            return false;
10921
                        }
10922

10923
                        // parse separator (:)
10924
                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10925
                        {
10926
                            return sax->parse_error(m_lexer.get_position(),
10927
                                                    m_lexer.get_token_string(),
10928
                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), BasicJsonType()));
10929
                        }
10930

10931
                        // remember we are now inside an object
10932
                        states.push_back(false);
10933

10934
                        // parse values
10935
                        get_token();
10936
                        continue;
10937
                    }
10938

10939
                    case token_type::begin_array:
10940
                    {
10941
                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
10942
                        {
10943
                            return false;
10944
                        }
10945

10946
                        // closing ] -> we are done
10947
                        if (get_token() == token_type::end_array)
10948
                        {
10949
                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10950
                            {
10951
                                return false;
10952
                            }
10953
                            break;
10954
                        }
10955

10956
                        // remember we are now inside an array
10957
                        states.push_back(true);
10958

10959
                        // parse values (no need to call get_token)
10960
                        continue;
10961
                    }
10962

10963
                    case token_type::value_float:
10964
                    {
10965
                        const auto res = m_lexer.get_number_float();
10966

10967
                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
10968
                        {
10969
                            return sax->parse_error(m_lexer.get_position(),
10970
                                                    m_lexer.get_token_string(),
10971
                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'", BasicJsonType()));
10972
                        }
10973

10974
                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
10975
                        {
10976
                            return false;
10977
                        }
10978

10979
                        break;
10980
                    }
10981

10982
                    case token_type::literal_false:
10983
                    {
10984
                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
10985
                        {
10986
                            return false;
10987
                        }
10988
                        break;
10989
                    }
10990

10991
                    case token_type::literal_null:
10992
                    {
10993
                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
10994
                        {
10995
                            return false;
10996
                        }
10997
                        break;
10998
                    }
10999

11000
                    case token_type::literal_true:
11001
                    {
11002
                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
11003
                        {
11004
                            return false;
11005
                        }
11006
                        break;
11007
                    }
11008

11009
                    case token_type::value_integer:
11010
                    {
11011
                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
11012
                        {
11013
                            return false;
11014
                        }
11015
                        break;
11016
                    }
11017

11018
                    case token_type::value_string:
11019
                    {
11020
                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
11021
                        {
11022
                            return false;
11023
                        }
11024
                        break;
11025
                    }
11026

11027
                    case token_type::value_unsigned:
11028
                    {
11029
                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
11030
                        {
11031
                            return false;
11032
                        }
11033
                        break;
11034
                    }
11035

11036
                    case token_type::parse_error:
11037
                    {
11038
                        // using "uninitialized" to avoid "expected" message
11039
                        return sax->parse_error(m_lexer.get_position(),
11040
                                                m_lexer.get_token_string(),
11041
                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), BasicJsonType()));
11042
                    }
11043

11044
                    case token_type::uninitialized:
11045
                    case token_type::end_array:
11046
                    case token_type::end_object:
11047
                    case token_type::name_separator:
11048
                    case token_type::value_separator:
11049
                    case token_type::end_of_input:
11050
                    case token_type::literal_or_value:
11051
                    default: // the last token was unexpected
11052
                    {
11053
                        return sax->parse_error(m_lexer.get_position(),
11054
                                                m_lexer.get_token_string(),
11055
                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), BasicJsonType()));
11056
                    }
11057
                }
11058
            }
11059
            else
11060
            {
11061
                skip_to_state_evaluation = false;
11062
            }
11063

11064
            // we reached this line after we successfully parsed a value
11065
            if (states.empty())
11066
            {
11067
                // empty stack: we reached the end of the hierarchy: done
11068
                return true;
11069
            }
11070

11071
            if (states.back())  // array
11072
            {
11073
                // comma -> next value
11074
                if (get_token() == token_type::value_separator)
11075
                {
11076
                    // parse a new value
11077
                    get_token();
11078
                    continue;
11079
                }
11080

11081
                // closing ]
11082
                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
11083
                {
11084
                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11085
                    {
11086
                        return false;
11087
                    }
11088

11089
                    // We are done with this array. Before we can parse a
11090
                    // new value, we need to evaluate the new state first.
11091
                    // By setting skip_to_state_evaluation to false, we
11092
                    // are effectively jumping to the beginning of this if.
11093
                    JSON_ASSERT(!states.empty());
11094
                    states.pop_back();
11095
                    skip_to_state_evaluation = true;
11096
                    continue;
11097
                }
11098

11099
                return sax->parse_error(m_lexer.get_position(),
11100
                                        m_lexer.get_token_string(),
11101
                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), BasicJsonType()));
11102
            }
11103

11104
            // states.back() is false -> object
11105

11106
            // comma -> next value
11107
            if (get_token() == token_type::value_separator)
11108
            {
11109
                // parse key
11110
                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
11111
                {
11112
                    return sax->parse_error(m_lexer.get_position(),
11113
                                            m_lexer.get_token_string(),
11114
                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), BasicJsonType()));
11115
                }
11116

11117
                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11118
                {
11119
                    return false;
11120
                }
11121

11122
                // parse separator (:)
11123
                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11124
                {
11125
                    return sax->parse_error(m_lexer.get_position(),
11126
                                            m_lexer.get_token_string(),
11127
                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), BasicJsonType()));
11128
                }
11129

11130
                // parse values
11131
                get_token();
11132
                continue;
11133
            }
11134

11135
            // closing }
11136
            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
11137
            {
11138
                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11139
                {
11140
                    return false;
11141
                }
11142

11143
                // We are done with this object. Before we can parse a
11144
                // new value, we need to evaluate the new state first.
11145
                // By setting skip_to_state_evaluation to false, we
11146
                // are effectively jumping to the beginning of this if.
11147
                JSON_ASSERT(!states.empty());
11148
                states.pop_back();
11149
                skip_to_state_evaluation = true;
11150
                continue;
11151
            }
11152

11153
            return sax->parse_error(m_lexer.get_position(),
11154
                                    m_lexer.get_token_string(),
11155
                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), BasicJsonType()));
11156
        }
11157
    }
11158

11159
    /// get next token from lexer
11160
    token_type get_token()
11161
    {
11162
        return last_token = m_lexer.scan();
11163
    }
11164

11165
    std::string exception_message(const token_type expected, const std::string& context)
11166
    {
11167
        std::string error_msg = "syntax error ";
11168

11169
        if (!context.empty())
11170
        {
11171
            error_msg += "while parsing " + context + " ";
11172
        }
11173

11174
        error_msg += "- ";
11175

11176
        if (last_token == token_type::parse_error)
11177
        {
11178
            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
11179
                         m_lexer.get_token_string() + "'";
11180
        }
11181
        else
11182
        {
11183
            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
11184
        }
11185

11186
        if (expected != token_type::uninitialized)
11187
        {
11188
            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
11189
        }
11190

11191
        return error_msg;
11192
    }
11193

11194
  private:
11195
    /// callback function
11196
    const parser_callback_t<BasicJsonType> callback = nullptr;
11197
    /// the type of the last read token
11198
    token_type last_token = token_type::uninitialized;
11199
    /// the lexer
11200
    lexer_t m_lexer;
11201
    /// whether to throw exceptions in case of errors
11202
    const bool allow_exceptions = true;
11203
};
11204

11205
}  // namespace detail
11206
}  // namespace nlohmann
11207

11208
// #include <nlohmann/detail/iterators/internal_iterator.hpp>
11209

11210

11211
// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
11212

11213

11214
#include <cstddef> // ptrdiff_t
11215
#include <limits>  // numeric_limits
11216

11217
// #include <nlohmann/detail/macro_scope.hpp>
11218

11219

11220
namespace nlohmann
11221
{
11222
namespace detail
11223
{
11224
/*
11225
@brief an iterator for primitive JSON types
11226

11227
This class models an iterator for primitive JSON types (boolean, number,
11228
string). It's only purpose is to allow the iterator/const_iterator classes
11229
to "iterate" over primitive values. Internally, the iterator is modeled by
11230
a `difference_type` variable. Value begin_value (`0`) models the begin,
11231
end_value (`1`) models past the end.
11232
*/
11233
class primitive_iterator_t
11234
{
11235
  private:
11236
    using difference_type = std::ptrdiff_t;
11237
    static constexpr difference_type begin_value = 0;
11238
    static constexpr difference_type end_value = begin_value + 1;
11239

11240
  JSON_PRIVATE_UNLESS_TESTED:
11241
    /// iterator as signed integer type
11242
    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
11243

11244
  public:
11245
    constexpr difference_type get_value() const noexcept
11246
    {
11247
        return m_it;
11248
    }
11249

11250
    /// set iterator to a defined beginning
11251
    void set_begin() noexcept
11252
    {
11253
        m_it = begin_value;
11254
    }
11255

11256
    /// set iterator to a defined past the end
11257
    void set_end() noexcept
11258
    {
11259
        m_it = end_value;
11260
    }
11261

11262
    /// return whether the iterator can be dereferenced
11263
    constexpr bool is_begin() const noexcept
11264
    {
11265
        return m_it == begin_value;
11266
    }
11267

11268
    /// return whether the iterator is at end
11269
    constexpr bool is_end() const noexcept
11270
    {
11271
        return m_it == end_value;
11272
    }
11273

11274
    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11275
    {
11276
        return lhs.m_it == rhs.m_it;
11277
    }
11278

11279
    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11280
    {
11281
        return lhs.m_it < rhs.m_it;
11282
    }
11283

11284
    primitive_iterator_t operator+(difference_type n) noexcept
11285
    {
11286
        auto result = *this;
11287
        result += n;
11288
        return result;
11289
    }
11290

11291
    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11292
    {
11293
        return lhs.m_it - rhs.m_it;
11294
    }
11295

11296
    primitive_iterator_t& operator++() noexcept
11297
    {
11298
        ++m_it;
11299
        return *this;
11300
    }
11301

11302
    primitive_iterator_t const operator++(int) noexcept // NOLINT(readability-const-return-type)
11303
    {
11304
        auto result = *this;
11305
        ++m_it;
11306
        return result;
11307
    }
11308

11309
    primitive_iterator_t& operator--() noexcept
11310
    {
11311
        --m_it;
11312
        return *this;
11313
    }
11314

11315
    primitive_iterator_t const operator--(int) noexcept // NOLINT(readability-const-return-type)
11316
    {
11317
        auto result = *this;
11318
        --m_it;
11319
        return result;
11320
    }
11321

11322
    primitive_iterator_t& operator+=(difference_type n) noexcept
11323
    {
11324
        m_it += n;
11325
        return *this;
11326
    }
11327

11328
    primitive_iterator_t& operator-=(difference_type n) noexcept
11329
    {
11330
        m_it -= n;
11331
        return *this;
11332
    }
11333
};
11334
}  // namespace detail
11335
}  // namespace nlohmann
11336

11337

11338
namespace nlohmann
11339
{
11340
namespace detail
11341
{
11342
/*!
11343
@brief an iterator value
11344

11345
@note This structure could easily be a union, but MSVC currently does not allow
11346
unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
11347
*/
11348
template<typename BasicJsonType> struct internal_iterator
11349
{
11350
    /// iterator for JSON objects
11351
    typename BasicJsonType::object_t::iterator object_iterator {};
11352
    /// iterator for JSON arrays
11353
    typename BasicJsonType::array_t::iterator array_iterator {};
11354
    /// generic iterator for all other types
11355
    primitive_iterator_t primitive_iterator {};
11356
};
11357
}  // namespace detail
11358
}  // namespace nlohmann
11359

11360
// #include <nlohmann/detail/iterators/iter_impl.hpp>
11361

11362

11363
#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
11364
#include <type_traits> // conditional, is_const, remove_const
11365

11366
// #include <nlohmann/detail/exceptions.hpp>
11367

11368
// #include <nlohmann/detail/iterators/internal_iterator.hpp>
11369

11370
// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
11371

11372
// #include <nlohmann/detail/macro_scope.hpp>
11373

11374
// #include <nlohmann/detail/meta/cpp_future.hpp>
11375

11376
// #include <nlohmann/detail/meta/type_traits.hpp>
11377

11378
// #include <nlohmann/detail/value_t.hpp>
11379

11380

11381
namespace nlohmann
11382
{
11383
namespace detail
11384
{
11385
// forward declare, to be able to friend it later on
11386
template<typename IteratorType> class iteration_proxy;
11387
template<typename IteratorType> class iteration_proxy_value;
11388

11389
/*!
11390
@brief a template for a bidirectional iterator for the @ref basic_json class
11391
This class implements a both iterators (iterator and const_iterator) for the
11392
@ref basic_json class.
11393
@note An iterator is called *initialized* when a pointer to a JSON value has
11394
      been set (e.g., by a constructor or a copy assignment). If the iterator is
11395
      default-constructed, it is *uninitialized* and most methods are undefined.
11396
      **The library uses assertions to detect calls on uninitialized iterators.**
11397
@requirement The class satisfies the following concept requirements:
11398
-
11399
[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
11400
  The iterator that can be moved can be moved in both directions (i.e.
11401
  incremented and decremented).
11402
@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
11403
       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
11404
*/
11405
template<typename BasicJsonType>
11406
class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
11407
{
11408
    /// the iterator with BasicJsonType of different const-ness
11409
    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
11410
    /// allow basic_json to access private members
11411
    friend other_iter_impl;
11412
    friend BasicJsonType;
11413
    friend iteration_proxy<iter_impl>;
11414
    friend iteration_proxy_value<iter_impl>;
11415

11416
    using object_t = typename BasicJsonType::object_t;
11417
    using array_t = typename BasicJsonType::array_t;
11418
    // make sure BasicJsonType is basic_json or const basic_json
11419
    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
11420
                  "iter_impl only accepts (const) basic_json");
11421

11422
  public:
11423

11424
    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
11425
    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
11426
    /// A user-defined iterator should provide publicly accessible typedefs named
11427
    /// iterator_category, value_type, difference_type, pointer, and reference.
11428
    /// Note that value_type is required to be non-const, even for constant iterators.
11429
    using iterator_category = std::bidirectional_iterator_tag;
11430

11431
    /// the type of the values when the iterator is dereferenced
11432
    using value_type = typename BasicJsonType::value_type;
11433
    /// a type to represent differences between iterators
11434
    using difference_type = typename BasicJsonType::difference_type;
11435
    /// defines a pointer to the type iterated over (value_type)
11436
    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
11437
          typename BasicJsonType::const_pointer,
11438
          typename BasicJsonType::pointer>::type;
11439
    /// defines a reference to the type iterated over (value_type)
11440
    using reference =
11441
        typename std::conditional<std::is_const<BasicJsonType>::value,
11442
        typename BasicJsonType::const_reference,
11443
        typename BasicJsonType::reference>::type;
11444

11445
    iter_impl() = default;
11446
    ~iter_impl() = default;
11447
    iter_impl(iter_impl&&) noexcept = default;
11448
    iter_impl& operator=(iter_impl&&) noexcept = default;
11449

11450
    /*!
11451
    @brief constructor for a given JSON instance
11452
    @param[in] object  pointer to a JSON object for this iterator
11453
    @pre object != nullptr
11454
    @post The iterator is initialized; i.e. `m_object != nullptr`.
11455
    */
11456
    explicit iter_impl(pointer object) noexcept : m_object(object)
11457
    {
11458
        JSON_ASSERT(m_object != nullptr);
11459

11460
        switch (m_object->m_type)
11461
        {
11462
            case value_t::object:
11463
            {
11464
                m_it.object_iterator = typename object_t::iterator();
11465
                break;
11466
            }
11467

11468
            case value_t::array:
11469
            {
11470
                m_it.array_iterator = typename array_t::iterator();
11471
                break;
11472
            }
11473

11474
            case value_t::null:
11475
            case value_t::string:
11476
            case value_t::boolean:
11477
            case value_t::number_integer:
11478
            case value_t::number_unsigned:
11479
            case value_t::number_float:
11480
            case value_t::binary:
11481
            case value_t::discarded:
11482
            default:
11483
            {
11484
                m_it.primitive_iterator = primitive_iterator_t();
11485
                break;
11486
            }
11487
        }
11488
    }
11489

11490
    /*!
11491
    @note The conventional copy constructor and copy assignment are implicitly
11492
          defined. Combined with the following converting constructor and
11493
          assignment, they support: (1) copy from iterator to iterator, (2)
11494
          copy from const iterator to const iterator, and (3) conversion from
11495
          iterator to const iterator. However conversion from const iterator
11496
          to iterator is not defined.
11497
    */
11498

11499
    /*!
11500
    @brief const copy constructor
11501
    @param[in] other const iterator to copy from
11502
    @note This copy constructor had to be defined explicitly to circumvent a bug
11503
          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
11504
          information refer to: https://github.com/nlohmann/json/issues/1608
11505
    */
11506
    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
11507
        : m_object(other.m_object), m_it(other.m_it)
11508
    {}
11509

11510
    /*!
11511
    @brief converting assignment
11512
    @param[in] other const iterator to copy from
11513
    @return const/non-const iterator
11514
    @note It is not checked whether @a other is initialized.
11515
    */
11516
    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
11517
    {
11518
        if (&other != this)
11519
        {
11520
            m_object = other.m_object;
11521
            m_it = other.m_it;
11522
        }
11523
        return *this;
11524
    }
11525

11526
    /*!
11527
    @brief converting constructor
11528
    @param[in] other  non-const iterator to copy from
11529
    @note It is not checked whether @a other is initialized.
11530
    */
11531
    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
11532
        : m_object(other.m_object), m_it(other.m_it)
11533
    {}
11534

11535
    /*!
11536
    @brief converting assignment
11537
    @param[in] other  non-const iterator to copy from
11538
    @return const/non-const iterator
11539
    @note It is not checked whether @a other is initialized.
11540
    */
11541
    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
11542
    {
11543
        m_object = other.m_object;
11544
        m_it = other.m_it;
11545
        return *this;
11546
    }
11547

11548
  JSON_PRIVATE_UNLESS_TESTED:
11549
    /*!
11550
    @brief set the iterator to the first value
11551
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11552
    */
11553
    void set_begin() noexcept
11554
    {
11555
        JSON_ASSERT(m_object != nullptr);
11556

11557
        switch (m_object->m_type)
11558
        {
11559
            case value_t::object:
11560
            {
11561
                m_it.object_iterator = m_object->m_value.object->begin();
11562
                break;
11563
            }
11564

11565
            case value_t::array:
11566
            {
11567
                m_it.array_iterator = m_object->m_value.array->begin();
11568
                break;
11569
            }
11570

11571
            case value_t::null:
11572
            {
11573
                // set to end so begin()==end() is true: null is empty
11574
                m_it.primitive_iterator.set_end();
11575
                break;
11576
            }
11577

11578
            case value_t::string:
11579
            case value_t::boolean:
11580
            case value_t::number_integer:
11581
            case value_t::number_unsigned:
11582
            case value_t::number_float:
11583
            case value_t::binary:
11584
            case value_t::discarded:
11585
            default:
11586
            {
11587
                m_it.primitive_iterator.set_begin();
11588
                break;
11589
            }
11590
        }
11591
    }
11592

11593
    /*!
11594
    @brief set the iterator past the last value
11595
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11596
    */
11597
    void set_end() noexcept
11598
    {
11599
        JSON_ASSERT(m_object != nullptr);
11600

11601
        switch (m_object->m_type)
11602
        {
11603
            case value_t::object:
11604
            {
11605
                m_it.object_iterator = m_object->m_value.object->end();
11606
                break;
11607
            }
11608

11609
            case value_t::array:
11610
            {
11611
                m_it.array_iterator = m_object->m_value.array->end();
11612
                break;
11613
            }
11614

11615
            case value_t::null:
11616
            case value_t::string:
11617
            case value_t::boolean:
11618
            case value_t::number_integer:
11619
            case value_t::number_unsigned:
11620
            case value_t::number_float:
11621
            case value_t::binary:
11622
            case value_t::discarded:
11623
            default:
11624
            {
11625
                m_it.primitive_iterator.set_end();
11626
                break;
11627
            }
11628
        }
11629
    }
11630

11631
  public:
11632
    /*!
11633
    @brief return a reference to the value pointed to by the iterator
11634
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11635
    */
11636
    reference operator*() const
11637
    {
11638
        JSON_ASSERT(m_object != nullptr);
11639

11640
        switch (m_object->m_type)
11641
        {
11642
            case value_t::object:
11643
            {
11644
                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11645
                return m_it.object_iterator->second;
11646
            }
11647

11648
            case value_t::array:
11649
            {
11650
                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11651
                return *m_it.array_iterator;
11652
            }
11653

11654
            case value_t::null:
11655
                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
11656

11657
            case value_t::string:
11658
            case value_t::boolean:
11659
            case value_t::number_integer:
11660
            case value_t::number_unsigned:
11661
            case value_t::number_float:
11662
            case value_t::binary:
11663
            case value_t::discarded:
11664
            default:
11665
            {
11666
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11667
                {
11668
                    return *m_object;
11669
                }
11670

11671
                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
11672
            }
11673
        }
11674
    }
11675

11676
    /*!
11677
    @brief dereference the iterator
11678
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11679
    */
11680
    pointer operator->() const
11681
    {
11682
        JSON_ASSERT(m_object != nullptr);
11683

11684
        switch (m_object->m_type)
11685
        {
11686
            case value_t::object:
11687
            {
11688
                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11689
                return &(m_it.object_iterator->second);
11690
            }
11691

11692
            case value_t::array:
11693
            {
11694
                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11695
                return &*m_it.array_iterator;
11696
            }
11697

11698
            case value_t::null:
11699
            case value_t::string:
11700
            case value_t::boolean:
11701
            case value_t::number_integer:
11702
            case value_t::number_unsigned:
11703
            case value_t::number_float:
11704
            case value_t::binary:
11705
            case value_t::discarded:
11706
            default:
11707
            {
11708
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11709
                {
11710
                    return m_object;
11711
                }
11712

11713
                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
11714
            }
11715
        }
11716
    }
11717

11718
    /*!
11719
    @brief post-increment (it++)
11720
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11721
    */
11722
    iter_impl const operator++(int) // NOLINT(readability-const-return-type)
11723
    {
11724
        auto result = *this;
11725
        ++(*this);
11726
        return result;
11727
    }
11728

11729
    /*!
11730
    @brief pre-increment (++it)
11731
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11732
    */
11733
    iter_impl& operator++()
11734
    {
11735
        JSON_ASSERT(m_object != nullptr);
11736

11737
        switch (m_object->m_type)
11738
        {
11739
            case value_t::object:
11740
            {
11741
                std::advance(m_it.object_iterator, 1);
11742
                break;
11743
            }
11744

11745
            case value_t::array:
11746
            {
11747
                std::advance(m_it.array_iterator, 1);
11748
                break;
11749
            }
11750

11751
            case value_t::null:
11752
            case value_t::string:
11753
            case value_t::boolean:
11754
            case value_t::number_integer:
11755
            case value_t::number_unsigned:
11756
            case value_t::number_float:
11757
            case value_t::binary:
11758
            case value_t::discarded:
11759
            default:
11760
            {
11761
                ++m_it.primitive_iterator;
11762
                break;
11763
            }
11764
        }
11765

11766
        return *this;
11767
    }
11768

11769
    /*!
11770
    @brief post-decrement (it--)
11771
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11772
    */
11773
    iter_impl const operator--(int) // NOLINT(readability-const-return-type)
11774
    {
11775
        auto result = *this;
11776
        --(*this);
11777
        return result;
11778
    }
11779

11780
    /*!
11781
    @brief pre-decrement (--it)
11782
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11783
    */
11784
    iter_impl& operator--()
11785
    {
11786
        JSON_ASSERT(m_object != nullptr);
11787

11788
        switch (m_object->m_type)
11789
        {
11790
            case value_t::object:
11791
            {
11792
                std::advance(m_it.object_iterator, -1);
11793
                break;
11794
            }
11795

11796
            case value_t::array:
11797
            {
11798
                std::advance(m_it.array_iterator, -1);
11799
                break;
11800
            }
11801

11802
            case value_t::null:
11803
            case value_t::string:
11804
            case value_t::boolean:
11805
            case value_t::number_integer:
11806
            case value_t::number_unsigned:
11807
            case value_t::number_float:
11808
            case value_t::binary:
11809
            case value_t::discarded:
11810
            default:
11811
            {
11812
                --m_it.primitive_iterator;
11813
                break;
11814
            }
11815
        }
11816

11817
        return *this;
11818
    }
11819

11820
    /*!
11821
    @brief comparison: equal
11822
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11823
    */
11824
    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
11825
    bool operator==(const IterImpl& other) const
11826
    {
11827
        // if objects are not the same, the comparison is undefined
11828
        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11829
        {
11830
            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
11831
        }
11832

11833
        JSON_ASSERT(m_object != nullptr);
11834

11835
        switch (m_object->m_type)
11836
        {
11837
            case value_t::object:
11838
                return (m_it.object_iterator == other.m_it.object_iterator);
11839

11840
            case value_t::array:
11841
                return (m_it.array_iterator == other.m_it.array_iterator);
11842

11843
            case value_t::null:
11844
            case value_t::string:
11845
            case value_t::boolean:
11846
            case value_t::number_integer:
11847
            case value_t::number_unsigned:
11848
            case value_t::number_float:
11849
            case value_t::binary:
11850
            case value_t::discarded:
11851
            default:
11852
                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11853
        }
11854
    }
11855

11856
    /*!
11857
    @brief comparison: not equal
11858
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11859
    */
11860
    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
11861
    bool operator!=(const IterImpl& other) const
11862
    {
11863
        return !operator==(other);
11864
    }
11865

11866
    /*!
11867
    @brief comparison: smaller
11868
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11869
    */
11870
    bool operator<(const iter_impl& other) const
11871
    {
11872
        // if objects are not the same, the comparison is undefined
11873
        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11874
        {
11875
            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
11876
        }
11877

11878
        JSON_ASSERT(m_object != nullptr);
11879

11880
        switch (m_object->m_type)
11881
        {
11882
            case value_t::object:
11883
                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", *m_object));
11884

11885
            case value_t::array:
11886
                return (m_it.array_iterator < other.m_it.array_iterator);
11887

11888
            case value_t::null:
11889
            case value_t::string:
11890
            case value_t::boolean:
11891
            case value_t::number_integer:
11892
            case value_t::number_unsigned:
11893
            case value_t::number_float:
11894
            case value_t::binary:
11895
            case value_t::discarded:
11896
            default:
11897
                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
11898
        }
11899
    }
11900

11901
    /*!
11902
    @brief comparison: less than or equal
11903
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11904
    */
11905
    bool operator<=(const iter_impl& other) const
11906
    {
11907
        return !other.operator < (*this);
11908
    }
11909

11910
    /*!
11911
    @brief comparison: greater than
11912
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11913
    */
11914
    bool operator>(const iter_impl& other) const
11915
    {
11916
        return !operator<=(other);
11917
    }
11918

11919
    /*!
11920
    @brief comparison: greater than or equal
11921
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11922
    */
11923
    bool operator>=(const iter_impl& other) const
11924
    {
11925
        return !operator<(other);
11926
    }
11927

11928
    /*!
11929
    @brief add to iterator
11930
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11931
    */
11932
    iter_impl& operator+=(difference_type i)
11933
    {
11934
        JSON_ASSERT(m_object != nullptr);
11935

11936
        switch (m_object->m_type)
11937
        {
11938
            case value_t::object:
11939
                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
11940

11941
            case value_t::array:
11942
            {
11943
                std::advance(m_it.array_iterator, i);
11944
                break;
11945
            }
11946

11947
            case value_t::null:
11948
            case value_t::string:
11949
            case value_t::boolean:
11950
            case value_t::number_integer:
11951
            case value_t::number_unsigned:
11952
            case value_t::number_float:
11953
            case value_t::binary:
11954
            case value_t::discarded:
11955
            default:
11956
            {
11957
                m_it.primitive_iterator += i;
11958
                break;
11959
            }
11960
        }
11961

11962
        return *this;
11963
    }
11964

11965
    /*!
11966
    @brief subtract from iterator
11967
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11968
    */
11969
    iter_impl& operator-=(difference_type i)
11970
    {
11971
        return operator+=(-i);
11972
    }
11973

11974
    /*!
11975
    @brief add to iterator
11976
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11977
    */
11978
    iter_impl operator+(difference_type i) const
11979
    {
11980
        auto result = *this;
11981
        result += i;
11982
        return result;
11983
    }
11984

11985
    /*!
11986
    @brief addition of distance and iterator
11987
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11988
    */
11989
    friend iter_impl operator+(difference_type i, const iter_impl& it)
11990
    {
11991
        auto result = it;
11992
        result += i;
11993
        return result;
11994
    }
11995

11996
    /*!
11997
    @brief subtract from iterator
11998
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
11999
    */
12000
    iter_impl operator-(difference_type i) const
12001
    {
12002
        auto result = *this;
12003
        result -= i;
12004
        return result;
12005
    }
12006

12007
    /*!
12008
    @brief return difference
12009
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
12010
    */
12011
    difference_type operator-(const iter_impl& other) const
12012
    {
12013
        JSON_ASSERT(m_object != nullptr);
12014

12015
        switch (m_object->m_type)
12016
        {
12017
            case value_t::object:
12018
                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
12019

12020
            case value_t::array:
12021
                return m_it.array_iterator - other.m_it.array_iterator;
12022

12023
            case value_t::null:
12024
            case value_t::string:
12025
            case value_t::boolean:
12026
            case value_t::number_integer:
12027
            case value_t::number_unsigned:
12028
            case value_t::number_float:
12029
            case value_t::binary:
12030
            case value_t::discarded:
12031
            default:
12032
                return m_it.primitive_iterator - other.m_it.primitive_iterator;
12033
        }
12034
    }
12035

12036
    /*!
12037
    @brief access to successor
12038
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
12039
    */
12040
    reference operator[](difference_type n) const
12041
    {
12042
        JSON_ASSERT(m_object != nullptr);
12043

12044
        switch (m_object->m_type)
12045
        {
12046
            case value_t::object:
12047
                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", *m_object));
12048

12049
            case value_t::array:
12050
                return *std::next(m_it.array_iterator, n);
12051

12052
            case value_t::null:
12053
                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
12054

12055
            case value_t::string:
12056
            case value_t::boolean:
12057
            case value_t::number_integer:
12058
            case value_t::number_unsigned:
12059
            case value_t::number_float:
12060
            case value_t::binary:
12061
            case value_t::discarded:
12062
            default:
12063
            {
12064
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
12065
                {
12066
                    return *m_object;
12067
                }
12068

12069
                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
12070
            }
12071
        }
12072
    }
12073

12074
    /*!
12075
    @brief return the key of an object iterator
12076
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
12077
    */
12078
    const typename object_t::key_type& key() const
12079
    {
12080
        JSON_ASSERT(m_object != nullptr);
12081

12082
        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
12083
        {
12084
            return m_it.object_iterator->first;
12085
        }
12086

12087
        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", *m_object));
12088
    }
12089

12090
    /*!
12091
    @brief return the value of an iterator
12092
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
12093
    */
12094
    reference value() const
12095
    {
12096
        return operator*();
12097
    }
12098

12099
  JSON_PRIVATE_UNLESS_TESTED:
12100
    /// associated JSON instance
12101
    pointer m_object = nullptr;
12102
    /// the actual iterator of the associated instance
12103
    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
12104
};
12105
} // namespace detail
12106
} // namespace nlohmann
12107

12108
// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
12109

12110
// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
12111

12112

12113
#include <cstddef> // ptrdiff_t
12114
#include <iterator> // reverse_iterator
12115
#include <utility> // declval
12116

12117
namespace nlohmann
12118
{
12119
namespace detail
12120
{
12121
//////////////////////
12122
// reverse_iterator //
12123
//////////////////////
12124

12125
/*!
12126
@brief a template for a reverse iterator class
12127

12128
@tparam Base the base iterator type to reverse. Valid types are @ref
12129
iterator (to create @ref reverse_iterator) and @ref const_iterator (to
12130
create @ref const_reverse_iterator).
12131

12132
@requirement The class satisfies the following concept requirements:
12133
-
12134
[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
12135
  The iterator that can be moved can be moved in both directions (i.e.
12136
  incremented and decremented).
12137
- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
12138
  It is possible to write to the pointed-to element (only if @a Base is
12139
  @ref iterator).
12140

12141
@since version 1.0.0
12142
*/
12143
template<typename Base>
12144
class json_reverse_iterator : public std::reverse_iterator<Base>
12145
{
12146
  public:
12147
    using difference_type = std::ptrdiff_t;
12148
    /// shortcut to the reverse iterator adapter
12149
    using base_iterator = std::reverse_iterator<Base>;
12150
    /// the reference type for the pointed-to element
12151
    using reference = typename Base::reference;
12152

12153
    /// create reverse iterator from iterator
12154
    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
12155
        : base_iterator(it) {}
12156

12157
    /// create reverse iterator from base class
12158
    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
12159

12160
    /// post-increment (it++)
12161
    json_reverse_iterator const operator++(int) // NOLINT(readability-const-return-type)
12162
    {
12163
        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
12164
    }
12165

12166
    /// pre-increment (++it)
12167
    json_reverse_iterator& operator++()
12168
    {
12169
        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
12170
    }
12171

12172
    /// post-decrement (it--)
12173
    json_reverse_iterator const operator--(int) // NOLINT(readability-const-return-type)
12174
    {
12175
        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
12176
    }
12177

12178
    /// pre-decrement (--it)
12179
    json_reverse_iterator& operator--()
12180
    {
12181
        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
12182
    }
12183

12184
    /// add to iterator
12185
    json_reverse_iterator& operator+=(difference_type i)
12186
    {
12187
        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
12188
    }
12189

12190
    /// add to iterator
12191
    json_reverse_iterator operator+(difference_type i) const
12192
    {
12193
        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
12194
    }
12195

12196
    /// subtract from iterator
12197
    json_reverse_iterator operator-(difference_type i) const
12198
    {
12199
        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
12200
    }
12201

12202
    /// return difference
12203
    difference_type operator-(const json_reverse_iterator& other) const
12204
    {
12205
        return base_iterator(*this) - base_iterator(other);
12206
    }
12207

12208
    /// access to successor
12209
    reference operator[](difference_type n) const
12210
    {
12211
        return *(this->operator+(n));
12212
    }
12213

12214
    /// return the key of an object iterator
12215
    auto key() const -> decltype(std::declval<Base>().key())
12216
    {
12217
        auto it = --this->base();
12218
        return it.key();
12219
    }
12220

12221
    /// return the value of an iterator
12222
    reference value() const
12223
    {
12224
        auto it = --this->base();
12225
        return it.operator * ();
12226
    }
12227
};
12228
}  // namespace detail
12229
}  // namespace nlohmann
12230

12231
// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
12232

12233
// #include <nlohmann/detail/json_pointer.hpp>
12234

12235

12236
#include <algorithm> // all_of
12237
#include <cctype> // isdigit
12238
#include <limits> // max
12239
#include <numeric> // accumulate
12240
#include <string> // string
12241
#include <utility> // move
12242
#include <vector> // vector
12243

12244
// #include <nlohmann/detail/exceptions.hpp>
12245

12246
// #include <nlohmann/detail/macro_scope.hpp>
12247

12248
// #include <nlohmann/detail/string_escape.hpp>
12249

12250
// #include <nlohmann/detail/value_t.hpp>
12251

12252

12253
namespace nlohmann
12254
{
12255

12256
/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
12257
/// @sa https://json.nlohmann.me/api/json_pointer/
12258
template<typename BasicJsonType>
12259
class json_pointer
12260
{
12261
    // allow basic_json to access private members
12262
    NLOHMANN_BASIC_JSON_TPL_DECLARATION
12263
    friend class basic_json;
12264

12265
  public:
12266
    /// @brief create JSON pointer
12267
    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
12268
    explicit json_pointer(const std::string& s = "")
12269
        : reference_tokens(split(s))
12270
    {}
12271

12272
    /// @brief return a string representation of the JSON pointer
12273
    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
12274
    std::string to_string() const
12275
    {
12276
        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
12277
                               std::string{},
12278
                               [](const std::string & a, const std::string & b)
12279
        {
12280
            return a + "/" + detail::escape(b);
12281
        });
12282
    }
12283

12284
    /// @brief return a string representation of the JSON pointer
12285
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
12286
    operator std::string() const
12287
    {
12288
        return to_string();
12289
    }
12290

12291
    /// @brief append another JSON pointer at the end of this JSON pointer
12292
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
12293
    json_pointer& operator/=(const json_pointer& ptr)
12294
    {
12295
        reference_tokens.insert(reference_tokens.end(),
12296
                                ptr.reference_tokens.begin(),
12297
                                ptr.reference_tokens.end());
12298
        return *this;
12299
    }
12300

12301
    /// @brief append an unescaped reference token at the end of this JSON pointer
12302
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
12303
    json_pointer& operator/=(std::string token)
12304
    {
12305
        push_back(std::move(token));
12306
        return *this;
12307
    }
12308

12309
    /// @brief append an array index at the end of this JSON pointer
12310
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
12311
    json_pointer& operator/=(std::size_t array_idx)
12312
    {
12313
        return *this /= std::to_string(array_idx);
12314
    }
12315

12316
    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
12317
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
12318
    friend json_pointer operator/(const json_pointer& lhs,
12319
                                  const json_pointer& rhs)
12320
    {
12321
        return json_pointer(lhs) /= rhs;
12322
    }
12323

12324
    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
12325
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
12326
    friend json_pointer operator/(const json_pointer& lhs, std::string token) // NOLINT(performance-unnecessary-value-param)
12327
    {
12328
        return json_pointer(lhs) /= std::move(token);
12329
    }
12330

12331
    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
12332
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
12333
    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
12334
    {
12335
        return json_pointer(lhs) /= array_idx;
12336
    }
12337

12338
    /// @brief returns the parent of this JSON pointer
12339
    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
12340
    json_pointer parent_pointer() const
12341
    {
12342
        if (empty())
12343
        {
12344
            return *this;
12345
        }
12346

12347
        json_pointer res = *this;
12348
        res.pop_back();
12349
        return res;
12350
    }
12351

12352
    /// @brief remove last reference token
12353
    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
12354
    void pop_back()
12355
    {
12356
        if (JSON_HEDLEY_UNLIKELY(empty()))
12357
        {
12358
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
12359
        }
12360

12361
        reference_tokens.pop_back();
12362
    }
12363

12364
    /// @brief return last reference token
12365
    /// @sa https://json.nlohmann.me/api/json_pointer/back/
12366
    const std::string& back() const
12367
    {
12368
        if (JSON_HEDLEY_UNLIKELY(empty()))
12369
        {
12370
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
12371
        }
12372

12373
        return reference_tokens.back();
12374
    }
12375

12376
    /// @brief append an unescaped token at the end of the reference pointer
12377
    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
12378
    void push_back(const std::string& token)
12379
    {
12380
        reference_tokens.push_back(token);
12381
    }
12382

12383
    /// @brief append an unescaped token at the end of the reference pointer
12384
    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
12385
    void push_back(std::string&& token)
12386
    {
12387
        reference_tokens.push_back(std::move(token));
12388
    }
12389

12390
    /// @brief return whether pointer points to the root document
12391
    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
12392
    bool empty() const noexcept
12393
    {
12394
        return reference_tokens.empty();
12395
    }
12396

12397
  private:
12398
    /*!
12399
    @param[in] s  reference token to be converted into an array index
12400

12401
    @return integer representation of @a s
12402

12403
    @throw parse_error.106  if an array index begins with '0'
12404
    @throw parse_error.109  if an array index begins not with a digit
12405
    @throw out_of_range.404 if string @a s could not be converted to an integer
12406
    @throw out_of_range.410 if an array index exceeds size_type
12407
    */
12408
    static typename BasicJsonType::size_type array_index(const std::string& s)
12409
    {
12410
        using size_type = typename BasicJsonType::size_type;
12411

12412
        // error condition (cf. RFC 6901, Sect. 4)
12413
        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
12414
        {
12415
            JSON_THROW(detail::parse_error::create(106, 0, "array index '" + s + "' must not begin with '0'", BasicJsonType()));
12416
        }
12417

12418
        // error condition (cf. RFC 6901, Sect. 4)
12419
        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
12420
        {
12421
            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number", BasicJsonType()));
12422
        }
12423

12424
        std::size_t processed_chars = 0;
12425
        unsigned long long res = 0;  // NOLINT(runtime/int)
12426
        JSON_TRY
12427
        {
12428
            res = std::stoull(s, &processed_chars);
12429
        }
12430
        JSON_CATCH(std::out_of_range&)
12431
        {
12432
            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
12433
        }
12434

12435
        // check if the string was completely read
12436
        if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
12437
        {
12438
            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
12439
        }
12440

12441
        // only triggered on special platforms (like 32bit), see also
12442
        // https://github.com/nlohmann/json/pull/2203
12443
        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
12444
        {
12445
            JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type", BasicJsonType())); // LCOV_EXCL_LINE
12446
        }
12447

12448
        return static_cast<size_type>(res);
12449
    }
12450

12451
  JSON_PRIVATE_UNLESS_TESTED:
12452
    json_pointer top() const
12453
    {
12454
        if (JSON_HEDLEY_UNLIKELY(empty()))
12455
        {
12456
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
12457
        }
12458

12459
        json_pointer result = *this;
12460
        result.reference_tokens = {reference_tokens[0]};
12461
        return result;
12462
    }
12463

12464
  private:
12465
    /*!
12466
    @brief create and return a reference to the pointed to value
12467

12468
    @complexity Linear in the number of reference tokens.
12469

12470
    @throw parse_error.109 if array index is not a number
12471
    @throw type_error.313 if value cannot be unflattened
12472
    */
12473
    BasicJsonType& get_and_create(BasicJsonType& j) const
12474
    {
12475
        auto* result = &j;
12476

12477
        // in case no reference tokens exist, return a reference to the JSON value
12478
        // j which will be overwritten by a primitive value
12479
        for (const auto& reference_token : reference_tokens)
12480
        {
12481
            switch (result->type())
12482
            {
12483
                case detail::value_t::null:
12484
                {
12485
                    if (reference_token == "0")
12486
                    {
12487
                        // start a new array if reference token is 0
12488
                        result = &result->operator[](0);
12489
                    }
12490
                    else
12491
                    {
12492
                        // start a new object otherwise
12493
                        result = &result->operator[](reference_token);
12494
                    }
12495
                    break;
12496
                }
12497

12498
                case detail::value_t::object:
12499
                {
12500
                    // create an entry in the object
12501
                    result = &result->operator[](reference_token);
12502
                    break;
12503
                }
12504

12505
                case detail::value_t::array:
12506
                {
12507
                    // create an entry in the array
12508
                    result = &result->operator[](array_index(reference_token));
12509
                    break;
12510
                }
12511

12512
                /*
12513
                The following code is only reached if there exists a reference
12514
                token _and_ the current value is primitive. In this case, we have
12515
                an error situation, because primitive values may only occur as
12516
                single value; that is, with an empty list of reference tokens.
12517
                */
12518
                case detail::value_t::string:
12519
                case detail::value_t::boolean:
12520
                case detail::value_t::number_integer:
12521
                case detail::value_t::number_unsigned:
12522
                case detail::value_t::number_float:
12523
                case detail::value_t::binary:
12524
                case detail::value_t::discarded:
12525
                default:
12526
                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", j));
12527
            }
12528
        }
12529

12530
        return *result;
12531
    }
12532

12533
    /*!
12534
    @brief return a reference to the pointed to value
12535

12536
    @note This version does not throw if a value is not present, but tries to
12537
          create nested values instead. For instance, calling this function
12538
          with pointer `"/this/that"` on a null value is equivalent to calling
12539
          `operator[]("this").operator[]("that")` on that value, effectively
12540
          changing the null value to an object.
12541

12542
    @param[in] ptr  a JSON value
12543

12544
    @return reference to the JSON value pointed to by the JSON pointer
12545

12546
    @complexity Linear in the length of the JSON pointer.
12547

12548
    @throw parse_error.106   if an array index begins with '0'
12549
    @throw parse_error.109   if an array index was not a number
12550
    @throw out_of_range.404  if the JSON pointer can not be resolved
12551
    */
12552
    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
12553
    {
12554
        for (const auto& reference_token : reference_tokens)
12555
        {
12556
            // convert null values to arrays or objects before continuing
12557
            if (ptr->is_null())
12558
            {
12559
                // check if reference token is a number
12560
                const bool nums =
12561
                    std::all_of(reference_token.begin(), reference_token.end(),
12562
                                [](const unsigned char x)
12563
                {
12564
                    return std::isdigit(x);
12565
                });
12566

12567
                // change value to array for numbers or "-" or to object otherwise
12568
                *ptr = (nums || reference_token == "-")
12569
                       ? detail::value_t::array
12570
                       : detail::value_t::object;
12571
            }
12572

12573
            switch (ptr->type())
12574
            {
12575
                case detail::value_t::object:
12576
                {
12577
                    // use unchecked object access
12578
                    ptr = &ptr->operator[](reference_token);
12579
                    break;
12580
                }
12581

12582
                case detail::value_t::array:
12583
                {
12584
                    if (reference_token == "-")
12585
                    {
12586
                        // explicitly treat "-" as index beyond the end
12587
                        ptr = &ptr->operator[](ptr->m_value.array->size());
12588
                    }
12589
                    else
12590
                    {
12591
                        // convert array index to number; unchecked access
12592
                        ptr = &ptr->operator[](array_index(reference_token));
12593
                    }
12594
                    break;
12595
                }
12596

12597
                case detail::value_t::null:
12598
                case detail::value_t::string:
12599
                case detail::value_t::boolean:
12600
                case detail::value_t::number_integer:
12601
                case detail::value_t::number_unsigned:
12602
                case detail::value_t::number_float:
12603
                case detail::value_t::binary:
12604
                case detail::value_t::discarded:
12605
                default:
12606
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12607
            }
12608
        }
12609

12610
        return *ptr;
12611
    }
12612

12613
    /*!
12614
    @throw parse_error.106   if an array index begins with '0'
12615
    @throw parse_error.109   if an array index was not a number
12616
    @throw out_of_range.402  if the array index '-' is used
12617
    @throw out_of_range.404  if the JSON pointer can not be resolved
12618
    */
12619
    BasicJsonType& get_checked(BasicJsonType* ptr) const
12620
    {
12621
        for (const auto& reference_token : reference_tokens)
12622
        {
12623
            switch (ptr->type())
12624
            {
12625
                case detail::value_t::object:
12626
                {
12627
                    // note: at performs range check
12628
                    ptr = &ptr->at(reference_token);
12629
                    break;
12630
                }
12631

12632
                case detail::value_t::array:
12633
                {
12634
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12635
                    {
12636
                        // "-" always fails the range check
12637
                        JSON_THROW(detail::out_of_range::create(402,
12638
                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12639
                                                                ") is out of range", *ptr));
12640
                    }
12641

12642
                    // note: at performs range check
12643
                    ptr = &ptr->at(array_index(reference_token));
12644
                    break;
12645
                }
12646

12647
                case detail::value_t::null:
12648
                case detail::value_t::string:
12649
                case detail::value_t::boolean:
12650
                case detail::value_t::number_integer:
12651
                case detail::value_t::number_unsigned:
12652
                case detail::value_t::number_float:
12653
                case detail::value_t::binary:
12654
                case detail::value_t::discarded:
12655
                default:
12656
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12657
            }
12658
        }
12659

12660
        return *ptr;
12661
    }
12662

12663
    /*!
12664
    @brief return a const reference to the pointed to value
12665

12666
    @param[in] ptr  a JSON value
12667

12668
    @return const reference to the JSON value pointed to by the JSON
12669
    pointer
12670

12671
    @throw parse_error.106   if an array index begins with '0'
12672
    @throw parse_error.109   if an array index was not a number
12673
    @throw out_of_range.402  if the array index '-' is used
12674
    @throw out_of_range.404  if the JSON pointer can not be resolved
12675
    */
12676
    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
12677
    {
12678
        for (const auto& reference_token : reference_tokens)
12679
        {
12680
            switch (ptr->type())
12681
            {
12682
                case detail::value_t::object:
12683
                {
12684
                    // use unchecked object access
12685
                    ptr = &ptr->operator[](reference_token);
12686
                    break;
12687
                }
12688

12689
                case detail::value_t::array:
12690
                {
12691
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12692
                    {
12693
                        // "-" cannot be used for const access
12694
                        JSON_THROW(detail::out_of_range::create(402, "array index '-' (" + std::to_string(ptr->m_value.array->size()) + ") is out of range", *ptr));
12695
                    }
12696

12697
                    // use unchecked array access
12698
                    ptr = &ptr->operator[](array_index(reference_token));
12699
                    break;
12700
                }
12701

12702
                case detail::value_t::null:
12703
                case detail::value_t::string:
12704
                case detail::value_t::boolean:
12705
                case detail::value_t::number_integer:
12706
                case detail::value_t::number_unsigned:
12707
                case detail::value_t::number_float:
12708
                case detail::value_t::binary:
12709
                case detail::value_t::discarded:
12710
                default:
12711
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12712
            }
12713
        }
12714

12715
        return *ptr;
12716
    }
12717

12718
    /*!
12719
    @throw parse_error.106   if an array index begins with '0'
12720
    @throw parse_error.109   if an array index was not a number
12721
    @throw out_of_range.402  if the array index '-' is used
12722
    @throw out_of_range.404  if the JSON pointer can not be resolved
12723
    */
12724
    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
12725
    {
12726
        for (const auto& reference_token : reference_tokens)
12727
        {
12728
            switch (ptr->type())
12729
            {
12730
                case detail::value_t::object:
12731
                {
12732
                    // note: at performs range check
12733
                    ptr = &ptr->at(reference_token);
12734
                    break;
12735
                }
12736

12737
                case detail::value_t::array:
12738
                {
12739
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12740
                    {
12741
                        // "-" always fails the range check
12742
                        JSON_THROW(detail::out_of_range::create(402,
12743
                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12744
                                                                ") is out of range", *ptr));
12745
                    }
12746

12747
                    // note: at performs range check
12748
                    ptr = &ptr->at(array_index(reference_token));
12749
                    break;
12750
                }
12751

12752
                case detail::value_t::null:
12753
                case detail::value_t::string:
12754
                case detail::value_t::boolean:
12755
                case detail::value_t::number_integer:
12756
                case detail::value_t::number_unsigned:
12757
                case detail::value_t::number_float:
12758
                case detail::value_t::binary:
12759
                case detail::value_t::discarded:
12760
                default:
12761
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12762
            }
12763
        }
12764

12765
        return *ptr;
12766
    }
12767

12768
    /*!
12769
    @throw parse_error.106   if an array index begins with '0'
12770
    @throw parse_error.109   if an array index was not a number
12771
    */
12772
    bool contains(const BasicJsonType* ptr) const
12773
    {
12774
        for (const auto& reference_token : reference_tokens)
12775
        {
12776
            switch (ptr->type())
12777
            {
12778
                case detail::value_t::object:
12779
                {
12780
                    if (!ptr->contains(reference_token))
12781
                    {
12782
                        // we did not find the key in the object
12783
                        return false;
12784
                    }
12785

12786
                    ptr = &ptr->operator[](reference_token);
12787
                    break;
12788
                }
12789

12790
                case detail::value_t::array:
12791
                {
12792
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12793
                    {
12794
                        // "-" always fails the range check
12795
                        return false;
12796
                    }
12797
                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
12798
                    {
12799
                        // invalid char
12800
                        return false;
12801
                    }
12802
                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
12803
                    {
12804
                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
12805
                        {
12806
                            // first char should be between '1' and '9'
12807
                            return false;
12808
                        }
12809
                        for (std::size_t i = 1; i < reference_token.size(); i++)
12810
                        {
12811
                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
12812
                            {
12813
                                // other char should be between '0' and '9'
12814
                                return false;
12815
                            }
12816
                        }
12817
                    }
12818

12819
                    const auto idx = array_index(reference_token);
12820
                    if (idx >= ptr->size())
12821
                    {
12822
                        // index out of range
12823
                        return false;
12824
                    }
12825

12826
                    ptr = &ptr->operator[](idx);
12827
                    break;
12828
                }
12829

12830
                case detail::value_t::null:
12831
                case detail::value_t::string:
12832
                case detail::value_t::boolean:
12833
                case detail::value_t::number_integer:
12834
                case detail::value_t::number_unsigned:
12835
                case detail::value_t::number_float:
12836
                case detail::value_t::binary:
12837
                case detail::value_t::discarded:
12838
                default:
12839
                {
12840
                    // we do not expect primitive values if there is still a
12841
                    // reference token to process
12842
                    return false;
12843
                }
12844
            }
12845
        }
12846

12847
        // no reference token left means we found a primitive value
12848
        return true;
12849
    }
12850

12851
    /*!
12852
    @brief split the string input to reference tokens
12853

12854
    @note This function is only called by the json_pointer constructor.
12855
          All exceptions below are documented there.
12856

12857
    @throw parse_error.107  if the pointer is not empty or begins with '/'
12858
    @throw parse_error.108  if character '~' is not followed by '0' or '1'
12859
    */
12860
    static std::vector<std::string> split(const std::string& reference_string)
12861
    {
12862
        std::vector<std::string> result;
12863

12864
        // special case: empty reference string -> no reference tokens
12865
        if (reference_string.empty())
12866
        {
12867
            return result;
12868
        }
12869

12870
        // check if nonempty reference string begins with slash
12871
        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
12872
        {
12873
            JSON_THROW(detail::parse_error::create(107, 1, "JSON pointer must be empty or begin with '/' - was: '" + reference_string + "'", BasicJsonType()));
12874
        }
12875

12876
        // extract the reference tokens:
12877
        // - slash: position of the last read slash (or end of string)
12878
        // - start: position after the previous slash
12879
        for (
12880
            // search for the first slash after the first character
12881
            std::size_t slash = reference_string.find_first_of('/', 1),
12882
            // set the beginning of the first reference token
12883
            start = 1;
12884
            // we can stop if start == 0 (if slash == std::string::npos)
12885
            start != 0;
12886
            // set the beginning of the next reference token
12887
            // (will eventually be 0 if slash == std::string::npos)
12888
            start = (slash == std::string::npos) ? 0 : slash + 1,
12889
            // find next slash
12890
            slash = reference_string.find_first_of('/', start))
12891
        {
12892
            // use the text between the beginning of the reference token
12893
            // (start) and the last slash (slash).
12894
            auto reference_token = reference_string.substr(start, slash - start);
12895

12896
            // check reference tokens are properly escaped
12897
            for (std::size_t pos = reference_token.find_first_of('~');
12898
                    pos != std::string::npos;
12899
                    pos = reference_token.find_first_of('~', pos + 1))
12900
            {
12901
                JSON_ASSERT(reference_token[pos] == '~');
12902

12903
                // ~ must be followed by 0 or 1
12904
                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
12905
                                         (reference_token[pos + 1] != '0' &&
12906
                                          reference_token[pos + 1] != '1')))
12907
                {
12908
                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", BasicJsonType()));
12909
                }
12910
            }
12911

12912
            // finally, store the reference token
12913
            detail::unescape(reference_token);
12914
            result.push_back(reference_token);
12915
        }
12916

12917
        return result;
12918
    }
12919

12920
  private:
12921
    /*!
12922
    @param[in] reference_string  the reference string to the current value
12923
    @param[in] value             the value to consider
12924
    @param[in,out] result        the result object to insert values to
12925

12926
    @note Empty objects or arrays are flattened to `null`.
12927
    */
12928
    static void flatten(const std::string& reference_string,
12929
                        const BasicJsonType& value,
12930
                        BasicJsonType& result)
12931
    {
12932
        switch (value.type())
12933
        {
12934
            case detail::value_t::array:
12935
            {
12936
                if (value.m_value.array->empty())
12937
                {
12938
                    // flatten empty array as null
12939
                    result[reference_string] = nullptr;
12940
                }
12941
                else
12942
                {
12943
                    // iterate array and use index as reference string
12944
                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
12945
                    {
12946
                        flatten(reference_string + "/" + std::to_string(i),
12947
                                value.m_value.array->operator[](i), result);
12948
                    }
12949
                }
12950
                break;
12951
            }
12952

12953
            case detail::value_t::object:
12954
            {
12955
                if (value.m_value.object->empty())
12956
                {
12957
                    // flatten empty object as null
12958
                    result[reference_string] = nullptr;
12959
                }
12960
                else
12961
                {
12962
                    // iterate object and use keys as reference string
12963
                    for (const auto& element : *value.m_value.object)
12964
                    {
12965
                        flatten(reference_string + "/" + detail::escape(element.first), element.second, result);
12966
                    }
12967
                }
12968
                break;
12969
            }
12970

12971
            case detail::value_t::null:
12972
            case detail::value_t::string:
12973
            case detail::value_t::boolean:
12974
            case detail::value_t::number_integer:
12975
            case detail::value_t::number_unsigned:
12976
            case detail::value_t::number_float:
12977
            case detail::value_t::binary:
12978
            case detail::value_t::discarded:
12979
            default:
12980
            {
12981
                // add primitive value with its reference string
12982
                result[reference_string] = value;
12983
                break;
12984
            }
12985
        }
12986
    }
12987

12988
    /*!
12989
    @param[in] value  flattened JSON
12990

12991
    @return unflattened JSON
12992

12993
    @throw parse_error.109 if array index is not a number
12994
    @throw type_error.314  if value is not an object
12995
    @throw type_error.315  if object values are not primitive
12996
    @throw type_error.313  if value cannot be unflattened
12997
    */
12998
    static BasicJsonType
12999
    unflatten(const BasicJsonType& value)
13000
    {
13001
        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
13002
        {
13003
            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", value));
13004
        }
13005

13006
        BasicJsonType result;
13007

13008
        // iterate the JSON object values
13009
        for (const auto& element : *value.m_value.object)
13010
        {
13011
            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
13012
            {
13013
                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", element.second));
13014
            }
13015

13016
            // assign value to reference pointed to by JSON pointer; Note that if
13017
            // the JSON pointer is "" (i.e., points to the whole value), function
13018
            // get_and_create returns a reference to result itself. An assignment
13019
            // will then create a primitive value.
13020
            json_pointer(element.first).get_and_create(result) = element.second;
13021
        }
13022

13023
        return result;
13024
    }
13025

13026
    /*!
13027
    @brief compares two JSON pointers for equality
13028

13029
    @param[in] lhs  JSON pointer to compare
13030
    @param[in] rhs  JSON pointer to compare
13031
    @return whether @a lhs is equal to @a rhs
13032

13033
    @complexity Linear in the length of the JSON pointer
13034

13035
    @exceptionsafety No-throw guarantee: this function never throws exceptions.
13036
    */
13037
    friend bool operator==(json_pointer const& lhs,
13038
                           json_pointer const& rhs) noexcept
13039
    {
13040
        return lhs.reference_tokens == rhs.reference_tokens;
13041
    }
13042

13043
    /*!
13044
    @brief compares two JSON pointers for inequality
13045

13046
    @param[in] lhs  JSON pointer to compare
13047
    @param[in] rhs  JSON pointer to compare
13048
    @return whether @a lhs is not equal @a rhs
13049

13050
    @complexity Linear in the length of the JSON pointer
13051

13052
    @exceptionsafety No-throw guarantee: this function never throws exceptions.
13053
    */
13054
    friend bool operator!=(json_pointer const& lhs,
13055
                           json_pointer const& rhs) noexcept
13056
    {
13057
        return !(lhs == rhs);
13058
    }
13059

13060
    /// the reference tokens
13061
    std::vector<std::string> reference_tokens;
13062
};
13063
}  // namespace nlohmann
13064

13065
// #include <nlohmann/detail/json_ref.hpp>
13066

13067

13068
#include <initializer_list>
13069
#include <utility>
13070

13071
// #include <nlohmann/detail/meta/type_traits.hpp>
13072

13073

13074
namespace nlohmann
13075
{
13076
namespace detail
13077
{
13078
template<typename BasicJsonType>
13079
class json_ref
13080
{
13081
  public:
13082
    using value_type = BasicJsonType;
13083

13084
    json_ref(value_type&& value)
13085
        : owned_value(std::move(value))
13086
    {}
13087

13088
    json_ref(const value_type& value)
13089
        : value_ref(&value)
13090
    {}
13091

13092
    json_ref(std::initializer_list<json_ref> init)
13093
        : owned_value(init)
13094
    {}
13095

13096
    template <
13097
        class... Args,
13098
        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
13099
    json_ref(Args && ... args)
13100
        : owned_value(std::forward<Args>(args)...)
13101
    {}
13102

13103
    // class should be movable only
13104
    json_ref(json_ref&&) noexcept = default;
13105
    json_ref(const json_ref&) = delete;
13106
    json_ref& operator=(const json_ref&) = delete;
13107
    json_ref& operator=(json_ref&&) = delete;
13108
    ~json_ref() = default;
13109

13110
    value_type moved_or_copied() const
13111
    {
13112
        if (value_ref == nullptr)
13113
        {
13114
            return std::move(owned_value);
13115
        }
13116
        return *value_ref;
13117
    }
13118

13119
    value_type const& operator*() const
13120
    {
13121
        return value_ref ? *value_ref : owned_value;
13122
    }
13123

13124
    value_type const* operator->() const
13125
    {
13126
        return &** this;
13127
    }
13128

13129
  private:
13130
    mutable value_type owned_value = nullptr;
13131
    value_type const* value_ref = nullptr;
13132
};
13133
}  // namespace detail
13134
}  // namespace nlohmann
13135

13136
// #include <nlohmann/detail/macro_scope.hpp>
13137

13138
// #include <nlohmann/detail/string_escape.hpp>
13139

13140
// #include <nlohmann/detail/meta/cpp_future.hpp>
13141

13142
// #include <nlohmann/detail/meta/type_traits.hpp>
13143

13144
// #include <nlohmann/detail/output/binary_writer.hpp>
13145

13146

13147
#include <algorithm> // reverse
13148
#include <array> // array
13149
#include <cmath> // isnan, isinf
13150
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
13151
#include <cstring> // memcpy
13152
#include <limits> // numeric_limits
13153
#include <string> // string
13154
#include <utility> // move
13155

13156
// #include <nlohmann/detail/input/binary_reader.hpp>
13157

13158
// #include <nlohmann/detail/macro_scope.hpp>
13159

13160
// #include <nlohmann/detail/output/output_adapters.hpp>
13161

13162

13163
#include <algorithm> // copy
13164
#include <cstddef> // size_t
13165
#include <iterator> // back_inserter
13166
#include <memory> // shared_ptr, make_shared
13167
#include <string> // basic_string
13168
#include <vector> // vector
13169

13170
#ifndef JSON_NO_IO
13171
    #include <ios>      // streamsize
13172
    #include <ostream>  // basic_ostream
13173
#endif  // JSON_NO_IO
13174

13175
// #include <nlohmann/detail/macro_scope.hpp>
13176

13177

13178
namespace nlohmann
13179
{
13180
namespace detail
13181
{
13182
/// abstract output adapter interface
13183
template<typename CharType> struct output_adapter_protocol
13184
{
13185
    virtual void write_character(CharType c) = 0;
13186
    virtual void write_characters(const CharType* s, std::size_t length) = 0;
13187
    virtual ~output_adapter_protocol() = default;
13188

13189
    output_adapter_protocol() = default;
13190
    output_adapter_protocol(const output_adapter_protocol&) = default;
13191
    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
13192
    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
13193
    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
13194
};
13195

13196
/// a type to simplify interfaces
13197
template<typename CharType>
13198
using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
13199

13200
/// output adapter for byte vectors
13201
template<typename CharType, typename AllocatorType = std::allocator<CharType>>
13202
class output_vector_adapter : public output_adapter_protocol<CharType>
13203
{
13204
  public:
13205
    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
13206
        : v(vec)
13207
    {}
13208

13209
    void write_character(CharType c) override
13210
    {
13211
        v.push_back(c);
13212
    }
13213

13214
    JSON_HEDLEY_NON_NULL(2)
13215
    void write_characters(const CharType* s, std::size_t length) override
13216
    {
13217
        std::copy(s, s + length, std::back_inserter(v));
13218
    }
13219

13220
  private:
13221
    std::vector<CharType, AllocatorType>& v;
13222
};
13223

13224
#ifndef JSON_NO_IO
13225
/// output adapter for output streams
13226
template<typename CharType>
13227
class output_stream_adapter : public output_adapter_protocol<CharType>
13228
{
13229
  public:
13230
    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
13231
        : stream(s)
13232
    {}
13233

13234
    void write_character(CharType c) override
13235
    {
13236
        stream.put(c);
13237
    }
13238

13239
    JSON_HEDLEY_NON_NULL(2)
13240
    void write_characters(const CharType* s, std::size_t length) override
13241
    {
13242
        stream.write(s, static_cast<std::streamsize>(length));
13243
    }
13244

13245
  private:
13246
    std::basic_ostream<CharType>& stream;
13247
};
13248
#endif  // JSON_NO_IO
13249

13250
/// output adapter for basic_string
13251
template<typename CharType, typename StringType = std::basic_string<CharType>>
13252
class output_string_adapter : public output_adapter_protocol<CharType>
13253
{
13254
  public:
13255
    explicit output_string_adapter(StringType& s) noexcept
13256
        : str(s)
13257
    {}
13258

13259
    void write_character(CharType c) override
13260
    {
13261
        str.push_back(c);
13262
    }
13263

13264
    JSON_HEDLEY_NON_NULL(2)
13265
    void write_characters(const CharType* s, std::size_t length) override
13266
    {
13267
        str.append(s, length);
13268
    }
13269

13270
  private:
13271
    StringType& str;
13272
};
13273

13274
template<typename CharType, typename StringType = std::basic_string<CharType>>
13275
class output_adapter
13276
{
13277
  public:
13278
    template<typename AllocatorType = std::allocator<CharType>>
13279
    output_adapter(std::vector<CharType, AllocatorType>& vec)
13280
        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
13281

13282
#ifndef JSON_NO_IO
13283
    output_adapter(std::basic_ostream<CharType>& s)
13284
        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
13285
#endif  // JSON_NO_IO
13286

13287
    output_adapter(StringType& s)
13288
        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
13289

13290
    operator output_adapter_t<CharType>()
13291
    {
13292
        return oa;
13293
    }
13294

13295
  private:
13296
    output_adapter_t<CharType> oa = nullptr;
13297
};
13298
}  // namespace detail
13299
}  // namespace nlohmann
13300

13301

13302
namespace nlohmann
13303
{
13304
namespace detail
13305
{
13306
///////////////////
13307
// binary writer //
13308
///////////////////
13309

13310
/*!
13311
@brief serialization to CBOR and MessagePack values
13312
*/
13313
template<typename BasicJsonType, typename CharType>
13314
class binary_writer
13315
{
13316
    using string_t = typename BasicJsonType::string_t;
13317
    using binary_t = typename BasicJsonType::binary_t;
13318
    using number_float_t = typename BasicJsonType::number_float_t;
13319

13320
  public:
13321
    /*!
13322
    @brief create a binary writer
13323

13324
    @param[in] adapter  output adapter to write to
13325
    */
13326
    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
13327
    {
13328
        JSON_ASSERT(oa);
13329
    }
13330

13331
    /*!
13332
    @param[in] j  JSON value to serialize
13333
    @pre       j.type() == value_t::object
13334
    */
13335
    void write_bson(const BasicJsonType& j)
13336
    {
13337
        switch (j.type())
13338
        {
13339
            case value_t::object:
13340
            {
13341
                write_bson_object(*j.m_value.object);
13342
                break;
13343
            }
13344

13345
            case value_t::null:
13346
            case value_t::array:
13347
            case value_t::string:
13348
            case value_t::boolean:
13349
            case value_t::number_integer:
13350
            case value_t::number_unsigned:
13351
            case value_t::number_float:
13352
            case value_t::binary:
13353
            case value_t::discarded:
13354
            default:
13355
            {
13356
                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));
13357
            }
13358
        }
13359
    }
13360

13361
    /*!
13362
    @param[in] j  JSON value to serialize
13363
    */
13364
    void write_cbor(const BasicJsonType& j)
13365
    {
13366
        switch (j.type())
13367
        {
13368
            case value_t::null:
13369
            {
13370
                oa->write_character(to_char_type(0xF6));
13371
                break;
13372
            }
13373

13374
            case value_t::boolean:
13375
            {
13376
                oa->write_character(j.m_value.boolean
13377
                                    ? to_char_type(0xF5)
13378
                                    : to_char_type(0xF4));
13379
                break;
13380
            }
13381

13382
            case value_t::number_integer:
13383
            {
13384
                if (j.m_value.number_integer >= 0)
13385
                {
13386
                    // CBOR does not differentiate between positive signed
13387
                    // integers and unsigned integers. Therefore, we used the
13388
                    // code from the value_t::number_unsigned case here.
13389
                    if (j.m_value.number_integer <= 0x17)
13390
                    {
13391
                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13392
                    }
13393
                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
13394
                    {
13395
                        oa->write_character(to_char_type(0x18));
13396
                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13397
                    }
13398
                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
13399
                    {
13400
                        oa->write_character(to_char_type(0x19));
13401
                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13402
                    }
13403
                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
13404
                    {
13405
                        oa->write_character(to_char_type(0x1A));
13406
                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13407
                    }
13408
                    else
13409
                    {
13410
                        oa->write_character(to_char_type(0x1B));
13411
                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13412
                    }
13413
                }
13414
                else
13415
                {
13416
                    // The conversions below encode the sign in the first
13417
                    // byte, and the value is converted to a positive number.
13418
                    const auto positive_number = -1 - j.m_value.number_integer;
13419
                    if (j.m_value.number_integer >= -24)
13420
                    {
13421
                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
13422
                    }
13423
                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
13424
                    {
13425
                        oa->write_character(to_char_type(0x38));
13426
                        write_number(static_cast<std::uint8_t>(positive_number));
13427
                    }
13428
                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
13429
                    {
13430
                        oa->write_character(to_char_type(0x39));
13431
                        write_number(static_cast<std::uint16_t>(positive_number));
13432
                    }
13433
                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
13434
                    {
13435
                        oa->write_character(to_char_type(0x3A));
13436
                        write_number(static_cast<std::uint32_t>(positive_number));
13437
                    }
13438
                    else
13439
                    {
13440
                        oa->write_character(to_char_type(0x3B));
13441
                        write_number(static_cast<std::uint64_t>(positive_number));
13442
                    }
13443
                }
13444
                break;
13445
            }
13446

13447
            case value_t::number_unsigned:
13448
            {
13449
                if (j.m_value.number_unsigned <= 0x17)
13450
                {
13451
                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
13452
                }
13453
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13454
                {
13455
                    oa->write_character(to_char_type(0x18));
13456
                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
13457
                }
13458
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13459
                {
13460
                    oa->write_character(to_char_type(0x19));
13461
                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
13462
                }
13463
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13464
                {
13465
                    oa->write_character(to_char_type(0x1A));
13466
                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
13467
                }
13468
                else
13469
                {
13470
                    oa->write_character(to_char_type(0x1B));
13471
                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
13472
                }
13473
                break;
13474
            }
13475

13476
            case value_t::number_float:
13477
            {
13478
                if (std::isnan(j.m_value.number_float))
13479
                {
13480
                    // NaN is 0xf97e00 in CBOR
13481
                    oa->write_character(to_char_type(0xF9));
13482
                    oa->write_character(to_char_type(0x7E));
13483
                    oa->write_character(to_char_type(0x00));
13484
                }
13485
                else if (std::isinf(j.m_value.number_float))
13486
                {
13487
                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
13488
                    oa->write_character(to_char_type(0xf9));
13489
                    oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
13490
                    oa->write_character(to_char_type(0x00));
13491
                }
13492
                else
13493
                {
13494
                    write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
13495
                }
13496
                break;
13497
            }
13498

13499
            case value_t::string:
13500
            {
13501
                // step 1: write control byte and the string length
13502
                const auto N = j.m_value.string->size();
13503
                if (N <= 0x17)
13504
                {
13505
                    write_number(static_cast<std::uint8_t>(0x60 + N));
13506
                }
13507
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13508
                {
13509
                    oa->write_character(to_char_type(0x78));
13510
                    write_number(static_cast<std::uint8_t>(N));
13511
                }
13512
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13513
                {
13514
                    oa->write_character(to_char_type(0x79));
13515
                    write_number(static_cast<std::uint16_t>(N));
13516
                }
13517
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13518
                {
13519
                    oa->write_character(to_char_type(0x7A));
13520
                    write_number(static_cast<std::uint32_t>(N));
13521
                }
13522
                // LCOV_EXCL_START
13523
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13524
                {
13525
                    oa->write_character(to_char_type(0x7B));
13526
                    write_number(static_cast<std::uint64_t>(N));
13527
                }
13528
                // LCOV_EXCL_STOP
13529

13530
                // step 2: write the string
13531
                oa->write_characters(
13532
                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13533
                    j.m_value.string->size());
13534
                break;
13535
            }
13536

13537
            case value_t::array:
13538
            {
13539
                // step 1: write control byte and the array size
13540
                const auto N = j.m_value.array->size();
13541
                if (N <= 0x17)
13542
                {
13543
                    write_number(static_cast<std::uint8_t>(0x80 + N));
13544
                }
13545
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13546
                {
13547
                    oa->write_character(to_char_type(0x98));
13548
                    write_number(static_cast<std::uint8_t>(N));
13549
                }
13550
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13551
                {
13552
                    oa->write_character(to_char_type(0x99));
13553
                    write_number(static_cast<std::uint16_t>(N));
13554
                }
13555
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13556
                {
13557
                    oa->write_character(to_char_type(0x9A));
13558
                    write_number(static_cast<std::uint32_t>(N));
13559
                }
13560
                // LCOV_EXCL_START
13561
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13562
                {
13563
                    oa->write_character(to_char_type(0x9B));
13564
                    write_number(static_cast<std::uint64_t>(N));
13565
                }
13566
                // LCOV_EXCL_STOP
13567

13568
                // step 2: write each element
13569
                for (const auto& el : *j.m_value.array)
13570
                {
13571
                    write_cbor(el);
13572
                }
13573
                break;
13574
            }
13575

13576
            case value_t::binary:
13577
            {
13578
                if (j.m_value.binary->has_subtype())
13579
                {
13580
                    if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
13581
                    {
13582
                        write_number(static_cast<std::uint8_t>(0xd8));
13583
                        write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
13584
                    }
13585
                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
13586
                    {
13587
                        write_number(static_cast<std::uint8_t>(0xd9));
13588
                        write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
13589
                    }
13590
                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
13591
                    {
13592
                        write_number(static_cast<std::uint8_t>(0xda));
13593
                        write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
13594
                    }
13595
                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
13596
                    {
13597
                        write_number(static_cast<std::uint8_t>(0xdb));
13598
                        write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
13599
                    }
13600
                }
13601

13602
                // step 1: write control byte and the binary array size
13603
                const auto N = j.m_value.binary->size();
13604
                if (N <= 0x17)
13605
                {
13606
                    write_number(static_cast<std::uint8_t>(0x40 + N));
13607
                }
13608
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13609
                {
13610
                    oa->write_character(to_char_type(0x58));
13611
                    write_number(static_cast<std::uint8_t>(N));
13612
                }
13613
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13614
                {
13615
                    oa->write_character(to_char_type(0x59));
13616
                    write_number(static_cast<std::uint16_t>(N));
13617
                }
13618
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13619
                {
13620
                    oa->write_character(to_char_type(0x5A));
13621
                    write_number(static_cast<std::uint32_t>(N));
13622
                }
13623
                // LCOV_EXCL_START
13624
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13625
                {
13626
                    oa->write_character(to_char_type(0x5B));
13627
                    write_number(static_cast<std::uint64_t>(N));
13628
                }
13629
                // LCOV_EXCL_STOP
13630

13631
                // step 2: write each element
13632
                oa->write_characters(
13633
                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13634
                    N);
13635

13636
                break;
13637
            }
13638

13639
            case value_t::object:
13640
            {
13641
                // step 1: write control byte and the object size
13642
                const auto N = j.m_value.object->size();
13643
                if (N <= 0x17)
13644
                {
13645
                    write_number(static_cast<std::uint8_t>(0xA0 + N));
13646
                }
13647
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13648
                {
13649
                    oa->write_character(to_char_type(0xB8));
13650
                    write_number(static_cast<std::uint8_t>(N));
13651
                }
13652
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13653
                {
13654
                    oa->write_character(to_char_type(0xB9));
13655
                    write_number(static_cast<std::uint16_t>(N));
13656
                }
13657
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13658
                {
13659
                    oa->write_character(to_char_type(0xBA));
13660
                    write_number(static_cast<std::uint32_t>(N));
13661
                }
13662
                // LCOV_EXCL_START
13663
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13664
                {
13665
                    oa->write_character(to_char_type(0xBB));
13666
                    write_number(static_cast<std::uint64_t>(N));
13667
                }
13668
                // LCOV_EXCL_STOP
13669

13670
                // step 2: write each element
13671
                for (const auto& el : *j.m_value.object)
13672
                {
13673
                    write_cbor(el.first);
13674
                    write_cbor(el.second);
13675
                }
13676
                break;
13677
            }
13678

13679
            case value_t::discarded:
13680
            default:
13681
                break;
13682
        }
13683
    }
13684

13685
    /*!
13686
    @param[in] j  JSON value to serialize
13687
    */
13688
    void write_msgpack(const BasicJsonType& j)
13689
    {
13690
        switch (j.type())
13691
        {
13692
            case value_t::null: // nil
13693
            {
13694
                oa->write_character(to_char_type(0xC0));
13695
                break;
13696
            }
13697

13698
            case value_t::boolean: // true and false
13699
            {
13700
                oa->write_character(j.m_value.boolean
13701
                                    ? to_char_type(0xC3)
13702
                                    : to_char_type(0xC2));
13703
                break;
13704
            }
13705

13706
            case value_t::number_integer:
13707
            {
13708
                if (j.m_value.number_integer >= 0)
13709
                {
13710
                    // MessagePack does not differentiate between positive
13711
                    // signed integers and unsigned integers. Therefore, we used
13712
                    // the code from the value_t::number_unsigned case here.
13713
                    if (j.m_value.number_unsigned < 128)
13714
                    {
13715
                        // positive fixnum
13716
                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13717
                    }
13718
                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13719
                    {
13720
                        // uint 8
13721
                        oa->write_character(to_char_type(0xCC));
13722
                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13723
                    }
13724
                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13725
                    {
13726
                        // uint 16
13727
                        oa->write_character(to_char_type(0xCD));
13728
                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13729
                    }
13730
                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13731
                    {
13732
                        // uint 32
13733
                        oa->write_character(to_char_type(0xCE));
13734
                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13735
                    }
13736
                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13737
                    {
13738
                        // uint 64
13739
                        oa->write_character(to_char_type(0xCF));
13740
                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13741
                    }
13742
                }
13743
                else
13744
                {
13745
                    if (j.m_value.number_integer >= -32)
13746
                    {
13747
                        // negative fixnum
13748
                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13749
                    }
13750
                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
13751
                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
13752
                    {
13753
                        // int 8
13754
                        oa->write_character(to_char_type(0xD0));
13755
                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13756
                    }
13757
                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
13758
                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
13759
                    {
13760
                        // int 16
13761
                        oa->write_character(to_char_type(0xD1));
13762
                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));
13763
                    }
13764
                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
13765
                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
13766
                    {
13767
                        // int 32
13768
                        oa->write_character(to_char_type(0xD2));
13769
                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));
13770
                    }
13771
                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
13772
                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
13773
                    {
13774
                        // int 64
13775
                        oa->write_character(to_char_type(0xD3));
13776
                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));
13777
                    }
13778
                }
13779
                break;
13780
            }
13781

13782
            case value_t::number_unsigned:
13783
            {
13784
                if (j.m_value.number_unsigned < 128)
13785
                {
13786
                    // positive fixnum
13787
                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13788
                }
13789
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13790
                {
13791
                    // uint 8
13792
                    oa->write_character(to_char_type(0xCC));
13793
                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13794
                }
13795
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13796
                {
13797
                    // uint 16
13798
                    oa->write_character(to_char_type(0xCD));
13799
                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13800
                }
13801
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13802
                {
13803
                    // uint 32
13804
                    oa->write_character(to_char_type(0xCE));
13805
                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13806
                }
13807
                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13808
                {
13809
                    // uint 64
13810
                    oa->write_character(to_char_type(0xCF));
13811
                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13812
                }
13813
                break;
13814
            }
13815

13816
            case value_t::number_float:
13817
            {
13818
                write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
13819
                break;
13820
            }
13821

13822
            case value_t::string:
13823
            {
13824
                // step 1: write control byte and the string length
13825
                const auto N = j.m_value.string->size();
13826
                if (N <= 31)
13827
                {
13828
                    // fixstr
13829
                    write_number(static_cast<std::uint8_t>(0xA0 | N));
13830
                }
13831
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13832
                {
13833
                    // str 8
13834
                    oa->write_character(to_char_type(0xD9));
13835
                    write_number(static_cast<std::uint8_t>(N));
13836
                }
13837
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13838
                {
13839
                    // str 16
13840
                    oa->write_character(to_char_type(0xDA));
13841
                    write_number(static_cast<std::uint16_t>(N));
13842
                }
13843
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13844
                {
13845
                    // str 32
13846
                    oa->write_character(to_char_type(0xDB));
13847
                    write_number(static_cast<std::uint32_t>(N));
13848
                }
13849

13850
                // step 2: write the string
13851
                oa->write_characters(
13852
                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13853
                    j.m_value.string->size());
13854
                break;
13855
            }
13856

13857
            case value_t::array:
13858
            {
13859
                // step 1: write control byte and the array size
13860
                const auto N = j.m_value.array->size();
13861
                if (N <= 15)
13862
                {
13863
                    // fixarray
13864
                    write_number(static_cast<std::uint8_t>(0x90 | N));
13865
                }
13866
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13867
                {
13868
                    // array 16
13869
                    oa->write_character(to_char_type(0xDC));
13870
                    write_number(static_cast<std::uint16_t>(N));
13871
                }
13872
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13873
                {
13874
                    // array 32
13875
                    oa->write_character(to_char_type(0xDD));
13876
                    write_number(static_cast<std::uint32_t>(N));
13877
                }
13878

13879
                // step 2: write each element
13880
                for (const auto& el : *j.m_value.array)
13881
                {
13882
                    write_msgpack(el);
13883
                }
13884
                break;
13885
            }
13886

13887
            case value_t::binary:
13888
            {
13889
                // step 0: determine if the binary type has a set subtype to
13890
                // determine whether or not to use the ext or fixext types
13891
                const bool use_ext = j.m_value.binary->has_subtype();
13892

13893
                // step 1: write control byte and the byte string length
13894
                const auto N = j.m_value.binary->size();
13895
                if (N <= (std::numeric_limits<std::uint8_t>::max)())
13896
                {
13897
                    std::uint8_t output_type{};
13898
                    bool fixed = true;
13899
                    if (use_ext)
13900
                    {
13901
                        switch (N)
13902
                        {
13903
                            case 1:
13904
                                output_type = 0xD4; // fixext 1
13905
                                break;
13906
                            case 2:
13907
                                output_type = 0xD5; // fixext 2
13908
                                break;
13909
                            case 4:
13910
                                output_type = 0xD6; // fixext 4
13911
                                break;
13912
                            case 8:
13913
                                output_type = 0xD7; // fixext 8
13914
                                break;
13915
                            case 16:
13916
                                output_type = 0xD8; // fixext 16
13917
                                break;
13918
                            default:
13919
                                output_type = 0xC7; // ext 8
13920
                                fixed = false;
13921
                                break;
13922
                        }
13923

13924
                    }
13925
                    else
13926
                    {
13927
                        output_type = 0xC4; // bin 8
13928
                        fixed = false;
13929
                    }
13930

13931
                    oa->write_character(to_char_type(output_type));
13932
                    if (!fixed)
13933
                    {
13934
                        write_number(static_cast<std::uint8_t>(N));
13935
                    }
13936
                }
13937
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13938
                {
13939
                    std::uint8_t output_type = use_ext
13940
                                               ? 0xC8 // ext 16
13941
                                               : 0xC5; // bin 16
13942

13943
                    oa->write_character(to_char_type(output_type));
13944
                    write_number(static_cast<std::uint16_t>(N));
13945
                }
13946
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13947
                {
13948
                    std::uint8_t output_type = use_ext
13949
                                               ? 0xC9 // ext 32
13950
                                               : 0xC6; // bin 32
13951

13952
                    oa->write_character(to_char_type(output_type));
13953
                    write_number(static_cast<std::uint32_t>(N));
13954
                }
13955

13956
                // step 1.5: if this is an ext type, write the subtype
13957
                if (use_ext)
13958
                {
13959
                    write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
13960
                }
13961

13962
                // step 2: write the byte string
13963
                oa->write_characters(
13964
                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13965
                    N);
13966

13967
                break;
13968
            }
13969

13970
            case value_t::object:
13971
            {
13972
                // step 1: write control byte and the object size
13973
                const auto N = j.m_value.object->size();
13974
                if (N <= 15)
13975
                {
13976
                    // fixmap
13977
                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
13978
                }
13979
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13980
                {
13981
                    // map 16
13982
                    oa->write_character(to_char_type(0xDE));
13983
                    write_number(static_cast<std::uint16_t>(N));
13984
                }
13985
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13986
                {
13987
                    // map 32
13988
                    oa->write_character(to_char_type(0xDF));
13989
                    write_number(static_cast<std::uint32_t>(N));
13990
                }
13991

13992
                // step 2: write each element
13993
                for (const auto& el : *j.m_value.object)
13994
                {
13995
                    write_msgpack(el.first);
13996
                    write_msgpack(el.second);
13997
                }
13998
                break;
13999
            }
14000

14001
            case value_t::discarded:
14002
            default:
14003
                break;
14004
        }
14005
    }
14006

14007
    /*!
14008
    @param[in] j  JSON value to serialize
14009
    @param[in] use_count   whether to use '#' prefixes (optimized format)
14010
    @param[in] use_type    whether to use '$' prefixes (optimized format)
14011
    @param[in] add_prefix  whether prefixes need to be used for this value
14012
    */
14013
    void write_ubjson(const BasicJsonType& j, const bool use_count,
14014
                      const bool use_type, const bool add_prefix = true)
14015
    {
14016
        switch (j.type())
14017
        {
14018
            case value_t::null:
14019
            {
14020
                if (add_prefix)
14021
                {
14022
                    oa->write_character(to_char_type('Z'));
14023
                }
14024
                break;
14025
            }
14026

14027
            case value_t::boolean:
14028
            {
14029
                if (add_prefix)
14030
                {
14031
                    oa->write_character(j.m_value.boolean
14032
                                        ? to_char_type('T')
14033
                                        : to_char_type('F'));
14034
                }
14035
                break;
14036
            }
14037

14038
            case value_t::number_integer:
14039
            {
14040
                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
14041
                break;
14042
            }
14043

14044
            case value_t::number_unsigned:
14045
            {
14046
                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
14047
                break;
14048
            }
14049

14050
            case value_t::number_float:
14051
            {
14052
                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
14053
                break;
14054
            }
14055

14056
            case value_t::string:
14057
            {
14058
                if (add_prefix)
14059
                {
14060
                    oa->write_character(to_char_type('S'));
14061
                }
14062
                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
14063
                oa->write_characters(
14064
                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
14065
                    j.m_value.string->size());
14066
                break;
14067
            }
14068

14069
            case value_t::array:
14070
            {
14071
                if (add_prefix)
14072
                {
14073
                    oa->write_character(to_char_type('['));
14074
                }
14075

14076
                bool prefix_required = true;
14077
                if (use_type && !j.m_value.array->empty())
14078
                {
14079
                    JSON_ASSERT(use_count);
14080
                    const CharType first_prefix = ubjson_prefix(j.front());
14081
                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
14082
                                                         [this, first_prefix](const BasicJsonType & v)
14083
                    {
14084
                        return ubjson_prefix(v) == first_prefix;
14085
                    });
14086

14087
                    if (same_prefix)
14088
                    {
14089
                        prefix_required = false;
14090
                        oa->write_character(to_char_type('$'));
14091
                        oa->write_character(first_prefix);
14092
                    }
14093
                }
14094

14095
                if (use_count)
14096
                {
14097
                    oa->write_character(to_char_type('#'));
14098
                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
14099
                }
14100

14101
                for (const auto& el : *j.m_value.array)
14102
                {
14103
                    write_ubjson(el, use_count, use_type, prefix_required);
14104
                }
14105

14106
                if (!use_count)
14107
                {
14108
                    oa->write_character(to_char_type(']'));
14109
                }
14110

14111
                break;
14112
            }
14113

14114
            case value_t::binary:
14115
            {
14116
                if (add_prefix)
14117
                {
14118
                    oa->write_character(to_char_type('['));
14119
                }
14120

14121
                if (use_type && !j.m_value.binary->empty())
14122
                {
14123
                    JSON_ASSERT(use_count);
14124
                    oa->write_character(to_char_type('$'));
14125
                    oa->write_character('U');
14126
                }
14127

14128
                if (use_count)
14129
                {
14130
                    oa->write_character(to_char_type('#'));
14131
                    write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
14132
                }
14133

14134
                if (use_type)
14135
                {
14136
                    oa->write_characters(
14137
                        reinterpret_cast<const CharType*>(j.m_value.binary->data()),
14138
                        j.m_value.binary->size());
14139
                }
14140
                else
14141
                {
14142
                    for (size_t i = 0; i < j.m_value.binary->size(); ++i)
14143
                    {
14144
                        oa->write_character(to_char_type('U'));
14145
                        oa->write_character(j.m_value.binary->data()[i]);
14146
                    }
14147
                }
14148

14149
                if (!use_count)
14150
                {
14151
                    oa->write_character(to_char_type(']'));
14152
                }
14153

14154
                break;
14155
            }
14156

14157
            case value_t::object:
14158
            {
14159
                if (add_prefix)
14160
                {
14161
                    oa->write_character(to_char_type('{'));
14162
                }
14163

14164
                bool prefix_required = true;
14165
                if (use_type && !j.m_value.object->empty())
14166
                {
14167
                    JSON_ASSERT(use_count);
14168
                    const CharType first_prefix = ubjson_prefix(j.front());
14169
                    const bool same_prefix = std::all_of(j.begin(), j.end(),
14170
                                                         [this, first_prefix](const BasicJsonType & v)
14171
                    {
14172
                        return ubjson_prefix(v) == first_prefix;
14173
                    });
14174

14175
                    if (same_prefix)
14176
                    {
14177
                        prefix_required = false;
14178
                        oa->write_character(to_char_type('$'));
14179
                        oa->write_character(first_prefix);
14180
                    }
14181
                }
14182

14183
                if (use_count)
14184
                {
14185
                    oa->write_character(to_char_type('#'));
14186
                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
14187
                }
14188

14189
                for (const auto& el : *j.m_value.object)
14190
                {
14191
                    write_number_with_ubjson_prefix(el.first.size(), true);
14192
                    oa->write_characters(
14193
                        reinterpret_cast<const CharType*>(el.first.c_str()),
14194
                        el.first.size());
14195
                    write_ubjson(el.second, use_count, use_type, prefix_required);
14196
                }
14197

14198
                if (!use_count)
14199
                {
14200
                    oa->write_character(to_char_type('}'));
14201
                }
14202

14203
                break;
14204
            }
14205

14206
            case value_t::discarded:
14207
            default:
14208
                break;
14209
        }
14210
    }
14211

14212
  private:
14213
    //////////
14214
    // BSON //
14215
    //////////
14216

14217
    /*!
14218
    @return The size of a BSON document entry header, including the id marker
14219
            and the entry name size (and its null-terminator).
14220
    */
14221
    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
14222
    {
14223
        const auto it = name.find(static_cast<typename string_t::value_type>(0));
14224
        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
14225
        {
14226
            JSON_THROW(out_of_range::create(409, "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")", j));
14227
            static_cast<void>(j);
14228
        }
14229

14230
        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
14231
    }
14232

14233
    /*!
14234
    @brief Writes the given @a element_type and @a name to the output adapter
14235
    */
14236
    void write_bson_entry_header(const string_t& name,
14237
                                 const std::uint8_t element_type)
14238
    {
14239
        oa->write_character(to_char_type(element_type)); // boolean
14240
        oa->write_characters(
14241
            reinterpret_cast<const CharType*>(name.c_str()),
14242
            name.size() + 1u);
14243
    }
14244

14245
    /*!
14246
    @brief Writes a BSON element with key @a name and boolean value @a value
14247
    */
14248
    void write_bson_boolean(const string_t& name,
14249
                            const bool value)
14250
    {
14251
        write_bson_entry_header(name, 0x08);
14252
        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
14253
    }
14254

14255
    /*!
14256
    @brief Writes a BSON element with key @a name and double value @a value
14257
    */
14258
    void write_bson_double(const string_t& name,
14259
                           const double value)
14260
    {
14261
        write_bson_entry_header(name, 0x01);
14262
        write_number<double, true>(value);
14263
    }
14264

14265
    /*!
14266
    @return The size of the BSON-encoded string in @a value
14267
    */
14268
    static std::size_t calc_bson_string_size(const string_t& value)
14269
    {
14270
        return sizeof(std::int32_t) + value.size() + 1ul;
14271
    }
14272

14273
    /*!
14274
    @brief Writes a BSON element with key @a name and string value @a value
14275
    */
14276
    void write_bson_string(const string_t& name,
14277
                           const string_t& value)
14278
    {
14279
        write_bson_entry_header(name, 0x02);
14280

14281
        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
14282
        oa->write_characters(
14283
            reinterpret_cast<const CharType*>(value.c_str()),
14284
            value.size() + 1);
14285
    }
14286

14287
    /*!
14288
    @brief Writes a BSON element with key @a name and null value
14289
    */
14290
    void write_bson_null(const string_t& name)
14291
    {
14292
        write_bson_entry_header(name, 0x0A);
14293
    }
14294

14295
    /*!
14296
    @return The size of the BSON-encoded integer @a value
14297
    */
14298
    static std::size_t calc_bson_integer_size(const std::int64_t value)
14299
    {
14300
        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
14301
               ? sizeof(std::int32_t)
14302
               : sizeof(std::int64_t);
14303
    }
14304

14305
    /*!
14306
    @brief Writes a BSON element with key @a name and integer @a value
14307
    */
14308
    void write_bson_integer(const string_t& name,
14309
                            const std::int64_t value)
14310
    {
14311
        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
14312
        {
14313
            write_bson_entry_header(name, 0x10); // int32
14314
            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
14315
        }
14316
        else
14317
        {
14318
            write_bson_entry_header(name, 0x12); // int64
14319
            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
14320
        }
14321
    }
14322

14323
    /*!
14324
    @return The size of the BSON-encoded unsigned integer in @a j
14325
    */
14326
    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
14327
    {
14328
        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14329
               ? sizeof(std::int32_t)
14330
               : sizeof(std::int64_t);
14331
    }
14332

14333
    /*!
14334
    @brief Writes a BSON element with key @a name and unsigned @a value
14335
    */
14336
    void write_bson_unsigned(const string_t& name,
14337
                             const BasicJsonType& j)
14338
    {
14339
        if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14340
        {
14341
            write_bson_entry_header(name, 0x10 /* int32 */);
14342
            write_number<std::int32_t, true>(static_cast<std::int32_t>(j.m_value.number_unsigned));
14343
        }
14344
        else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14345
        {
14346
            write_bson_entry_header(name, 0x12 /* int64 */);
14347
            write_number<std::int64_t, true>(static_cast<std::int64_t>(j.m_value.number_unsigned));
14348
        }
14349
        else
14350
        {
14351
            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(j.m_value.number_unsigned) + " cannot be represented by BSON as it does not fit int64", j));
14352
        }
14353
    }
14354

14355
    /*!
14356
    @brief Writes a BSON element with key @a name and object @a value
14357
    */
14358
    void write_bson_object_entry(const string_t& name,
14359
                                 const typename BasicJsonType::object_t& value)
14360
    {
14361
        write_bson_entry_header(name, 0x03); // object
14362
        write_bson_object(value);
14363
    }
14364

14365
    /*!
14366
    @return The size of the BSON-encoded array @a value
14367
    */
14368
    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
14369
    {
14370
        std::size_t array_index = 0ul;
14371

14372
        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
14373
        {
14374
            return result + calc_bson_element_size(std::to_string(array_index++), el);
14375
        });
14376

14377
        return sizeof(std::int32_t) + embedded_document_size + 1ul;
14378
    }
14379

14380
    /*!
14381
    @return The size of the BSON-encoded binary array @a value
14382
    */
14383
    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
14384
    {
14385
        return sizeof(std::int32_t) + value.size() + 1ul;
14386
    }
14387

14388
    /*!
14389
    @brief Writes a BSON element with key @a name and array @a value
14390
    */
14391
    void write_bson_array(const string_t& name,
14392
                          const typename BasicJsonType::array_t& value)
14393
    {
14394
        write_bson_entry_header(name, 0x04); // array
14395
        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
14396

14397
        std::size_t array_index = 0ul;
14398

14399
        for (const auto& el : value)
14400
        {
14401
            write_bson_element(std::to_string(array_index++), el);
14402
        }
14403

14404
        oa->write_character(to_char_type(0x00));
14405
    }
14406

14407
    /*!
14408
    @brief Writes a BSON element with key @a name and binary value @a value
14409
    */
14410
    void write_bson_binary(const string_t& name,
14411
                           const binary_t& value)
14412
    {
14413
        write_bson_entry_header(name, 0x05);
14414

14415
        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
14416
        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
14417

14418
        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
14419
    }
14420

14421
    /*!
14422
    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
14423
    @return The calculated size for the BSON document entry for @a j with the given @a name.
14424
    */
14425
    static std::size_t calc_bson_element_size(const string_t& name,
14426
            const BasicJsonType& j)
14427
    {
14428
        const auto header_size = calc_bson_entry_header_size(name, j);
14429
        switch (j.type())
14430
        {
14431
            case value_t::object:
14432
                return header_size + calc_bson_object_size(*j.m_value.object);
14433

14434
            case value_t::array:
14435
                return header_size + calc_bson_array_size(*j.m_value.array);
14436

14437
            case value_t::binary:
14438
                return header_size + calc_bson_binary_size(*j.m_value.binary);
14439

14440
            case value_t::boolean:
14441
                return header_size + 1ul;
14442

14443
            case value_t::number_float:
14444
                return header_size + 8ul;
14445

14446
            case value_t::number_integer:
14447
                return header_size + calc_bson_integer_size(j.m_value.number_integer);
14448

14449
            case value_t::number_unsigned:
14450
                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
14451

14452
            case value_t::string:
14453
                return header_size + calc_bson_string_size(*j.m_value.string);
14454

14455
            case value_t::null:
14456
                return header_size + 0ul;
14457

14458
            // LCOV_EXCL_START
14459
            case value_t::discarded:
14460
            default:
14461
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
14462
                return 0ul;
14463
                // LCOV_EXCL_STOP
14464
        }
14465
    }
14466

14467
    /*!
14468
    @brief Serializes the JSON value @a j to BSON and associates it with the
14469
           key @a name.
14470
    @param name The name to associate with the JSON entity @a j within the
14471
                current BSON document
14472
    */
14473
    void write_bson_element(const string_t& name,
14474
                            const BasicJsonType& j)
14475
    {
14476
        switch (j.type())
14477
        {
14478
            case value_t::object:
14479
                return write_bson_object_entry(name, *j.m_value.object);
14480

14481
            case value_t::array:
14482
                return write_bson_array(name, *j.m_value.array);
14483

14484
            case value_t::binary:
14485
                return write_bson_binary(name, *j.m_value.binary);
14486

14487
            case value_t::boolean:
14488
                return write_bson_boolean(name, j.m_value.boolean);
14489

14490
            case value_t::number_float:
14491
                return write_bson_double(name, j.m_value.number_float);
14492

14493
            case value_t::number_integer:
14494
                return write_bson_integer(name, j.m_value.number_integer);
14495

14496
            case value_t::number_unsigned:
14497
                return write_bson_unsigned(name, j);
14498

14499
            case value_t::string:
14500
                return write_bson_string(name, *j.m_value.string);
14501

14502
            case value_t::null:
14503
                return write_bson_null(name);
14504

14505
            // LCOV_EXCL_START
14506
            case value_t::discarded:
14507
            default:
14508
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
14509
                return;
14510
                // LCOV_EXCL_STOP
14511
        }
14512
    }
14513

14514
    /*!
14515
    @brief Calculates the size of the BSON serialization of the given
14516
           JSON-object @a j.
14517
    @param[in] value  JSON value to serialize
14518
    @pre       value.type() == value_t::object
14519
    */
14520
    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
14521
    {
14522
        std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
14523
                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
14524
        {
14525
            return result += calc_bson_element_size(el.first, el.second);
14526
        });
14527

14528
        return sizeof(std::int32_t) + document_size + 1ul;
14529
    }
14530

14531
    /*!
14532
    @param[in] value  JSON value to serialize
14533
    @pre       value.type() == value_t::object
14534
    */
14535
    void write_bson_object(const typename BasicJsonType::object_t& value)
14536
    {
14537
        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
14538

14539
        for (const auto& el : value)
14540
        {
14541
            write_bson_element(el.first, el.second);
14542
        }
14543

14544
        oa->write_character(to_char_type(0x00));
14545
    }
14546

14547
    //////////
14548
    // CBOR //
14549
    //////////
14550

14551
    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
14552
    {
14553
        return to_char_type(0xFA);  // Single-Precision Float
14554
    }
14555

14556
    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
14557
    {
14558
        return to_char_type(0xFB);  // Double-Precision Float
14559
    }
14560

14561
    /////////////
14562
    // MsgPack //
14563
    /////////////
14564

14565
    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
14566
    {
14567
        return to_char_type(0xCA);  // float 32
14568
    }
14569

14570
    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
14571
    {
14572
        return to_char_type(0xCB);  // float 64
14573
    }
14574

14575
    ////////////
14576
    // UBJSON //
14577
    ////////////
14578

14579
    // UBJSON: write number (floating point)
14580
    template<typename NumberType, typename std::enable_if<
14581
                 std::is_floating_point<NumberType>::value, int>::type = 0>
14582
    void write_number_with_ubjson_prefix(const NumberType n,
14583
                                         const bool add_prefix)
14584
    {
14585
        if (add_prefix)
14586
        {
14587
            oa->write_character(get_ubjson_float_prefix(n));
14588
        }
14589
        write_number(n);
14590
    }
14591

14592
    // UBJSON: write number (unsigned integer)
14593
    template<typename NumberType, typename std::enable_if<
14594
                 std::is_unsigned<NumberType>::value, int>::type = 0>
14595
    void write_number_with_ubjson_prefix(const NumberType n,
14596
                                         const bool add_prefix)
14597
    {
14598
        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14599
        {
14600
            if (add_prefix)
14601
            {
14602
                oa->write_character(to_char_type('i'));  // int8
14603
            }
14604
            write_number(static_cast<std::uint8_t>(n));
14605
        }
14606
        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14607
        {
14608
            if (add_prefix)
14609
            {
14610
                oa->write_character(to_char_type('U'));  // uint8
14611
            }
14612
            write_number(static_cast<std::uint8_t>(n));
14613
        }
14614
        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14615
        {
14616
            if (add_prefix)
14617
            {
14618
                oa->write_character(to_char_type('I'));  // int16
14619
            }
14620
            write_number(static_cast<std::int16_t>(n));
14621
        }
14622
        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14623
        {
14624
            if (add_prefix)
14625
            {
14626
                oa->write_character(to_char_type('l'));  // int32
14627
            }
14628
            write_number(static_cast<std::int32_t>(n));
14629
        }
14630
        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14631
        {
14632
            if (add_prefix)
14633
            {
14634
                oa->write_character(to_char_type('L'));  // int64
14635
            }
14636
            write_number(static_cast<std::int64_t>(n));
14637
        }
14638
        else
14639
        {
14640
            if (add_prefix)
14641
            {
14642
                oa->write_character(to_char_type('H'));  // high-precision number
14643
            }
14644

14645
            const auto number = BasicJsonType(n).dump();
14646
            write_number_with_ubjson_prefix(number.size(), true);
14647
            for (std::size_t i = 0; i < number.size(); ++i)
14648
            {
14649
                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14650
            }
14651
        }
14652
    }
14653

14654
    // UBJSON: write number (signed integer)
14655
    template < typename NumberType, typename std::enable_if <
14656
                   std::is_signed<NumberType>::value&&
14657
                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
14658
    void write_number_with_ubjson_prefix(const NumberType n,
14659
                                         const bool add_prefix)
14660
    {
14661
        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14662
        {
14663
            if (add_prefix)
14664
            {
14665
                oa->write_character(to_char_type('i'));  // int8
14666
            }
14667
            write_number(static_cast<std::int8_t>(n));
14668
        }
14669
        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
14670
        {
14671
            if (add_prefix)
14672
            {
14673
                oa->write_character(to_char_type('U'));  // uint8
14674
            }
14675
            write_number(static_cast<std::uint8_t>(n));
14676
        }
14677
        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14678
        {
14679
            if (add_prefix)
14680
            {
14681
                oa->write_character(to_char_type('I'));  // int16
14682
            }
14683
            write_number(static_cast<std::int16_t>(n));
14684
        }
14685
        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14686
        {
14687
            if (add_prefix)
14688
            {
14689
                oa->write_character(to_char_type('l'));  // int32
14690
            }
14691
            write_number(static_cast<std::int32_t>(n));
14692
        }
14693
        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14694
        {
14695
            if (add_prefix)
14696
            {
14697
                oa->write_character(to_char_type('L'));  // int64
14698
            }
14699
            write_number(static_cast<std::int64_t>(n));
14700
        }
14701
        // LCOV_EXCL_START
14702
        else
14703
        {
14704
            if (add_prefix)
14705
            {
14706
                oa->write_character(to_char_type('H'));  // high-precision number
14707
            }
14708

14709
            const auto number = BasicJsonType(n).dump();
14710
            write_number_with_ubjson_prefix(number.size(), true);
14711
            for (std::size_t i = 0; i < number.size(); ++i)
14712
            {
14713
                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14714
            }
14715
        }
14716
        // LCOV_EXCL_STOP
14717
    }
14718

14719
    /*!
14720
    @brief determine the type prefix of container values
14721
    */
14722
    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
14723
    {
14724
        switch (j.type())
14725
        {
14726
            case value_t::null:
14727
                return 'Z';
14728

14729
            case value_t::boolean:
14730
                return j.m_value.boolean ? 'T' : 'F';
14731

14732
            case value_t::number_integer:
14733
            {
14734
                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
14735
                {
14736
                    return 'i';
14737
                }
14738
                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
14739
                {
14740
                    return 'U';
14741
                }
14742
                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
14743
                {
14744
                    return 'I';
14745
                }
14746
                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
14747
                {
14748
                    return 'l';
14749
                }
14750
                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
14751
                {
14752
                    return 'L';
14753
                }
14754
                // anything else is treated as high-precision number
14755
                return 'H'; // LCOV_EXCL_LINE
14756
            }
14757

14758
            case value_t::number_unsigned:
14759
            {
14760
                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14761
                {
14762
                    return 'i';
14763
                }
14764
                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
14765
                {
14766
                    return 'U';
14767
                }
14768
                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14769
                {
14770
                    return 'I';
14771
                }
14772
                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14773
                {
14774
                    return 'l';
14775
                }
14776
                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14777
                {
14778
                    return 'L';
14779
                }
14780
                // anything else is treated as high-precision number
14781
                return 'H'; // LCOV_EXCL_LINE
14782
            }
14783

14784
            case value_t::number_float:
14785
                return get_ubjson_float_prefix(j.m_value.number_float);
14786

14787
            case value_t::string:
14788
                return 'S';
14789

14790
            case value_t::array: // fallthrough
14791
            case value_t::binary:
14792
                return '[';
14793

14794
            case value_t::object:
14795
                return '{';
14796

14797
            case value_t::discarded:
14798
            default:  // discarded values
14799
                return 'N';
14800
        }
14801
    }
14802

14803
    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
14804
    {
14805
        return 'd';  // float 32
14806
    }
14807

14808
    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
14809
    {
14810
        return 'D';  // float 64
14811
    }
14812

14813
    ///////////////////////
14814
    // Utility functions //
14815
    ///////////////////////
14816

14817
    /*
14818
    @brief write a number to output input
14819
    @param[in] n number of type @a NumberType
14820
    @tparam NumberType the type of the number
14821
    @tparam OutputIsLittleEndian Set to true if output data is
14822
                                 required to be little endian
14823

14824
    @note This function needs to respect the system's endianness, because bytes
14825
          in CBOR, MessagePack, and UBJSON are stored in network order (big
14826
          endian) and therefore need reordering on little endian systems.
14827
    */
14828
    template<typename NumberType, bool OutputIsLittleEndian = false>
14829
    void write_number(const NumberType n)
14830
    {
14831
        // step 1: write number to array of length NumberType
14832
        std::array<CharType, sizeof(NumberType)> vec{};
14833
        std::memcpy(vec.data(), &n, sizeof(NumberType));
14834

14835
        // step 2: write array to output (with possible reordering)
14836
        if (is_little_endian != OutputIsLittleEndian)
14837
        {
14838
            // reverse byte order prior to conversion if necessary
14839
            std::reverse(vec.begin(), vec.end());
14840
        }
14841

14842
        oa->write_characters(vec.data(), sizeof(NumberType));
14843
    }
14844

14845
    void write_compact_float(const number_float_t n, detail::input_format_t format)
14846
    {
14847
#ifdef __GNUC__
14848
#pragma GCC diagnostic push
14849
#pragma GCC diagnostic ignored "-Wfloat-equal"
14850
#endif
14851
        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
14852
                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
14853
                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
14854
        {
14855
            oa->write_character(format == detail::input_format_t::cbor
14856
                                ? get_cbor_float_prefix(static_cast<float>(n))
14857
                                : get_msgpack_float_prefix(static_cast<float>(n)));
14858
            write_number(static_cast<float>(n));
14859
        }
14860
        else
14861
        {
14862
            oa->write_character(format == detail::input_format_t::cbor
14863
                                ? get_cbor_float_prefix(n)
14864
                                : get_msgpack_float_prefix(n));
14865
            write_number(n);
14866
        }
14867
#ifdef __GNUC__
14868
#pragma GCC diagnostic pop
14869
#endif
14870
    }
14871

14872
  public:
14873
    // The following to_char_type functions are implement the conversion
14874
    // between uint8_t and CharType. In case CharType is not unsigned,
14875
    // such a conversion is required to allow values greater than 128.
14876
    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
14877
    template < typename C = CharType,
14878
               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
14879
    static constexpr CharType to_char_type(std::uint8_t x) noexcept
14880
    {
14881
        return *reinterpret_cast<char*>(&x);
14882
    }
14883

14884
    template < typename C = CharType,
14885
               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
14886
    static CharType to_char_type(std::uint8_t x) noexcept
14887
    {
14888
        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
14889
        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
14890
        CharType result;
14891
        std::memcpy(&result, &x, sizeof(x));
14892
        return result;
14893
    }
14894

14895
    template<typename C = CharType,
14896
             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
14897
    static constexpr CharType to_char_type(std::uint8_t x) noexcept
14898
    {
14899
        return x;
14900
    }
14901

14902
    template < typename InputCharType, typename C = CharType,
14903
               enable_if_t <
14904
                   std::is_signed<C>::value &&
14905
                   std::is_signed<char>::value &&
14906
                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
14907
                   > * = nullptr >
14908
    static constexpr CharType to_char_type(InputCharType x) noexcept
14909
    {
14910
        return x;
14911
    }
14912

14913
  private:
14914
    /// whether we can assume little endianness
14915
    const bool is_little_endian = little_endianness();
14916

14917
    /// the output
14918
    output_adapter_t<CharType> oa = nullptr;
14919
};
14920
}  // namespace detail
14921
}  // namespace nlohmann
14922

14923
// #include <nlohmann/detail/output/output_adapters.hpp>
14924

14925
// #include <nlohmann/detail/output/serializer.hpp>
14926

14927

14928
#include <algorithm> // reverse, remove, fill, find, none_of
14929
#include <array> // array
14930
#include <clocale> // localeconv, lconv
14931
#include <cmath> // labs, isfinite, isnan, signbit
14932
#include <cstddef> // size_t, ptrdiff_t
14933
#include <cstdint> // uint8_t
14934
#include <cstdio> // snprintf
14935
#include <limits> // numeric_limits
14936
#include <string> // string, char_traits
14937
#include <iomanip> // setfill, setw
14938
#include <sstream> // stringstream
14939
#include <type_traits> // is_same
14940
#include <utility> // move
14941

14942
// #include <nlohmann/detail/conversions/to_chars.hpp>
14943

14944

14945
#include <array> // array
14946
#include <cmath>   // signbit, isfinite
14947
#include <cstdint> // intN_t, uintN_t
14948
#include <cstring> // memcpy, memmove
14949
#include <limits> // numeric_limits
14950
#include <type_traits> // conditional
14951

14952
// #include <nlohmann/detail/macro_scope.hpp>
14953

14954

14955
namespace nlohmann
14956
{
14957
namespace detail
14958
{
14959

14960
/*!
14961
@brief implements the Grisu2 algorithm for binary to decimal floating-point
14962
conversion.
14963

14964
This implementation is a slightly modified version of the reference
14965
implementation which may be obtained from
14966
http://florian.loitsch.com/publications (bench.tar.gz).
14967

14968
The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
14969

14970
For a detailed description of the algorithm see:
14971

14972
[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
14973
    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
14974
    Language Design and Implementation, PLDI 2010
14975
[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
14976
    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
14977
    Design and Implementation, PLDI 1996
14978
*/
14979
namespace dtoa_impl
14980
{
14981

14982
template<typename Target, typename Source>
14983
Target reinterpret_bits(const Source source)
14984
{
14985
    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
14986

14987
    Target target;
14988
    std::memcpy(&target, &source, sizeof(Source));
14989
    return target;
14990
}
14991

14992
struct diyfp // f * 2^e
14993
{
14994
    static constexpr int kPrecision = 64; // = q
14995

14996
    std::uint64_t f = 0;
14997
    int e = 0;
14998

14999
    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
15000

15001
    /*!
15002
    @brief returns x - y
15003
    @pre x.e == y.e and x.f >= y.f
15004
    */
15005
    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
15006
    {
15007
        JSON_ASSERT(x.e == y.e);
15008
        JSON_ASSERT(x.f >= y.f);
15009

15010
        return {x.f - y.f, x.e};
15011
    }
15012

15013
    /*!
15014
    @brief returns x * y
15015
    @note The result is rounded. (Only the upper q bits are returned.)
15016
    */
15017
    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
15018
    {
15019
        static_assert(kPrecision == 64, "internal error");
15020

15021
        // Computes:
15022
        //  f = round((x.f * y.f) / 2^q)
15023
        //  e = x.e + y.e + q
15024

15025
        // Emulate the 64-bit * 64-bit multiplication:
15026
        //
15027
        // p = u * v
15028
        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
15029
        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
15030
        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
15031
        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
15032
        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
15033
        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
15034
        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
15035
        //
15036
        // (Since Q might be larger than 2^32 - 1)
15037
        //
15038
        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
15039
        //
15040
        // (Q_hi + H does not overflow a 64-bit int)
15041
        //
15042
        //   = p_lo + 2^64 p_hi
15043

15044
        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
15045
        const std::uint64_t u_hi = x.f >> 32u;
15046
        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
15047
        const std::uint64_t v_hi = y.f >> 32u;
15048

15049
        const std::uint64_t p0 = u_lo * v_lo;
15050
        const std::uint64_t p1 = u_lo * v_hi;
15051
        const std::uint64_t p2 = u_hi * v_lo;
15052
        const std::uint64_t p3 = u_hi * v_hi;
15053

15054
        const std::uint64_t p0_hi = p0 >> 32u;
15055
        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
15056
        const std::uint64_t p1_hi = p1 >> 32u;
15057
        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
15058
        const std::uint64_t p2_hi = p2 >> 32u;
15059

15060
        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
15061

15062
        // The full product might now be computed as
15063
        //
15064
        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
15065
        // p_lo = p0_lo + (Q << 32)
15066
        //
15067
        // But in this particular case here, the full p_lo is not required.
15068
        // Effectively we only need to add the highest bit in p_lo to p_hi (and
15069
        // Q_hi + 1 does not overflow).
15070

15071
        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
15072

15073
        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
15074

15075
        return {h, x.e + y.e + 64};
15076
    }
15077

15078
    /*!
15079
    @brief normalize x such that the significand is >= 2^(q-1)
15080
    @pre x.f != 0
15081
    */
15082
    static diyfp normalize(diyfp x) noexcept
15083
    {
15084
        JSON_ASSERT(x.f != 0);
15085

15086
        while ((x.f >> 63u) == 0)
15087
        {
15088
            x.f <<= 1u;
15089
            x.e--;
15090
        }
15091

15092
        return x;
15093
    }
15094

15095
    /*!
15096
    @brief normalize x such that the result has the exponent E
15097
    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
15098
    */
15099
    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
15100
    {
15101
        const int delta = x.e - target_exponent;
15102

15103
        JSON_ASSERT(delta >= 0);
15104
        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
15105

15106
        return {x.f << delta, target_exponent};
15107
    }
15108
};
15109

15110
struct boundaries
15111
{
15112
    diyfp w;
15113
    diyfp minus;
15114
    diyfp plus;
15115
};
15116

15117
/*!
15118
Compute the (normalized) diyfp representing the input number 'value' and its
15119
boundaries.
15120

15121
@pre value must be finite and positive
15122
*/
15123
template<typename FloatType>
15124
boundaries compute_boundaries(FloatType value)
15125
{
15126
    JSON_ASSERT(std::isfinite(value));
15127
    JSON_ASSERT(value > 0);
15128

15129
    // Convert the IEEE representation into a diyfp.
15130
    //
15131
    // If v is denormal:
15132
    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
15133
    // If v is normalized:
15134
    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
15135

15136
    static_assert(std::numeric_limits<FloatType>::is_iec559,
15137
                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
15138

15139
    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
15140
    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
15141
    constexpr int      kMinExp    = 1 - kBias;
15142
    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
15143

15144
    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
15145

15146
    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
15147
    const std::uint64_t E = bits >> (kPrecision - 1);
15148
    const std::uint64_t F = bits & (kHiddenBit - 1);
15149

15150
    const bool is_denormal = E == 0;
15151
    const diyfp v = is_denormal
15152
                    ? diyfp(F, kMinExp)
15153
                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
15154

15155
    // Compute the boundaries m- and m+ of the floating-point value
15156
    // v = f * 2^e.
15157
    //
15158
    // Determine v- and v+, the floating-point predecessor and successor if v,
15159
    // respectively.
15160
    //
15161
    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
15162
    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
15163
    //
15164
    //      v+ = v + 2^e
15165
    //
15166
    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
15167
    // between m- and m+ round to v, regardless of how the input rounding
15168
    // algorithm breaks ties.
15169
    //
15170
    //      ---+-------------+-------------+-------------+-------------+---  (A)
15171
    //         v-            m-            v             m+            v+
15172
    //
15173
    //      -----------------+------+------+-------------+-------------+---  (B)
15174
    //                       v-     m-     v             m+            v+
15175

15176
    const bool lower_boundary_is_closer = F == 0 && E > 1;
15177
    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
15178
    const diyfp m_minus = lower_boundary_is_closer
15179
                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
15180
                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
15181

15182
    // Determine the normalized w+ = m+.
15183
    const diyfp w_plus = diyfp::normalize(m_plus);
15184

15185
    // Determine w- = m- such that e_(w-) = e_(w+).
15186
    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
15187

15188
    return {diyfp::normalize(v), w_minus, w_plus};
15189
}
15190

15191
// Given normalized diyfp w, Grisu needs to find a (normalized) cached
15192
// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
15193
// within a certain range [alpha, gamma] (Definition 3.2 from [1])
15194
//
15195
//      alpha <= e = e_c + e_w + q <= gamma
15196
//
15197
// or
15198
//
15199
//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
15200
//                          <= f_c * f_w * 2^gamma
15201
//
15202
// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
15203
//
15204
//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
15205
//
15206
// or
15207
//
15208
//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
15209
//
15210
// The choice of (alpha,gamma) determines the size of the table and the form of
15211
// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
15212
// in practice:
15213
//
15214
// The idea is to cut the number c * w = f * 2^e into two parts, which can be
15215
// processed independently: An integral part p1, and a fractional part p2:
15216
//
15217
//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
15218
//              = (f div 2^-e) + (f mod 2^-e) * 2^e
15219
//              = p1 + p2 * 2^e
15220
//
15221
// The conversion of p1 into decimal form requires a series of divisions and
15222
// modulos by (a power of) 10. These operations are faster for 32-bit than for
15223
// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
15224
// achieved by choosing
15225
//
15226
//      -e >= 32   or   e <= -32 := gamma
15227
//
15228
// In order to convert the fractional part
15229
//
15230
//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
15231
//
15232
// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
15233
// d[-i] are extracted in order:
15234
//
15235
//      (10 * p2) div 2^-e = d[-1]
15236
//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
15237
//
15238
// The multiplication by 10 must not overflow. It is sufficient to choose
15239
//
15240
//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
15241
//
15242
// Since p2 = f mod 2^-e < 2^-e,
15243
//
15244
//      -e <= 60   or   e >= -60 := alpha
15245

15246
constexpr int kAlpha = -60;
15247
constexpr int kGamma = -32;
15248

15249
struct cached_power // c = f * 2^e ~= 10^k
15250
{
15251
    std::uint64_t f;
15252
    int e;
15253
    int k;
15254
};
15255

15256
/*!
15257
For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
15258
power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
15259
satisfies (Definition 3.2 from [1])
15260

15261
     alpha <= e_c + e + q <= gamma.
15262
*/
15263
inline cached_power get_cached_power_for_binary_exponent(int e)
15264
{
15265
    // Now
15266
    //
15267
    //      alpha <= e_c + e + q <= gamma                                    (1)
15268
    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
15269
    //
15270
    // and since the c's are normalized, 2^(q-1) <= f_c,
15271
    //
15272
    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
15273
    //      ==> 2^(alpha - e - 1) <= c
15274
    //
15275
    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
15276
    //
15277
    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
15278
    //        = ceil( (alpha - e - 1) * log_10(2) )
15279
    //
15280
    // From the paper:
15281
    // "In theory the result of the procedure could be wrong since c is rounded,
15282
    //  and the computation itself is approximated [...]. In practice, however,
15283
    //  this simple function is sufficient."
15284
    //
15285
    // For IEEE double precision floating-point numbers converted into
15286
    // normalized diyfp's w = f * 2^e, with q = 64,
15287
    //
15288
    //      e >= -1022      (min IEEE exponent)
15289
    //           -52        (p - 1)
15290
    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
15291
    //           -11        (normalize the diyfp)
15292
    //         = -1137
15293
    //
15294
    // and
15295
    //
15296
    //      e <= +1023      (max IEEE exponent)
15297
    //           -52        (p - 1)
15298
    //           -11        (normalize the diyfp)
15299
    //         = 960
15300
    //
15301
    // This binary exponent range [-1137,960] results in a decimal exponent
15302
    // range [-307,324]. One does not need to store a cached power for each
15303
    // k in this range. For each such k it suffices to find a cached power
15304
    // such that the exponent of the product lies in [alpha,gamma].
15305
    // This implies that the difference of the decimal exponents of adjacent
15306
    // table entries must be less than or equal to
15307
    //
15308
    //      floor( (gamma - alpha) * log_10(2) ) = 8.
15309
    //
15310
    // (A smaller distance gamma-alpha would require a larger table.)
15311

15312
    // NB:
15313
    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
15314

15315
    constexpr int kCachedPowersMinDecExp = -300;
15316
    constexpr int kCachedPowersDecStep = 8;
15317

15318
    static constexpr std::array<cached_power, 79> kCachedPowers =
15319
    {
15320
        {
15321
            { 0xAB70FE17C79AC6CA, -1060, -300 },
15322
            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
15323
            { 0xBE5691EF416BD60C, -1007, -284 },
15324
            { 0x8DD01FAD907FFC3C,  -980, -276 },
15325
            { 0xD3515C2831559A83,  -954, -268 },
15326
            { 0x9D71AC8FADA6C9B5,  -927, -260 },
15327
            { 0xEA9C227723EE8BCB,  -901, -252 },
15328
            { 0xAECC49914078536D,  -874, -244 },
15329
            { 0x823C12795DB6CE57,  -847, -236 },
15330
            { 0xC21094364DFB5637,  -821, -228 },
15331
            { 0x9096EA6F3848984F,  -794, -220 },
15332
            { 0xD77485CB25823AC7,  -768, -212 },
15333
            { 0xA086CFCD97BF97F4,  -741, -204 },
15334
            { 0xEF340A98172AACE5,  -715, -196 },
15335
            { 0xB23867FB2A35B28E,  -688, -188 },
15336
            { 0x84C8D4DFD2C63F3B,  -661, -180 },
15337
            { 0xC5DD44271AD3CDBA,  -635, -172 },
15338
            { 0x936B9FCEBB25C996,  -608, -164 },
15339
            { 0xDBAC6C247D62A584,  -582, -156 },
15340
            { 0xA3AB66580D5FDAF6,  -555, -148 },
15341
            { 0xF3E2F893DEC3F126,  -529, -140 },
15342
            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
15343
            { 0x87625F056C7C4A8B,  -475, -124 },
15344
            { 0xC9BCFF6034C13053,  -449, -116 },
15345
            { 0x964E858C91BA2655,  -422, -108 },
15346
            { 0xDFF9772470297EBD,  -396, -100 },
15347
            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
15348
            { 0xF8A95FCF88747D94,  -343,  -84 },
15349
            { 0xB94470938FA89BCF,  -316,  -76 },
15350
            { 0x8A08F0F8BF0F156B,  -289,  -68 },
15351
            { 0xCDB02555653131B6,  -263,  -60 },
15352
            { 0x993FE2C6D07B7FAC,  -236,  -52 },
15353
            { 0xE45C10C42A2B3B06,  -210,  -44 },
15354
            { 0xAA242499697392D3,  -183,  -36 },
15355
            { 0xFD87B5F28300CA0E,  -157,  -28 },
15356
            { 0xBCE5086492111AEB,  -130,  -20 },
15357
            { 0x8CBCCC096F5088CC,  -103,  -12 },
15358
            { 0xD1B71758E219652C,   -77,   -4 },
15359
            { 0x9C40000000000000,   -50,    4 },
15360
            { 0xE8D4A51000000000,   -24,   12 },
15361
            { 0xAD78EBC5AC620000,     3,   20 },
15362
            { 0x813F3978F8940984,    30,   28 },
15363
            { 0xC097CE7BC90715B3,    56,   36 },
15364
            { 0x8F7E32CE7BEA5C70,    83,   44 },
15365
            { 0xD5D238A4ABE98068,   109,   52 },
15366
            { 0x9F4F2726179A2245,   136,   60 },
15367
            { 0xED63A231D4C4FB27,   162,   68 },
15368
            { 0xB0DE65388CC8ADA8,   189,   76 },
15369
            { 0x83C7088E1AAB65DB,   216,   84 },
15370
            { 0xC45D1DF942711D9A,   242,   92 },
15371
            { 0x924D692CA61BE758,   269,  100 },
15372
            { 0xDA01EE641A708DEA,   295,  108 },
15373
            { 0xA26DA3999AEF774A,   322,  116 },
15374
            { 0xF209787BB47D6B85,   348,  124 },
15375
            { 0xB454E4A179DD1877,   375,  132 },
15376
            { 0x865B86925B9BC5C2,   402,  140 },
15377
            { 0xC83553C5C8965D3D,   428,  148 },
15378
            { 0x952AB45CFA97A0B3,   455,  156 },
15379
            { 0xDE469FBD99A05FE3,   481,  164 },
15380
            { 0xA59BC234DB398C25,   508,  172 },
15381
            { 0xF6C69A72A3989F5C,   534,  180 },
15382
            { 0xB7DCBF5354E9BECE,   561,  188 },
15383
            { 0x88FCF317F22241E2,   588,  196 },
15384
            { 0xCC20CE9BD35C78A5,   614,  204 },
15385
            { 0x98165AF37B2153DF,   641,  212 },
15386
            { 0xE2A0B5DC971F303A,   667,  220 },
15387
            { 0xA8D9D1535CE3B396,   694,  228 },
15388
            { 0xFB9B7CD9A4A7443C,   720,  236 },
15389
            { 0xBB764C4CA7A44410,   747,  244 },
15390
            { 0x8BAB8EEFB6409C1A,   774,  252 },
15391
            { 0xD01FEF10A657842C,   800,  260 },
15392
            { 0x9B10A4E5E9913129,   827,  268 },
15393
            { 0xE7109BFBA19C0C9D,   853,  276 },
15394
            { 0xAC2820D9623BF429,   880,  284 },
15395
            { 0x80444B5E7AA7CF85,   907,  292 },
15396
            { 0xBF21E44003ACDD2D,   933,  300 },
15397
            { 0x8E679C2F5E44FF8F,   960,  308 },
15398
            { 0xD433179D9C8CB841,   986,  316 },
15399
            { 0x9E19DB92B4E31BA9,  1013,  324 },
15400
        }
15401
    };
15402

15403
    // This computation gives exactly the same results for k as
15404
    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
15405
    // for |e| <= 1500, but doesn't require floating-point operations.
15406
    // NB: log_10(2) ~= 78913 / 2^18
15407
    JSON_ASSERT(e >= -1500);
15408
    JSON_ASSERT(e <=  1500);
15409
    const int f = kAlpha - e - 1;
15410
    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
15411

15412
    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
15413
    JSON_ASSERT(index >= 0);
15414
    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
15415

15416
    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
15417
    JSON_ASSERT(kAlpha <= cached.e + e + 64);
15418
    JSON_ASSERT(kGamma >= cached.e + e + 64);
15419

15420
    return cached;
15421
}
15422

15423
/*!
15424
For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
15425
For n == 0, returns 1 and sets pow10 := 1.
15426
*/
15427
inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
15428
{
15429
    // LCOV_EXCL_START
15430
    if (n >= 1000000000)
15431
    {
15432
        pow10 = 1000000000;
15433
        return 10;
15434
    }
15435
    // LCOV_EXCL_STOP
15436
    if (n >= 100000000)
15437
    {
15438
        pow10 = 100000000;
15439
        return  9;
15440
    }
15441
    if (n >= 10000000)
15442
    {
15443
        pow10 = 10000000;
15444
        return  8;
15445
    }
15446
    if (n >= 1000000)
15447
    {
15448
        pow10 = 1000000;
15449
        return  7;
15450
    }
15451
    if (n >= 100000)
15452
    {
15453
        pow10 = 100000;
15454
        return  6;
15455
    }
15456
    if (n >= 10000)
15457
    {
15458
        pow10 = 10000;
15459
        return  5;
15460
    }
15461
    if (n >= 1000)
15462
    {
15463
        pow10 = 1000;
15464
        return  4;
15465
    }
15466
    if (n >= 100)
15467
    {
15468
        pow10 = 100;
15469
        return  3;
15470
    }
15471
    if (n >= 10)
15472
    {
15473
        pow10 = 10;
15474
        return  2;
15475
    }
15476

15477
    pow10 = 1;
15478
    return 1;
15479
}
15480

15481
inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
15482
                         std::uint64_t rest, std::uint64_t ten_k)
15483
{
15484
    JSON_ASSERT(len >= 1);
15485
    JSON_ASSERT(dist <= delta);
15486
    JSON_ASSERT(rest <= delta);
15487
    JSON_ASSERT(ten_k > 0);
15488

15489
    //               <--------------------------- delta ---->
15490
    //                                  <---- dist --------->
15491
    // --------------[------------------+-------------------]--------------
15492
    //               M-                 w                   M+
15493
    //
15494
    //                                  ten_k
15495
    //                                <------>
15496
    //                                       <---- rest ---->
15497
    // --------------[------------------+----+--------------]--------------
15498
    //                                  w    V
15499
    //                                       = buf * 10^k
15500
    //
15501
    // ten_k represents a unit-in-the-last-place in the decimal representation
15502
    // stored in buf.
15503
    // Decrement buf by ten_k while this takes buf closer to w.
15504

15505
    // The tests are written in this order to avoid overflow in unsigned
15506
    // integer arithmetic.
15507

15508
    while (rest < dist
15509
            && delta - rest >= ten_k
15510
            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
15511
    {
15512
        JSON_ASSERT(buf[len - 1] != '0');
15513
        buf[len - 1]--;
15514
        rest += ten_k;
15515
    }
15516
}
15517

15518
/*!
15519
Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
15520
M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
15521
*/
15522
inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
15523
                             diyfp M_minus, diyfp w, diyfp M_plus)
15524
{
15525
    static_assert(kAlpha >= -60, "internal error");
15526
    static_assert(kGamma <= -32, "internal error");
15527

15528
    // Generates the digits (and the exponent) of a decimal floating-point
15529
    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
15530
    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
15531
    //
15532
    //               <--------------------------- delta ---->
15533
    //                                  <---- dist --------->
15534
    // --------------[------------------+-------------------]--------------
15535
    //               M-                 w                   M+
15536
    //
15537
    // Grisu2 generates the digits of M+ from left to right and stops as soon as
15538
    // V is in [M-,M+].
15539

15540
    JSON_ASSERT(M_plus.e >= kAlpha);
15541
    JSON_ASSERT(M_plus.e <= kGamma);
15542

15543
    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
15544
    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
15545

15546
    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
15547
    //
15548
    //      M+ = f * 2^e
15549
    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
15550
    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
15551
    //         = p1 + p2 * 2^e
15552

15553
    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
15554

15555
    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
15556
    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
15557

15558
    // 1)
15559
    //
15560
    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
15561

15562
    JSON_ASSERT(p1 > 0);
15563

15564
    std::uint32_t pow10{};
15565
    const int k = find_largest_pow10(p1, pow10);
15566

15567
    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
15568
    //
15569
    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
15570
    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
15571
    //
15572
    //      M+ = p1                                             + p2 * 2^e
15573
    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
15574
    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
15575
    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
15576
    //
15577
    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
15578
    //
15579
    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
15580
    //
15581
    // but stop as soon as
15582
    //
15583
    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
15584

15585
    int n = k;
15586
    while (n > 0)
15587
    {
15588
        // Invariants:
15589
        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
15590
        //      pow10 = 10^(n-1) <= p1 < 10^n
15591
        //
15592
        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
15593
        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
15594
        //
15595
        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
15596
        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
15597
        //
15598
        JSON_ASSERT(d <= 9);
15599
        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
15600
        //
15601
        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
15602
        //
15603
        p1 = r;
15604
        n--;
15605
        //
15606
        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
15607
        //      pow10 = 10^n
15608
        //
15609

15610
        // Now check if enough digits have been generated.
15611
        // Compute
15612
        //
15613
        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
15614
        //
15615
        // Note:
15616
        // Since rest and delta share the same exponent e, it suffices to
15617
        // compare the significands.
15618
        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15619
        if (rest <= delta)
15620
        {
15621
            // V = buffer * 10^n, with M- <= V <= M+.
15622

15623
            decimal_exponent += n;
15624

15625
            // We may now just stop. But instead look if the buffer could be
15626
            // decremented to bring V closer to w.
15627
            //
15628
            // pow10 = 10^n is now 1 ulp in the decimal representation V.
15629
            // The rounding procedure works with diyfp's with an implicit
15630
            // exponent of e.
15631
            //
15632
            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
15633
            //
15634
            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15635
            grisu2_round(buffer, length, dist, delta, rest, ten_n);
15636

15637
            return;
15638
        }
15639

15640
        pow10 /= 10;
15641
        //
15642
        //      pow10 = 10^(n-1) <= p1 < 10^n
15643
        // Invariants restored.
15644
    }
15645

15646
    // 2)
15647
    //
15648
    // The digits of the integral part have been generated:
15649
    //
15650
    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
15651
    //         = buffer            + p2 * 2^e
15652
    //
15653
    // Now generate the digits of the fractional part p2 * 2^e.
15654
    //
15655
    // Note:
15656
    // No decimal point is generated: the exponent is adjusted instead.
15657
    //
15658
    // p2 actually represents the fraction
15659
    //
15660
    //      p2 * 2^e
15661
    //          = p2 / 2^-e
15662
    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
15663
    //
15664
    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
15665
    //
15666
    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
15667
    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
15668
    //
15669
    // using
15670
    //
15671
    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
15672
    //                = (                   d) * 2^-e + (                   r)
15673
    //
15674
    // or
15675
    //      10^m * p2 * 2^e = d + r * 2^e
15676
    //
15677
    // i.e.
15678
    //
15679
    //      M+ = buffer + p2 * 2^e
15680
    //         = buffer + 10^-m * (d + r * 2^e)
15681
    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
15682
    //
15683
    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
15684

15685
    JSON_ASSERT(p2 > delta);
15686

15687
    int m = 0;
15688
    for (;;)
15689
    {
15690
        // Invariant:
15691
        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
15692
        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
15693
        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
15694
        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
15695
        //
15696
        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15697
        p2 *= 10;
15698
        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
15699
        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
15700
        //
15701
        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
15702
        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
15703
        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
15704
        //
15705
        JSON_ASSERT(d <= 9);
15706
        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
15707
        //
15708
        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
15709
        //
15710
        p2 = r;
15711
        m++;
15712
        //
15713
        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
15714
        // Invariant restored.
15715

15716
        // Check if enough digits have been generated.
15717
        //
15718
        //      10^-m * p2 * 2^e <= delta * 2^e
15719
        //              p2 * 2^e <= 10^m * delta * 2^e
15720
        //                    p2 <= 10^m * delta
15721
        delta *= 10;
15722
        dist  *= 10;
15723
        if (p2 <= delta)
15724
        {
15725
            break;
15726
        }
15727
    }
15728

15729
    // V = buffer * 10^-m, with M- <= V <= M+.
15730

15731
    decimal_exponent -= m;
15732

15733
    // 1 ulp in the decimal representation is now 10^-m.
15734
    // Since delta and dist are now scaled by 10^m, we need to do the
15735
    // same with ulp in order to keep the units in sync.
15736
    //
15737
    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
15738
    //
15739
    const std::uint64_t ten_m = one.f;
15740
    grisu2_round(buffer, length, dist, delta, p2, ten_m);
15741

15742
    // By construction this algorithm generates the shortest possible decimal
15743
    // number (Loitsch, Theorem 6.2) which rounds back to w.
15744
    // For an input number of precision p, at least
15745
    //
15746
    //      N = 1 + ceil(p * log_10(2))
15747
    //
15748
    // decimal digits are sufficient to identify all binary floating-point
15749
    // numbers (Matula, "In-and-Out conversions").
15750
    // This implies that the algorithm does not produce more than N decimal
15751
    // digits.
15752
    //
15753
    //      N = 17 for p = 53 (IEEE double precision)
15754
    //      N = 9  for p = 24 (IEEE single precision)
15755
}
15756

15757
/*!
15758
v = buf * 10^decimal_exponent
15759
len is the length of the buffer (number of decimal digits)
15760
The buffer must be large enough, i.e. >= max_digits10.
15761
*/
15762
JSON_HEDLEY_NON_NULL(1)
15763
inline void grisu2(char* buf, int& len, int& decimal_exponent,
15764
                   diyfp m_minus, diyfp v, diyfp m_plus)
15765
{
15766
    JSON_ASSERT(m_plus.e == m_minus.e);
15767
    JSON_ASSERT(m_plus.e == v.e);
15768

15769
    //  --------(-----------------------+-----------------------)--------    (A)
15770
    //          m-                      v                       m+
15771
    //
15772
    //  --------------------(-----------+-----------------------)--------    (B)
15773
    //                      m-          v                       m+
15774
    //
15775
    // First scale v (and m- and m+) such that the exponent is in the range
15776
    // [alpha, gamma].
15777

15778
    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
15779

15780
    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
15781

15782
    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
15783
    const diyfp w       = diyfp::mul(v,       c_minus_k);
15784
    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
15785
    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
15786

15787
    //  ----(---+---)---------------(---+---)---------------(---+---)----
15788
    //          w-                      w                       w+
15789
    //          = c*m-                  = c*v                   = c*m+
15790
    //
15791
    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
15792
    // w+ are now off by a small amount.
15793
    // In fact:
15794
    //
15795
    //      w - v * 10^k < 1 ulp
15796
    //
15797
    // To account for this inaccuracy, add resp. subtract 1 ulp.
15798
    //
15799
    //  --------+---[---------------(---+---)---------------]---+--------
15800
    //          w-  M-                  w                   M+  w+
15801
    //
15802
    // Now any number in [M-, M+] (bounds included) will round to w when input,
15803
    // regardless of how the input rounding algorithm breaks ties.
15804
    //
15805
    // And digit_gen generates the shortest possible such number in [M-, M+].
15806
    // Note that this does not mean that Grisu2 always generates the shortest
15807
    // possible number in the interval (m-, m+).
15808
    const diyfp M_minus(w_minus.f + 1, w_minus.e);
15809
    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
15810

15811
    decimal_exponent = -cached.k; // = -(-k) = k
15812

15813
    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
15814
}
15815

15816
/*!
15817
v = buf * 10^decimal_exponent
15818
len is the length of the buffer (number of decimal digits)
15819
The buffer must be large enough, i.e. >= max_digits10.
15820
*/
15821
template<typename FloatType>
15822
JSON_HEDLEY_NON_NULL(1)
15823
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
15824
{
15825
    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
15826
                  "internal error: not enough precision");
15827

15828
    JSON_ASSERT(std::isfinite(value));
15829
    JSON_ASSERT(value > 0);
15830

15831
    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
15832
    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
15833
    // decimal representations are not exactly "short".
15834
    //
15835
    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
15836
    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
15837
    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
15838
    // does.
15839
    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
15840
    // representation using the corresponding std::from_chars function recovers value exactly". That
15841
    // indicates that single precision floating-point numbers should be recovered using
15842
    // 'std::strtof'.
15843
    //
15844
    // NB: If the neighbors are computed for single-precision numbers, there is a single float
15845
    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
15846
    //     value is off by 1 ulp.
15847
#if 0
15848
    const boundaries w = compute_boundaries(static_cast<double>(value));
15849
#else
15850
    const boundaries w = compute_boundaries(value);
15851
#endif
15852

15853
    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
15854
}
15855

15856
/*!
15857
@brief appends a decimal representation of e to buf
15858
@return a pointer to the element following the exponent.
15859
@pre -1000 < e < 1000
15860
*/
15861
JSON_HEDLEY_NON_NULL(1)
15862
JSON_HEDLEY_RETURNS_NON_NULL
15863
inline char* append_exponent(char* buf, int e)
15864
{
15865
    JSON_ASSERT(e > -1000);
15866
    JSON_ASSERT(e <  1000);
15867

15868
    if (e < 0)
15869
    {
15870
        e = -e;
15871
        *buf++ = '-';
15872
    }
15873
    else
15874
    {
15875
        *buf++ = '+';
15876
    }
15877

15878
    auto k = static_cast<std::uint32_t>(e);
15879
    if (k < 10)
15880
    {
15881
        // Always print at least two digits in the exponent.
15882
        // This is for compatibility with printf("%g").
15883
        *buf++ = '0';
15884
        *buf++ = static_cast<char>('0' + k);
15885
    }
15886
    else if (k < 100)
15887
    {
15888
        *buf++ = static_cast<char>('0' + k / 10);
15889
        k %= 10;
15890
        *buf++ = static_cast<char>('0' + k);
15891
    }
15892
    else
15893
    {
15894
        *buf++ = static_cast<char>('0' + k / 100);
15895
        k %= 100;
15896
        *buf++ = static_cast<char>('0' + k / 10);
15897
        k %= 10;
15898
        *buf++ = static_cast<char>('0' + k);
15899
    }
15900

15901
    return buf;
15902
}
15903

15904
/*!
15905
@brief prettify v = buf * 10^decimal_exponent
15906

15907
If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
15908
notation. Otherwise it will be printed in exponential notation.
15909

15910
@pre min_exp < 0
15911
@pre max_exp > 0
15912
*/
15913
JSON_HEDLEY_NON_NULL(1)
15914
JSON_HEDLEY_RETURNS_NON_NULL
15915
inline char* format_buffer(char* buf, int len, int decimal_exponent,
15916
                           int min_exp, int max_exp)
15917
{
15918
    JSON_ASSERT(min_exp < 0);
15919
    JSON_ASSERT(max_exp > 0);
15920

15921
    const int k = len;
15922
    const int n = len + decimal_exponent;
15923

15924
    // v = buf * 10^(n-k)
15925
    // k is the length of the buffer (number of decimal digits)
15926
    // n is the position of the decimal point relative to the start of the buffer.
15927

15928
    if (k <= n && n <= max_exp)
15929
    {
15930
        // digits[000]
15931
        // len <= max_exp + 2
15932

15933
        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
15934
        // Make it look like a floating-point number (#362, #378)
15935
        buf[n + 0] = '.';
15936
        buf[n + 1] = '0';
15937
        return buf + (static_cast<size_t>(n) + 2);
15938
    }
15939

15940
    if (0 < n && n <= max_exp)
15941
    {
15942
        // dig.its
15943
        // len <= max_digits10 + 1
15944

15945
        JSON_ASSERT(k > n);
15946

15947
        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
15948
        buf[n] = '.';
15949
        return buf + (static_cast<size_t>(k) + 1U);
15950
    }
15951

15952
    if (min_exp < n && n <= 0)
15953
    {
15954
        // 0.[000]digits
15955
        // len <= 2 + (-min_exp - 1) + max_digits10
15956

15957
        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
15958
        buf[0] = '0';
15959
        buf[1] = '.';
15960
        std::memset(buf + 2, '0', static_cast<size_t>(-n));
15961
        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
15962
    }
15963

15964
    if (k == 1)
15965
    {
15966
        // dE+123
15967
        // len <= 1 + 5
15968

15969
        buf += 1;
15970
    }
15971
    else
15972
    {
15973
        // d.igitsE+123
15974
        // len <= max_digits10 + 1 + 5
15975

15976
        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
15977
        buf[1] = '.';
15978
        buf += 1 + static_cast<size_t>(k);
15979
    }
15980

15981
    *buf++ = 'e';
15982
    return append_exponent(buf, n - 1);
15983
}
15984

15985
} // namespace dtoa_impl
15986

15987
/*!
15988
@brief generates a decimal representation of the floating-point number value in [first, last).
15989

15990
The format of the resulting decimal representation is similar to printf's %g
15991
format. Returns an iterator pointing past-the-end of the decimal representation.
15992

15993
@note The input number must be finite, i.e. NaN's and Inf's are not supported.
15994
@note The buffer must be large enough.
15995
@note The result is NOT null-terminated.
15996
*/
15997
template<typename FloatType>
15998
JSON_HEDLEY_NON_NULL(1, 2)
15999
JSON_HEDLEY_RETURNS_NON_NULL
16000
char* to_chars(char* first, const char* last, FloatType value)
16001
{
16002
    static_cast<void>(last); // maybe unused - fix warning
16003
    JSON_ASSERT(std::isfinite(value));
16004

16005
    // Use signbit(value) instead of (value < 0) since signbit works for -0.
16006
    if (std::signbit(value))
16007
    {
16008
        value = -value;
16009
        *first++ = '-';
16010
    }
16011

16012
#ifdef __GNUC__
16013
#pragma GCC diagnostic push
16014
#pragma GCC diagnostic ignored "-Wfloat-equal"
16015
#endif
16016
    if (value == 0) // +-0
16017
    {
16018
        *first++ = '0';
16019
        // Make it look like a floating-point number (#362, #378)
16020
        *first++ = '.';
16021
        *first++ = '0';
16022
        return first;
16023
    }
16024
#ifdef __GNUC__
16025
#pragma GCC diagnostic pop
16026
#endif
16027

16028
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
16029

16030
    // Compute v = buffer * 10^decimal_exponent.
16031
    // The decimal digits are stored in the buffer, which needs to be interpreted
16032
    // as an unsigned decimal integer.
16033
    // len is the length of the buffer, i.e. the number of decimal digits.
16034
    int len = 0;
16035
    int decimal_exponent = 0;
16036
    dtoa_impl::grisu2(first, len, decimal_exponent, value);
16037

16038
    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
16039

16040
    // Format the buffer like printf("%.*g", prec, value)
16041
    constexpr int kMinExp = -4;
16042
    // Use digits10 here to increase compatibility with version 2.
16043
    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
16044

16045
    JSON_ASSERT(last - first >= kMaxExp + 2);
16046
    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
16047
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
16048

16049
    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
16050
}
16051

16052
} // namespace detail
16053
} // namespace nlohmann
16054

16055
// #include <nlohmann/detail/exceptions.hpp>
16056

16057
// #include <nlohmann/detail/macro_scope.hpp>
16058

16059
// #include <nlohmann/detail/meta/cpp_future.hpp>
16060

16061
// #include <nlohmann/detail/output/binary_writer.hpp>
16062

16063
// #include <nlohmann/detail/output/output_adapters.hpp>
16064

16065
// #include <nlohmann/detail/value_t.hpp>
16066

16067

16068
namespace nlohmann
16069
{
16070
namespace detail
16071
{
16072
///////////////////
16073
// serialization //
16074
///////////////////
16075

16076
/// how to treat decoding errors
16077
enum class error_handler_t
16078
{
16079
    strict,  ///< throw a type_error exception in case of invalid UTF-8
16080
    replace, ///< replace invalid UTF-8 sequences with U+FFFD
16081
    ignore   ///< ignore invalid UTF-8 sequences
16082
};
16083

16084
template<typename BasicJsonType>
16085
class serializer
16086
{
16087
    using string_t = typename BasicJsonType::string_t;
16088
    using number_float_t = typename BasicJsonType::number_float_t;
16089
    using number_integer_t = typename BasicJsonType::number_integer_t;
16090
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
16091
    using binary_char_t = typename BasicJsonType::binary_t::value_type;
16092
    static constexpr std::uint8_t UTF8_ACCEPT = 0;
16093
    static constexpr std::uint8_t UTF8_REJECT = 1;
16094

16095
  public:
16096
    /*!
16097
    @param[in] s  output stream to serialize to
16098
    @param[in] ichar  indentation character to use
16099
    @param[in] error_handler_  how to react on decoding errors
16100
    */
16101
    serializer(output_adapter_t<char> s, const char ichar,
16102
               error_handler_t error_handler_ = error_handler_t::strict)
16103
        : o(std::move(s))
16104
        , loc(std::localeconv())
16105
        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
16106
        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
16107
        , indent_char(ichar)
16108
        , indent_string(512, indent_char)
16109
        , error_handler(error_handler_)
16110
    {}
16111

16112
    // delete because of pointer members
16113
    serializer(const serializer&) = delete;
16114
    serializer& operator=(const serializer&) = delete;
16115
    serializer(serializer&&) = delete;
16116
    serializer& operator=(serializer&&) = delete;
16117
    ~serializer() = default;
16118

16119
    /*!
16120
    @brief internal implementation of the serialization function
16121

16122
    This function is called by the public member function dump and organizes
16123
    the serialization internally. The indentation level is propagated as
16124
    additional parameter. In case of arrays and objects, the function is
16125
    called recursively.
16126

16127
    - strings and object keys are escaped using `escape_string()`
16128
    - integer numbers are converted implicitly via `operator<<`
16129
    - floating-point numbers are converted to a string using `"%g"` format
16130
    - binary values are serialized as objects containing the subtype and the
16131
      byte array
16132

16133
    @param[in] val               value to serialize
16134
    @param[in] pretty_print      whether the output shall be pretty-printed
16135
    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
16136
    in the output are escaped with `\uXXXX` sequences, and the result consists
16137
    of ASCII characters only.
16138
    @param[in] indent_step       the indent level
16139
    @param[in] current_indent    the current indent level (only used internally)
16140
    */
16141
    void dump(const BasicJsonType& val,
16142
              const bool pretty_print,
16143
              const bool ensure_ascii,
16144
              const unsigned int indent_step,
16145
              const unsigned int current_indent = 0)
16146
    {
16147
        switch (val.m_type)
16148
        {
16149
            case value_t::object:
16150
            {
16151
                if (val.m_value.object->empty())
16152
                {
16153
                    o->write_characters("{}", 2);
16154
                    return;
16155
                }
16156

16157
                if (pretty_print)
16158
                {
16159
                    o->write_characters("{\n", 2);
16160

16161
                    // variable to hold indentation for recursive calls
16162
                    const auto new_indent = current_indent + indent_step;
16163
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16164
                    {
16165
                        indent_string.resize(indent_string.size() * 2, ' ');
16166
                    }
16167

16168
                    // first n-1 elements
16169
                    auto i = val.m_value.object->cbegin();
16170
                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16171
                    {
16172
                        o->write_characters(indent_string.c_str(), new_indent);
16173
                        o->write_character('\"');
16174
                        dump_escaped(i->first, ensure_ascii);
16175
                        o->write_characters("\": ", 3);
16176
                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
16177
                        o->write_characters(",\n", 2);
16178
                    }
16179

16180
                    // last element
16181
                    JSON_ASSERT(i != val.m_value.object->cend());
16182
                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16183
                    o->write_characters(indent_string.c_str(), new_indent);
16184
                    o->write_character('\"');
16185
                    dump_escaped(i->first, ensure_ascii);
16186
                    o->write_characters("\": ", 3);
16187
                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
16188

16189
                    o->write_character('\n');
16190
                    o->write_characters(indent_string.c_str(), current_indent);
16191
                    o->write_character('}');
16192
                }
16193
                else
16194
                {
16195
                    o->write_character('{');
16196

16197
                    // first n-1 elements
16198
                    auto i = val.m_value.object->cbegin();
16199
                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16200
                    {
16201
                        o->write_character('\"');
16202
                        dump_escaped(i->first, ensure_ascii);
16203
                        o->write_characters("\":", 2);
16204
                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
16205
                        o->write_character(',');
16206
                    }
16207

16208
                    // last element
16209
                    JSON_ASSERT(i != val.m_value.object->cend());
16210
                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16211
                    o->write_character('\"');
16212
                    dump_escaped(i->first, ensure_ascii);
16213
                    o->write_characters("\":", 2);
16214
                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
16215

16216
                    o->write_character('}');
16217
                }
16218

16219
                return;
16220
            }
16221

16222
            case value_t::array:
16223
            {
16224
                if (val.m_value.array->empty())
16225
                {
16226
                    o->write_characters("[]", 2);
16227
                    return;
16228
                }
16229

16230
                if (pretty_print)
16231
                {
16232
                    o->write_characters("[\n", 2);
16233

16234
                    // variable to hold indentation for recursive calls
16235
                    const auto new_indent = current_indent + indent_step;
16236
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16237
                    {
16238
                        indent_string.resize(indent_string.size() * 2, ' ');
16239
                    }
16240

16241
                    // first n-1 elements
16242
                    for (auto i = val.m_value.array->cbegin();
16243
                            i != val.m_value.array->cend() - 1; ++i)
16244
                    {
16245
                        o->write_characters(indent_string.c_str(), new_indent);
16246
                        dump(*i, true, ensure_ascii, indent_step, new_indent);
16247
                        o->write_characters(",\n", 2);
16248
                    }
16249

16250
                    // last element
16251
                    JSON_ASSERT(!val.m_value.array->empty());
16252
                    o->write_characters(indent_string.c_str(), new_indent);
16253
                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
16254

16255
                    o->write_character('\n');
16256
                    o->write_characters(indent_string.c_str(), current_indent);
16257
                    o->write_character(']');
16258
                }
16259
                else
16260
                {
16261
                    o->write_character('[');
16262

16263
                    // first n-1 elements
16264
                    for (auto i = val.m_value.array->cbegin();
16265
                            i != val.m_value.array->cend() - 1; ++i)
16266
                    {
16267
                        dump(*i, false, ensure_ascii, indent_step, current_indent);
16268
                        o->write_character(',');
16269
                    }
16270

16271
                    // last element
16272
                    JSON_ASSERT(!val.m_value.array->empty());
16273
                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
16274

16275
                    o->write_character(']');
16276
                }
16277

16278
                return;
16279
            }
16280

16281
            case value_t::string:
16282
            {
16283
                o->write_character('\"');
16284
                dump_escaped(*val.m_value.string, ensure_ascii);
16285
                o->write_character('\"');
16286
                return;
16287
            }
16288

16289
            case value_t::binary:
16290
            {
16291
                if (pretty_print)
16292
                {
16293
                    o->write_characters("{\n", 2);
16294

16295
                    // variable to hold indentation for recursive calls
16296
                    const auto new_indent = current_indent + indent_step;
16297
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16298
                    {
16299
                        indent_string.resize(indent_string.size() * 2, ' ');
16300
                    }
16301

16302
                    o->write_characters(indent_string.c_str(), new_indent);
16303

16304
                    o->write_characters("\"bytes\": [", 10);
16305

16306
                    if (!val.m_value.binary->empty())
16307
                    {
16308
                        for (auto i = val.m_value.binary->cbegin();
16309
                                i != val.m_value.binary->cend() - 1; ++i)
16310
                        {
16311
                            dump_integer(*i);
16312
                            o->write_characters(", ", 2);
16313
                        }
16314
                        dump_integer(val.m_value.binary->back());
16315
                    }
16316

16317
                    o->write_characters("],\n", 3);
16318
                    o->write_characters(indent_string.c_str(), new_indent);
16319

16320
                    o->write_characters("\"subtype\": ", 11);
16321
                    if (val.m_value.binary->has_subtype())
16322
                    {
16323
                        dump_integer(val.m_value.binary->subtype());
16324
                    }
16325
                    else
16326
                    {
16327
                        o->write_characters("null", 4);
16328
                    }
16329
                    o->write_character('\n');
16330
                    o->write_characters(indent_string.c_str(), current_indent);
16331
                    o->write_character('}');
16332
                }
16333
                else
16334
                {
16335
                    o->write_characters("{\"bytes\":[", 10);
16336

16337
                    if (!val.m_value.binary->empty())
16338
                    {
16339
                        for (auto i = val.m_value.binary->cbegin();
16340
                                i != val.m_value.binary->cend() - 1; ++i)
16341
                        {
16342
                            dump_integer(*i);
16343
                            o->write_character(',');
16344
                        }
16345
                        dump_integer(val.m_value.binary->back());
16346
                    }
16347

16348
                    o->write_characters("],\"subtype\":", 12);
16349
                    if (val.m_value.binary->has_subtype())
16350
                    {
16351
                        dump_integer(val.m_value.binary->subtype());
16352
                        o->write_character('}');
16353
                    }
16354
                    else
16355
                    {
16356
                        o->write_characters("null}", 5);
16357
                    }
16358
                }
16359
                return;
16360
            }
16361

16362
            case value_t::boolean:
16363
            {
16364
                if (val.m_value.boolean)
16365
                {
16366
                    o->write_characters("true", 4);
16367
                }
16368
                else
16369
                {
16370
                    o->write_characters("false", 5);
16371
                }
16372
                return;
16373
            }
16374

16375
            case value_t::number_integer:
16376
            {
16377
                dump_integer(val.m_value.number_integer);
16378
                return;
16379
            }
16380

16381
            case value_t::number_unsigned:
16382
            {
16383
                dump_integer(val.m_value.number_unsigned);
16384
                return;
16385
            }
16386

16387
            case value_t::number_float:
16388
            {
16389
                dump_float(val.m_value.number_float);
16390
                return;
16391
            }
16392

16393
            case value_t::discarded:
16394
            {
16395
                o->write_characters("<discarded>", 11);
16396
                return;
16397
            }
16398

16399
            case value_t::null:
16400
            {
16401
                o->write_characters("null", 4);
16402
                return;
16403
            }
16404

16405
            default:            // LCOV_EXCL_LINE
16406
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16407
        }
16408
    }
16409

16410
  JSON_PRIVATE_UNLESS_TESTED:
16411
    /*!
16412
    @brief dump escaped string
16413

16414
    Escape a string by replacing certain special characters by a sequence of an
16415
    escape character (backslash) and another character and other control
16416
    characters by a sequence of "\u" followed by a four-digit hex
16417
    representation. The escaped string is written to output stream @a o.
16418

16419
    @param[in] s  the string to escape
16420
    @param[in] ensure_ascii  whether to escape non-ASCII characters with
16421
                             \uXXXX sequences
16422

16423
    @complexity Linear in the length of string @a s.
16424
    */
16425
    void dump_escaped(const string_t& s, const bool ensure_ascii)
16426
    {
16427
        std::uint32_t codepoint{};
16428
        std::uint8_t state = UTF8_ACCEPT;
16429
        std::size_t bytes = 0;  // number of bytes written to string_buffer
16430

16431
        // number of bytes written at the point of the last valid byte
16432
        std::size_t bytes_after_last_accept = 0;
16433
        std::size_t undumped_chars = 0;
16434

16435
        for (std::size_t i = 0; i < s.size(); ++i)
16436
        {
16437
            const auto byte = static_cast<std::uint8_t>(s[i]);
16438

16439
            switch (decode(state, codepoint, byte))
16440
            {
16441
                case UTF8_ACCEPT:  // decode found a new code point
16442
                {
16443
                    switch (codepoint)
16444
                    {
16445
                        case 0x08: // backspace
16446
                        {
16447
                            string_buffer[bytes++] = '\\';
16448
                            string_buffer[bytes++] = 'b';
16449
                            break;
16450
                        }
16451

16452
                        case 0x09: // horizontal tab
16453
                        {
16454
                            string_buffer[bytes++] = '\\';
16455
                            string_buffer[bytes++] = 't';
16456
                            break;
16457
                        }
16458

16459
                        case 0x0A: // newline
16460
                        {
16461
                            string_buffer[bytes++] = '\\';
16462
                            string_buffer[bytes++] = 'n';
16463
                            break;
16464
                        }
16465

16466
                        case 0x0C: // formfeed
16467
                        {
16468
                            string_buffer[bytes++] = '\\';
16469
                            string_buffer[bytes++] = 'f';
16470
                            break;
16471
                        }
16472

16473
                        case 0x0D: // carriage return
16474
                        {
16475
                            string_buffer[bytes++] = '\\';
16476
                            string_buffer[bytes++] = 'r';
16477
                            break;
16478
                        }
16479

16480
                        case 0x22: // quotation mark
16481
                        {
16482
                            string_buffer[bytes++] = '\\';
16483
                            string_buffer[bytes++] = '\"';
16484
                            break;
16485
                        }
16486

16487
                        case 0x5C: // reverse solidus
16488
                        {
16489
                            string_buffer[bytes++] = '\\';
16490
                            string_buffer[bytes++] = '\\';
16491
                            break;
16492
                        }
16493

16494
                        default:
16495
                        {
16496
                            // escape control characters (0x00..0x1F) or, if
16497
                            // ensure_ascii parameter is used, non-ASCII characters
16498
                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
16499
                            {
16500
                                if (codepoint <= 0xFFFF)
16501
                                {
16502
                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16503
                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
16504
                                                                      static_cast<std::uint16_t>(codepoint)));
16505
                                    bytes += 6;
16506
                                }
16507
                                else
16508
                                {
16509
                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16510
                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
16511
                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
16512
                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
16513
                                    bytes += 12;
16514
                                }
16515
                            }
16516
                            else
16517
                            {
16518
                                // copy byte to buffer (all previous bytes
16519
                                // been copied have in default case above)
16520
                                string_buffer[bytes++] = s[i];
16521
                            }
16522
                            break;
16523
                        }
16524
                    }
16525

16526
                    // write buffer and reset index; there must be 13 bytes
16527
                    // left, as this is the maximal number of bytes to be
16528
                    // written ("\uxxxx\uxxxx\0") for one code point
16529
                    if (string_buffer.size() - bytes < 13)
16530
                    {
16531
                        o->write_characters(string_buffer.data(), bytes);
16532
                        bytes = 0;
16533
                    }
16534

16535
                    // remember the byte position of this accept
16536
                    bytes_after_last_accept = bytes;
16537
                    undumped_chars = 0;
16538
                    break;
16539
                }
16540

16541
                case UTF8_REJECT:  // decode found invalid UTF-8 byte
16542
                {
16543
                    switch (error_handler)
16544
                    {
16545
                        case error_handler_t::strict:
16546
                        {
16547
                            std::stringstream ss;
16548
                            ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (byte | 0);
16549
                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str(), BasicJsonType()));
16550
                        }
16551

16552
                        case error_handler_t::ignore:
16553
                        case error_handler_t::replace:
16554
                        {
16555
                            // in case we saw this character the first time, we
16556
                            // would like to read it again, because the byte
16557
                            // may be OK for itself, but just not OK for the
16558
                            // previous sequence
16559
                            if (undumped_chars > 0)
16560
                            {
16561
                                --i;
16562
                            }
16563

16564
                            // reset length buffer to the last accepted index;
16565
                            // thus removing/ignoring the invalid characters
16566
                            bytes = bytes_after_last_accept;
16567

16568
                            if (error_handler == error_handler_t::replace)
16569
                            {
16570
                                // add a replacement character
16571
                                if (ensure_ascii)
16572
                                {
16573
                                    string_buffer[bytes++] = '\\';
16574
                                    string_buffer[bytes++] = 'u';
16575
                                    string_buffer[bytes++] = 'f';
16576
                                    string_buffer[bytes++] = 'f';
16577
                                    string_buffer[bytes++] = 'f';
16578
                                    string_buffer[bytes++] = 'd';
16579
                                }
16580
                                else
16581
                                {
16582
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
16583
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
16584
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
16585
                                }
16586

16587
                                // write buffer and reset index; there must be 13 bytes
16588
                                // left, as this is the maximal number of bytes to be
16589
                                // written ("\uxxxx\uxxxx\0") for one code point
16590
                                if (string_buffer.size() - bytes < 13)
16591
                                {
16592
                                    o->write_characters(string_buffer.data(), bytes);
16593
                                    bytes = 0;
16594
                                }
16595

16596
                                bytes_after_last_accept = bytes;
16597
                            }
16598

16599
                            undumped_chars = 0;
16600

16601
                            // continue processing the string
16602
                            state = UTF8_ACCEPT;
16603
                            break;
16604
                        }
16605

16606
                        default:            // LCOV_EXCL_LINE
16607
                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16608
                    }
16609
                    break;
16610
                }
16611

16612
                default:  // decode found yet incomplete multi-byte code point
16613
                {
16614
                    if (!ensure_ascii)
16615
                    {
16616
                        // code point will not be escaped - copy byte to buffer
16617
                        string_buffer[bytes++] = s[i];
16618
                    }
16619
                    ++undumped_chars;
16620
                    break;
16621
                }
16622
            }
16623
        }
16624

16625
        // we finished processing the string
16626
        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16627
        {
16628
            // write buffer
16629
            if (bytes > 0)
16630
            {
16631
                o->write_characters(string_buffer.data(), bytes);
16632
            }
16633
        }
16634
        else
16635
        {
16636
            // we finish reading, but do not accept: string was incomplete
16637
            switch (error_handler)
16638
            {
16639
                case error_handler_t::strict:
16640
                {
16641
                    std::stringstream ss;
16642
                    ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (static_cast<std::uint8_t>(s.back()) | 0);
16643
                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str(), BasicJsonType()));
16644
                }
16645

16646
                case error_handler_t::ignore:
16647
                {
16648
                    // write all accepted bytes
16649
                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
16650
                    break;
16651
                }
16652

16653
                case error_handler_t::replace:
16654
                {
16655
                    // write all accepted bytes
16656
                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
16657
                    // add a replacement character
16658
                    if (ensure_ascii)
16659
                    {
16660
                        o->write_characters("\\ufffd", 6);
16661
                    }
16662
                    else
16663
                    {
16664
                        o->write_characters("\xEF\xBF\xBD", 3);
16665
                    }
16666
                    break;
16667
                }
16668

16669
                default:            // LCOV_EXCL_LINE
16670
                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16671
            }
16672
        }
16673
    }
16674

16675
  private:
16676
    /*!
16677
    @brief count digits
16678

16679
    Count the number of decimal (base 10) digits for an input unsigned integer.
16680

16681
    @param[in] x  unsigned integer number to count its digits
16682
    @return    number of decimal digits
16683
    */
16684
    inline unsigned int count_digits(number_unsigned_t x) noexcept
16685
    {
16686
        unsigned int n_digits = 1;
16687
        for (;;)
16688
        {
16689
            if (x < 10)
16690
            {
16691
                return n_digits;
16692
            }
16693
            if (x < 100)
16694
            {
16695
                return n_digits + 1;
16696
            }
16697
            if (x < 1000)
16698
            {
16699
                return n_digits + 2;
16700
            }
16701
            if (x < 10000)
16702
            {
16703
                return n_digits + 3;
16704
            }
16705
            x = x / 10000u;
16706
            n_digits += 4;
16707
        }
16708
    }
16709

16710
    // templates to avoid warnings about useless casts
16711
    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
16712
    bool is_negative_number(NumberType x)
16713
    {
16714
        return x < 0;
16715
    }
16716

16717
    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
16718
    bool is_negative_number(NumberType /*unused*/)
16719
    {
16720
        return false;
16721
    }
16722

16723
    /*!
16724
    @brief dump an integer
16725

16726
    Dump a given integer to output stream @a o. Works internally with
16727
    @a number_buffer.
16728

16729
    @param[in] x  integer number (signed or unsigned) to dump
16730
    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
16731
    */
16732
    template < typename NumberType, detail::enable_if_t <
16733
                   std::is_integral<NumberType>::value ||
16734
                   std::is_same<NumberType, number_unsigned_t>::value ||
16735
                   std::is_same<NumberType, number_integer_t>::value ||
16736
                   std::is_same<NumberType, binary_char_t>::value,
16737
                   int > = 0 >
16738
    void dump_integer(NumberType x)
16739
    {
16740
        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16741
        {
16742
            {
16743
                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
16744
                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
16745
                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
16746
                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
16747
                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
16748
                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
16749
                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
16750
                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
16751
                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
16752
                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
16753
            }
16754
        };
16755

16756
        // special case for "0"
16757
        if (x == 0)
16758
        {
16759
            o->write_character('0');
16760
            return;
16761
        }
16762

16763
        // use a pointer to fill the buffer
16764
        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16765

16766
        number_unsigned_t abs_value;
16767

16768
        unsigned int n_chars{};
16769

16770
        if (is_negative_number(x))
16771
        {
16772
            *buffer_ptr = '-';
16773
            abs_value = remove_sign(static_cast<number_integer_t>(x));
16774

16775
            // account one more byte for the minus sign
16776
            n_chars = 1 + count_digits(abs_value);
16777
        }
16778
        else
16779
        {
16780
            abs_value = static_cast<number_unsigned_t>(x);
16781
            n_chars = count_digits(abs_value);
16782
        }
16783

16784
        // spare 1 byte for '\0'
16785
        JSON_ASSERT(n_chars < number_buffer.size() - 1);
16786

16787
        // jump to the end to generate the string from backward,
16788
        // so we later avoid reversing the result
16789
        buffer_ptr += n_chars;
16790

16791
        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
16792
        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
16793
        while (abs_value >= 100)
16794
        {
16795
            const auto digits_index = static_cast<unsigned>((abs_value % 100));
16796
            abs_value /= 100;
16797
            *(--buffer_ptr) = digits_to_99[digits_index][1];
16798
            *(--buffer_ptr) = digits_to_99[digits_index][0];
16799
        }
16800

16801
        if (abs_value >= 10)
16802
        {
16803
            const auto digits_index = static_cast<unsigned>(abs_value);
16804
            *(--buffer_ptr) = digits_to_99[digits_index][1];
16805
            *(--buffer_ptr) = digits_to_99[digits_index][0];
16806
        }
16807
        else
16808
        {
16809
            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
16810
        }
16811

16812
        o->write_characters(number_buffer.data(), n_chars);
16813
    }
16814

16815
    /*!
16816
    @brief dump a floating-point number
16817

16818
    Dump a given floating-point number to output stream @a o. Works internally
16819
    with @a number_buffer.
16820

16821
    @param[in] x  floating-point number to dump
16822
    */
16823
    void dump_float(number_float_t x)
16824
    {
16825
        // NaN / inf
16826
        if (!std::isfinite(x))
16827
        {
16828
            o->write_characters("null", 4);
16829
            return;
16830
        }
16831

16832
        // If number_float_t is an IEEE-754 single or double precision number,
16833
        // use the Grisu2 algorithm to produce short numbers which are
16834
        // guaranteed to round-trip, using strtof and strtod, resp.
16835
        //
16836
        // NB: The test below works if <long double> == <double>.
16837
        static constexpr bool is_ieee_single_or_double
16838
            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
16839
              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
16840

16841
        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
16842
    }
16843

16844
    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
16845
    {
16846
        auto* begin = number_buffer.data();
16847
        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
16848

16849
        o->write_characters(begin, static_cast<size_t>(end - begin));
16850
    }
16851

16852
    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
16853
    {
16854
        // get number of digits for a float -> text -> float round-trip
16855
        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
16856

16857
        // the actual conversion
16858
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16859
        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
16860

16861
        // negative value indicates an error
16862
        JSON_ASSERT(len > 0);
16863
        // check if buffer was large enough
16864
        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
16865

16866
        // erase thousands separator
16867
        if (thousands_sep != '\0')
16868
        {
16869
            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
16870
            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
16871
            std::fill(end, number_buffer.end(), '\0');
16872
            JSON_ASSERT((end - number_buffer.begin()) <= len);
16873
            len = (end - number_buffer.begin());
16874
        }
16875

16876
        // convert decimal point to '.'
16877
        if (decimal_point != '\0' && decimal_point != '.')
16878
        {
16879
            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
16880
            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
16881
            if (dec_pos != number_buffer.end())
16882
            {
16883
                *dec_pos = '.';
16884
            }
16885
        }
16886

16887
        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
16888

16889
        // determine if we need to append ".0"
16890
        const bool value_is_int_like =
16891
            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
16892
                         [](char c)
16893
        {
16894
            return c == '.' || c == 'e';
16895
        });
16896

16897
        if (value_is_int_like)
16898
        {
16899
            o->write_characters(".0", 2);
16900
        }
16901
    }
16902

16903
    /*!
16904
    @brief check whether a string is UTF-8 encoded
16905

16906
    The function checks each byte of a string whether it is UTF-8 encoded. The
16907
    result of the check is stored in the @a state parameter. The function must
16908
    be called initially with state 0 (accept). State 1 means the string must
16909
    be rejected, because the current byte is not allowed. If the string is
16910
    completely processed, but the state is non-zero, the string ended
16911
    prematurely; that is, the last byte indicated more bytes should have
16912
    followed.
16913

16914
    @param[in,out] state  the state of the decoding
16915
    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
16916
    @param[in] byte       next byte to decode
16917
    @return               new state
16918

16919
    @note The function has been edited: a std::array is used.
16920

16921
    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <[email protected]>
16922
    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
16923
    */
16924
    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
16925
    {
16926
        static const std::array<std::uint8_t, 400> utf8d =
16927
        {
16928
            {
16929
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
16930
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
16931
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
16932
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
16933
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
16934
                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
16935
                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
16936
                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
16937
                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
16938
                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
16939
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
16940
                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
16941
                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
16942
                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
16943
            }
16944
        };
16945

16946
        JSON_ASSERT(byte < utf8d.size());
16947
        const std::uint8_t type = utf8d[byte];
16948

16949
        codep = (state != UTF8_ACCEPT)
16950
                ? (byte & 0x3fu) | (codep << 6u)
16951
                : (0xFFu >> type) & (byte);
16952

16953
        std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
16954
        JSON_ASSERT(index < 400);
16955
        state = utf8d[index];
16956
        return state;
16957
    }
16958

16959
    /*
16960
     * Overload to make the compiler happy while it is instantiating
16961
     * dump_integer for number_unsigned_t.
16962
     * Must never be called.
16963
     */
16964
    number_unsigned_t remove_sign(number_unsigned_t x)
16965
    {
16966
        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16967
        return x; // LCOV_EXCL_LINE
16968
    }
16969

16970
    /*
16971
     * Helper function for dump_integer
16972
     *
16973
     * This function takes a negative signed integer and returns its absolute
16974
     * value as unsigned integer. The plus/minus shuffling is necessary as we can
16975
     * not directly remove the sign of an arbitrary signed integer as the
16976
     * absolute values of INT_MIN and INT_MAX are usually not the same. See
16977
     * #1708 for details.
16978
     */
16979
    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
16980
    {
16981
        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
16982
        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
16983
    }
16984

16985
  private:
16986
    /// the output of the serializer
16987
    output_adapter_t<char> o = nullptr;
16988

16989
    /// a (hopefully) large enough character buffer
16990
    std::array<char, 64> number_buffer{{}};
16991

16992
    /// the locale
16993
    const std::lconv* loc = nullptr;
16994
    /// the locale's thousand separator character
16995
    const char thousands_sep = '\0';
16996
    /// the locale's decimal point character
16997
    const char decimal_point = '\0';
16998

16999
    /// string buffer
17000
    std::array<char, 512> string_buffer{{}};
17001

17002
    /// the indentation character
17003
    const char indent_char;
17004
    /// the indentation string
17005
    string_t indent_string;
17006

17007
    /// error_handler how to react on decoding errors
17008
    const error_handler_t error_handler;
17009
};
17010
}  // namespace detail
17011
}  // namespace nlohmann
17012

17013
// #include <nlohmann/detail/value_t.hpp>
17014

17015
// #include <nlohmann/json_fwd.hpp>
17016

17017
// #include <nlohmann/ordered_map.hpp>
17018

17019

17020
#include <functional> // less
17021
#include <initializer_list> // initializer_list
17022
#include <iterator> // input_iterator_tag, iterator_traits
17023
#include <memory> // allocator
17024
#include <stdexcept> // for out_of_range
17025
#include <type_traits> // enable_if, is_convertible
17026
#include <utility> // pair
17027
#include <vector> // vector
17028

17029
// #include <nlohmann/detail/macro_scope.hpp>
17030

17031

17032
namespace nlohmann
17033
{
17034

17035
/// ordered_map: a minimal map-like container that preserves insertion order
17036
/// for use within nlohmann::basic_json<ordered_map>
17037
template <class Key, class T, class IgnoredLess = std::less<Key>,
17038
          class Allocator = std::allocator<std::pair<const Key, T>>>
17039
                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
17040
{
17041
    using key_type = Key;
17042
    using mapped_type = T;
17043
    using Container = std::vector<std::pair<const Key, T>, Allocator>;
17044
    using iterator = typename Container::iterator;
17045
    using const_iterator = typename Container::const_iterator;
17046
    using size_type = typename Container::size_type;
17047
    using value_type = typename Container::value_type;
17048

17049
    // Explicit constructors instead of `using Container::Container`
17050
    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
17051
    ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
17052
    template <class It>
17053
    ordered_map(It first, It last, const Allocator& alloc = Allocator())
17054
        : Container{first, last, alloc} {}
17055
    ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
17056
        : Container{init, alloc} {}
17057

17058
    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
17059
    {
17060
        for (auto it = this->begin(); it != this->end(); ++it)
17061
        {
17062
            if (it->first == key)
17063
            {
17064
                return {it, false};
17065
            }
17066
        }
17067
        Container::emplace_back(key, t);
17068
        return {--this->end(), true};
17069
    }
17070

17071
    T& operator[](const Key& key)
17072
    {
17073
        return emplace(key, T{}).first->second;
17074
    }
17075

17076
    const T& operator[](const Key& key) const
17077
    {
17078
        return at(key);
17079
    }
17080

17081
    T& at(const Key& key)
17082
    {
17083
        for (auto it = this->begin(); it != this->end(); ++it)
17084
        {
17085
            if (it->first == key)
17086
            {
17087
                return it->second;
17088
            }
17089
        }
17090

17091
        JSON_THROW(std::out_of_range("key not found"));
17092
    }
17093

17094
    const T& at(const Key& key) const
17095
    {
17096
        for (auto it = this->begin(); it != this->end(); ++it)
17097
        {
17098
            if (it->first == key)
17099
            {
17100
                return it->second;
17101
            }
17102
        }
17103

17104
        JSON_THROW(std::out_of_range("key not found"));
17105
    }
17106

17107
    size_type erase(const Key& key)
17108
    {
17109
        for (auto it = this->begin(); it != this->end(); ++it)
17110
        {
17111
            if (it->first == key)
17112
            {
17113
                // Since we cannot move const Keys, re-construct them in place
17114
                for (auto next = it; ++next != this->end(); ++it)
17115
                {
17116
                    it->~value_type(); // Destroy but keep allocation
17117
                    new (&*it) value_type{std::move(*next)};
17118
                }
17119
                Container::pop_back();
17120
                return 1;
17121
            }
17122
        }
17123
        return 0;
17124
    }
17125

17126
    iterator erase(iterator pos)
17127
    {
17128
        return erase(pos, std::next(pos));
17129
    }
17130

17131
    iterator erase(iterator first, iterator last)
17132
    {
17133
        const auto elements_affected = std::distance(first, last);
17134
        const auto offset = std::distance(Container::begin(), first);
17135

17136
        // This is the start situation. We need to delete elements_affected
17137
        // elements (3 in this example: e, f, g), and need to return an
17138
        // iterator past the last deleted element (h in this example).
17139
        // Note that offset is the distance from the start of the vector
17140
        // to first. We will need this later.
17141

17142
        // [ a, b, c, d, e, f, g, h, i, j ]
17143
        //               ^        ^
17144
        //             first    last
17145

17146
        // Since we cannot move const Keys, we re-construct them in place.
17147
        // We start at first and re-construct (viz. copy) the elements from
17148
        // the back of the vector. Example for first iteration:
17149

17150
        //               ,--------.
17151
        //               v        |   destroy e and re-construct with h
17152
        // [ a, b, c, d, e, f, g, h, i, j ]
17153
        //               ^        ^
17154
        //               it       it + elements_affected
17155

17156
        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
17157
        {
17158
            it->~value_type(); // destroy but keep allocation
17159
            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
17160
        }
17161

17162
        // [ a, b, c, d, h, i, j, h, i, j ]
17163
        //               ^        ^
17164
        //             first    last
17165

17166
        // remove the unneeded elements at the end of the vector
17167
        Container::resize(this->size() - static_cast<size_type>(elements_affected));
17168

17169
        // [ a, b, c, d, h, i, j ]
17170
        //               ^        ^
17171
        //             first    last
17172

17173
        // first is now pointing past the last deleted element, but we cannot
17174
        // use this iterator, because it may have been invalidated by the
17175
        // resize call. Instead, we can return begin() + offset.
17176
        return Container::begin() + offset;
17177
    }
17178

17179
    size_type count(const Key& key) const
17180
    {
17181
        for (auto it = this->begin(); it != this->end(); ++it)
17182
        {
17183
            if (it->first == key)
17184
            {
17185
                return 1;
17186
            }
17187
        }
17188
        return 0;
17189
    }
17190

17191
    iterator find(const Key& key)
17192
    {
17193
        for (auto it = this->begin(); it != this->end(); ++it)
17194
        {
17195
            if (it->first == key)
17196
            {
17197
                return it;
17198
            }
17199
        }
17200
        return Container::end();
17201
    }
17202

17203
    const_iterator find(const Key& key) const
17204
    {
17205
        for (auto it = this->begin(); it != this->end(); ++it)
17206
        {
17207
            if (it->first == key)
17208
            {
17209
                return it;
17210
            }
17211
        }
17212
        return Container::end();
17213
    }
17214

17215
    std::pair<iterator, bool> insert( value_type&& value )
17216
    {
17217
        return emplace(value.first, std::move(value.second));
17218
    }
17219

17220
    std::pair<iterator, bool> insert( const value_type& value )
17221
    {
17222
        for (auto it = this->begin(); it != this->end(); ++it)
17223
        {
17224
            if (it->first == value.first)
17225
            {
17226
                return {it, false};
17227
            }
17228
        }
17229
        Container::push_back(value);
17230
        return {--this->end(), true};
17231
    }
17232

17233
    template<typename InputIt>
17234
    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
17235
            std::input_iterator_tag>::value>::type;
17236

17237
    template<typename InputIt, typename = require_input_iter<InputIt>>
17238
    void insert(InputIt first, InputIt last)
17239
    {
17240
        for (auto it = first; it != last; ++it)
17241
        {
17242
            insert(*it);
17243
        }
17244
    }
17245
};
17246

17247
}  // namespace nlohmann
17248

17249

17250
#if defined(JSON_HAS_CPP_17)
17251
    #include <string_view>
17252
#endif
17253

17254
/*!
17255
@brief namespace for Niels Lohmann
17256
@see https://github.com/nlohmann
17257
@since version 1.0.0
17258
*/
17259
namespace nlohmann
17260
{
17261

17262
/*!
17263
@brief a class to store JSON values
17264

17265
@internal
17266
@invariant The member variables @a m_value and @a m_type have the following
17267
relationship:
17268
- If `m_type == value_t::object`, then `m_value.object != nullptr`.
17269
- If `m_type == value_t::array`, then `m_value.array != nullptr`.
17270
- If `m_type == value_t::string`, then `m_value.string != nullptr`.
17271
The invariants are checked by member function assert_invariant().
17272

17273
@note ObjectType trick from https://stackoverflow.com/a/9860911
17274
@endinternal
17275

17276
@since version 1.0.0
17277

17278
@nosubgrouping
17279
*/
17280
NLOHMANN_BASIC_JSON_TPL_DECLARATION
17281
class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
17282
{
17283
  private:
17284
    template<detail::value_t> friend struct detail::external_constructor;
17285
    friend ::nlohmann::json_pointer<basic_json>;
17286

17287
    template<typename BasicJsonType, typename InputType>
17288
    friend class ::nlohmann::detail::parser;
17289
    friend ::nlohmann::detail::serializer<basic_json>;
17290
    template<typename BasicJsonType>
17291
    friend class ::nlohmann::detail::iter_impl;
17292
    template<typename BasicJsonType, typename CharType>
17293
    friend class ::nlohmann::detail::binary_writer;
17294
    template<typename BasicJsonType, typename InputType, typename SAX>
17295
    friend class ::nlohmann::detail::binary_reader;
17296
    template<typename BasicJsonType>
17297
    friend class ::nlohmann::detail::json_sax_dom_parser;
17298
    template<typename BasicJsonType>
17299
    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
17300
    friend class ::nlohmann::detail::exception;
17301

17302
    /// workaround type for MSVC
17303
    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
17304

17305
  JSON_PRIVATE_UNLESS_TESTED:
17306
    // convenience aliases for types residing in namespace detail;
17307
    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
17308

17309
    template<typename InputAdapterType>
17310
    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
17311
        InputAdapterType adapter,
17312
        detail::parser_callback_t<basic_json>cb = nullptr,
17313
        const bool allow_exceptions = true,
17314
        const bool ignore_comments = false
17315
                                 )
17316
    {
17317
        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
17318
                std::move(cb), allow_exceptions, ignore_comments);
17319
    }
17320

17321
  private:
17322
    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
17323
    template<typename BasicJsonType>
17324
    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
17325
    template<typename BasicJsonType>
17326
    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
17327
    template<typename Iterator>
17328
    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
17329
    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
17330

17331
    template<typename CharType>
17332
    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
17333

17334
    template<typename InputType>
17335
    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
17336
    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
17337

17338
  JSON_PRIVATE_UNLESS_TESTED:
17339
    using serializer = ::nlohmann::detail::serializer<basic_json>;
17340

17341
  public:
17342
    using value_t = detail::value_t;
17343
    /// JSON Pointer, see @ref nlohmann::json_pointer
17344
    using json_pointer = ::nlohmann::json_pointer<basic_json>;
17345
    template<typename T, typename SFINAE>
17346
    using json_serializer = JSONSerializer<T, SFINAE>;
17347
    /// how to treat decoding errors
17348
    using error_handler_t = detail::error_handler_t;
17349
    /// how to treat CBOR tags
17350
    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
17351
    /// helper type for initializer lists of basic_json values
17352
    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
17353

17354
    using input_format_t = detail::input_format_t;
17355
    /// SAX interface type, see @ref nlohmann::json_sax
17356
    using json_sax_t = json_sax<basic_json>;
17357

17358
    ////////////////
17359
    // exceptions //
17360
    ////////////////
17361

17362
    /// @name exceptions
17363
    /// Classes to implement user-defined exceptions.
17364
    /// @{
17365

17366
    using exception = detail::exception;
17367
    using parse_error = detail::parse_error;
17368
    using invalid_iterator = detail::invalid_iterator;
17369
    using type_error = detail::type_error;
17370
    using out_of_range = detail::out_of_range;
17371
    using other_error = detail::other_error;
17372

17373
    /// @}
17374

17375

17376
    /////////////////////
17377
    // container types //
17378
    /////////////////////
17379

17380
    /// @name container types
17381
    /// The canonic container types to use @ref basic_json like any other STL
17382
    /// container.
17383
    /// @{
17384

17385
    /// the type of elements in a basic_json container
17386
    using value_type = basic_json;
17387

17388
    /// the type of an element reference
17389
    using reference = value_type&;
17390
    /// the type of an element const reference
17391
    using const_reference = const value_type&;
17392

17393
    /// a type to represent differences between iterators
17394
    using difference_type = std::ptrdiff_t;
17395
    /// a type to represent container sizes
17396
    using size_type = std::size_t;
17397

17398
    /// the allocator type
17399
    using allocator_type = AllocatorType<basic_json>;
17400

17401
    /// the type of an element pointer
17402
    using pointer = typename std::allocator_traits<allocator_type>::pointer;
17403
    /// the type of an element const pointer
17404
    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
17405

17406
    /// an iterator for a basic_json container
17407
    using iterator = iter_impl<basic_json>;
17408
    /// a const iterator for a basic_json container
17409
    using const_iterator = iter_impl<const basic_json>;
17410
    /// a reverse iterator for a basic_json container
17411
    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
17412
    /// a const reverse iterator for a basic_json container
17413
    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
17414

17415
    /// @}
17416

17417

17418
    /// @brief returns the allocator associated with the container
17419
    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
17420
    static allocator_type get_allocator()
17421
    {
17422
        return allocator_type();
17423
    }
17424

17425
    /// @brief returns version information on the library
17426
    /// @sa https://json.nlohmann.me/api/basic_json/meta/
17427
    JSON_HEDLEY_WARN_UNUSED_RESULT
17428
    static basic_json meta()
17429
    {
17430
        basic_json result;
17431

17432
        result["copyright"] = "(C) 2013-2022 Niels Lohmann";
17433
        result["name"] = "JSON for Modern C++";
17434
        result["url"] = "https://github.com/nlohmann/json";
17435
        result["version"]["string"] =
17436
            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
17437
            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
17438
            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
17439
        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
17440
        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
17441
        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
17442

17443
#ifdef _WIN32
17444
        result["platform"] = "win32";
17445
#elif defined __linux__
17446
        result["platform"] = "linux";
17447
#elif defined __APPLE__
17448
        result["platform"] = "apple";
17449
#elif defined __unix__
17450
        result["platform"] = "unix";
17451
#else
17452
        result["platform"] = "unknown";
17453
#endif
17454

17455
#if defined(__ICC) || defined(__INTEL_COMPILER)
17456
        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
17457
#elif defined(__clang__)
17458
        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
17459
#elif defined(__GNUC__) || defined(__GNUG__)
17460
        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
17461
#elif defined(__HP_cc) || defined(__HP_aCC)
17462
        result["compiler"] = "hp"
17463
#elif defined(__IBMCPP__)
17464
        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
17465
#elif defined(_MSC_VER)
17466
        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
17467
#elif defined(__PGI)
17468
        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
17469
#elif defined(__SUNPRO_CC)
17470
        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
17471
#else
17472
        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
17473
#endif
17474

17475
#ifdef __cplusplus
17476
        result["compiler"]["c++"] = std::to_string(__cplusplus);
17477
#else
17478
        result["compiler"]["c++"] = "unknown";
17479
#endif
17480
        return result;
17481
    }
17482

17483

17484
    ///////////////////////////
17485
    // JSON value data types //
17486
    ///////////////////////////
17487

17488
    /// @name JSON value data types
17489
    /// The data types to store a JSON value. These types are derived from
17490
    /// the template arguments passed to class @ref basic_json.
17491
    /// @{
17492

17493
    /// @brief object key comparator type
17494
    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
17495
#if defined(JSON_HAS_CPP_14)
17496
    // Use transparent comparator if possible, combined with perfect forwarding
17497
    // on find() and count() calls prevents unnecessary string construction.
17498
    using object_comparator_t = std::less<>;
17499
#else
17500
    using object_comparator_t = std::less<StringType>;
17501
#endif
17502

17503
    /// @brief a type for an object
17504
    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
17505
    using object_t = ObjectType<StringType,
17506
          basic_json,
17507
          object_comparator_t,
17508
          AllocatorType<std::pair<const StringType,
17509
          basic_json>>>;
17510

17511
    /// @brief a type for an array
17512
    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
17513
    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
17514

17515
    /// @brief a type for a string
17516
    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
17517
    using string_t = StringType;
17518

17519
    /// @brief a type for a boolean
17520
    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
17521
    using boolean_t = BooleanType;
17522

17523
    /// @brief a type for a number (integer)
17524
    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
17525
    using number_integer_t = NumberIntegerType;
17526

17527
    /// @brief a type for a number (unsigned)
17528
    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
17529
    using number_unsigned_t = NumberUnsignedType;
17530

17531
    /// @brief a type for a number (floating-point)
17532
    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
17533
    using number_float_t = NumberFloatType;
17534

17535
    /// @brief a type for a packed binary type
17536
    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
17537
    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
17538

17539
    /// @}
17540

17541
  private:
17542

17543
    /// helper for exception-safe object creation
17544
    template<typename T, typename... Args>
17545
    JSON_HEDLEY_RETURNS_NON_NULL
17546
    static T* create(Args&& ... args)
17547
    {
17548
        AllocatorType<T> alloc;
17549
        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
17550

17551
        auto deleter = [&](T * obj)
17552
        {
17553
            AllocatorTraits::deallocate(alloc, obj, 1);
17554
        };
17555
        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
17556
        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
17557
        JSON_ASSERT(obj != nullptr);
17558
        return obj.release();
17559
    }
17560

17561
    ////////////////////////
17562
    // JSON value storage //
17563
    ////////////////////////
17564

17565
  JSON_PRIVATE_UNLESS_TESTED:
17566
    /*!
17567
    @brief a JSON value
17568

17569
    The actual storage for a JSON value of the @ref basic_json class. This
17570
    union combines the different storage types for the JSON value types
17571
    defined in @ref value_t.
17572

17573
    JSON type | value_t type    | used type
17574
    --------- | --------------- | ------------------------
17575
    object    | object          | pointer to @ref object_t
17576
    array     | array           | pointer to @ref array_t
17577
    string    | string          | pointer to @ref string_t
17578
    boolean   | boolean         | @ref boolean_t
17579
    number    | number_integer  | @ref number_integer_t
17580
    number    | number_unsigned | @ref number_unsigned_t
17581
    number    | number_float    | @ref number_float_t
17582
    binary    | binary          | pointer to @ref binary_t
17583
    null      | null            | *no value is stored*
17584

17585
    @note Variable-length types (objects, arrays, and strings) are stored as
17586
    pointers. The size of the union should not exceed 64 bits if the default
17587
    value types are used.
17588

17589
    @since version 1.0.0
17590
    */
17591
    union json_value
17592
    {
17593
        /// object (stored with pointer to save storage)
17594
        object_t* object;
17595
        /// array (stored with pointer to save storage)
17596
        array_t* array;
17597
        /// string (stored with pointer to save storage)
17598
        string_t* string;
17599
        /// binary (stored with pointer to save storage)
17600
        binary_t* binary;
17601
        /// boolean
17602
        boolean_t boolean;
17603
        /// number (integer)
17604
        number_integer_t number_integer;
17605
        /// number (unsigned integer)
17606
        number_unsigned_t number_unsigned;
17607
        /// number (floating-point)
17608
        number_float_t number_float;
17609

17610
        /// default constructor (for null values)
17611
        json_value() = default;
17612
        /// constructor for booleans
17613
        json_value(boolean_t v) noexcept : boolean(v) {}
17614
        /// constructor for numbers (integer)
17615
        json_value(number_integer_t v) noexcept : number_integer(v) {}
17616
        /// constructor for numbers (unsigned)
17617
        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
17618
        /// constructor for numbers (floating-point)
17619
        json_value(number_float_t v) noexcept : number_float(v) {}
17620
        /// constructor for empty values of a given type
17621
        json_value(value_t t)
17622
        {
17623
            switch (t)
17624
            {
17625
                case value_t::object:
17626
                {
17627
                    object = create<object_t>();
17628
                    break;
17629
                }
17630

17631
                case value_t::array:
17632
                {
17633
                    array = create<array_t>();
17634
                    break;
17635
                }
17636

17637
                case value_t::string:
17638
                {
17639
                    string = create<string_t>("");
17640
                    break;
17641
                }
17642

17643
                case value_t::binary:
17644
                {
17645
                    binary = create<binary_t>();
17646
                    break;
17647
                }
17648

17649
                case value_t::boolean:
17650
                {
17651
                    boolean = static_cast<boolean_t>(false);
17652
                    break;
17653
                }
17654

17655
                case value_t::number_integer:
17656
                {
17657
                    number_integer = static_cast<number_integer_t>(0);
17658
                    break;
17659
                }
17660

17661
                case value_t::number_unsigned:
17662
                {
17663
                    number_unsigned = static_cast<number_unsigned_t>(0);
17664
                    break;
17665
                }
17666

17667
                case value_t::number_float:
17668
                {
17669
                    number_float = static_cast<number_float_t>(0.0);
17670
                    break;
17671
                }
17672

17673
                case value_t::null:
17674
                {
17675
                    object = nullptr;  // silence warning, see #821
17676
                    break;
17677
                }
17678

17679
                case value_t::discarded:
17680
                default:
17681
                {
17682
                    object = nullptr;  // silence warning, see #821
17683
                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
17684
                    {
17685
                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.10.5", basic_json())); // LCOV_EXCL_LINE
17686
                    }
17687
                    break;
17688
                }
17689
            }
17690
        }
17691

17692
        /// constructor for strings
17693
        json_value(const string_t& value) : string(create<string_t>(value)) {}
17694

17695
        /// constructor for rvalue strings
17696
        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
17697

17698
        /// constructor for objects
17699
        json_value(const object_t& value) : object(create<object_t>(value)) {}
17700

17701
        /// constructor for rvalue objects
17702
        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
17703

17704
        /// constructor for arrays
17705
        json_value(const array_t& value) : array(create<array_t>(value)) {}
17706

17707
        /// constructor for rvalue arrays
17708
        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
17709

17710
        /// constructor for binary arrays
17711
        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
17712

17713
        /// constructor for rvalue binary arrays
17714
        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
17715

17716
        /// constructor for binary arrays (internal type)
17717
        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
17718

17719
        /// constructor for rvalue binary arrays (internal type)
17720
        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
17721

17722
        void destroy(value_t t)
17723
        {
17724
            if (t == value_t::array || t == value_t::object)
17725
            {
17726
                // flatten the current json_value to a heap-allocated stack
17727
                std::vector<basic_json> stack;
17728

17729
                // move the top-level items to stack
17730
                if (t == value_t::array)
17731
                {
17732
                    stack.reserve(array->size());
17733
                    std::move(array->begin(), array->end(), std::back_inserter(stack));
17734
                }
17735
                else
17736
                {
17737
                    stack.reserve(object->size());
17738
                    for (auto&& it : *object)
17739
                    {
17740
                        stack.push_back(std::move(it.second));
17741
                    }
17742
                }
17743

17744
                while (!stack.empty())
17745
                {
17746
                    // move the last item to local variable to be processed
17747
                    basic_json current_item(std::move(stack.back()));
17748
                    stack.pop_back();
17749

17750
                    // if current_item is array/object, move
17751
                    // its children to the stack to be processed later
17752
                    if (current_item.is_array())
17753
                    {
17754
                        std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
17755

17756
                        current_item.m_value.array->clear();
17757
                    }
17758
                    else if (current_item.is_object())
17759
                    {
17760
                        for (auto&& it : *current_item.m_value.object)
17761
                        {
17762
                            stack.push_back(std::move(it.second));
17763
                        }
17764

17765
                        current_item.m_value.object->clear();
17766
                    }
17767

17768
                    // it's now safe that current_item get destructed
17769
                    // since it doesn't have any children
17770
                }
17771
            }
17772

17773
            switch (t)
17774
            {
17775
                case value_t::object:
17776
                {
17777
                    AllocatorType<object_t> alloc;
17778
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
17779
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
17780
                    break;
17781
                }
17782

17783
                case value_t::array:
17784
                {
17785
                    AllocatorType<array_t> alloc;
17786
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
17787
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
17788
                    break;
17789
                }
17790

17791
                case value_t::string:
17792
                {
17793
                    AllocatorType<string_t> alloc;
17794
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
17795
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
17796
                    break;
17797
                }
17798

17799
                case value_t::binary:
17800
                {
17801
                    AllocatorType<binary_t> alloc;
17802
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
17803
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
17804
                    break;
17805
                }
17806

17807
                case value_t::null:
17808
                case value_t::boolean:
17809
                case value_t::number_integer:
17810
                case value_t::number_unsigned:
17811
                case value_t::number_float:
17812
                case value_t::discarded:
17813
                default:
17814
                {
17815
                    break;
17816
                }
17817
            }
17818
        }
17819
    };
17820

17821
  private:
17822
    /*!
17823
    @brief checks the class invariants
17824

17825
    This function asserts the class invariants. It needs to be called at the
17826
    end of every constructor to make sure that created objects respect the
17827
    invariant. Furthermore, it has to be called each time the type of a JSON
17828
    value is changed, because the invariant expresses a relationship between
17829
    @a m_type and @a m_value.
17830

17831
    Furthermore, the parent relation is checked for arrays and objects: If
17832
    @a check_parents true and the value is an array or object, then the
17833
    container's elements must have the current value as parent.
17834

17835
    @param[in] check_parents  whether the parent relation should be checked.
17836
               The value is true by default and should only be set to false
17837
               during destruction of objects when the invariant does not
17838
               need to hold.
17839
    */
17840
    void assert_invariant(bool check_parents = true) const noexcept
17841
    {
17842
        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
17843
        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
17844
        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
17845
        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
17846

17847
#if JSON_DIAGNOSTICS
17848
        JSON_TRY
17849
        {
17850
            // cppcheck-suppress assertWithSideEffect
17851
            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
17852
            {
17853
                return j.m_parent == this;
17854
            }));
17855
        }
17856
        JSON_CATCH(...) {} // LCOV_EXCL_LINE
17857
#endif
17858
        static_cast<void>(check_parents);
17859
    }
17860

17861
    void set_parents()
17862
    {
17863
#if JSON_DIAGNOSTICS
17864
        switch (m_type)
17865
        {
17866
            case value_t::array:
17867
            {
17868
                for (auto& element : *m_value.array)
17869
                {
17870
                    element.m_parent = this;
17871
                }
17872
                break;
17873
            }
17874

17875
            case value_t::object:
17876
            {
17877
                for (auto& element : *m_value.object)
17878
                {
17879
                    element.second.m_parent = this;
17880
                }
17881
                break;
17882
            }
17883

17884
            case value_t::null:
17885
            case value_t::string:
17886
            case value_t::boolean:
17887
            case value_t::number_integer:
17888
            case value_t::number_unsigned:
17889
            case value_t::number_float:
17890
            case value_t::binary:
17891
            case value_t::discarded:
17892
            default:
17893
                break;
17894
        }
17895
#endif
17896
    }
17897

17898
    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
17899
    {
17900
#if JSON_DIAGNOSTICS
17901
        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
17902
        {
17903
            (it + i)->m_parent = this;
17904
        }
17905
#else
17906
        static_cast<void>(count_set_parents);
17907
#endif
17908
        return it;
17909
    }
17910

17911
    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
17912
    {
17913
#if JSON_DIAGNOSTICS
17914
        if (old_capacity != static_cast<std::size_t>(-1))
17915
        {
17916
            // see https://github.com/nlohmann/json/issues/2838
17917
            JSON_ASSERT(type() == value_t::array);
17918
            if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
17919
            {
17920
                // capacity has changed: update all parents
17921
                set_parents();
17922
                return j;
17923
            }
17924
        }
17925

17926
        // ordered_json uses a vector internally, so pointers could have
17927
        // been invalidated; see https://github.com/nlohmann/json/issues/2962
17928
#ifdef JSON_HEDLEY_MSVC_VERSION
17929
#pragma warning(push )
17930
#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
17931
#endif
17932
        if (detail::is_ordered_map<object_t>::value)
17933
        {
17934
            set_parents();
17935
            return j;
17936
        }
17937
#ifdef JSON_HEDLEY_MSVC_VERSION
17938
#pragma warning( pop )
17939
#endif
17940

17941
        j.m_parent = this;
17942
#else
17943
        static_cast<void>(j);
17944
        static_cast<void>(old_capacity);
17945
#endif
17946
        return j;
17947
    }
17948

17949
  public:
17950
    //////////////////////////
17951
    // JSON parser callback //
17952
    //////////////////////////
17953

17954
    /// @brief parser event types
17955
    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
17956
    using parse_event_t = detail::parse_event_t;
17957

17958
    /// @brief per-element parser callback type
17959
    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
17960
    using parser_callback_t = detail::parser_callback_t<basic_json>;
17961

17962
    //////////////////
17963
    // constructors //
17964
    //////////////////
17965

17966
    /// @name constructors and destructors
17967
    /// Constructors of class @ref basic_json, copy/move constructor, copy
17968
    /// assignment, static functions creating objects, and the destructor.
17969
    /// @{
17970

17971
    /// @brief create an empty value with a given type
17972
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
17973
    basic_json(const value_t v)
17974
        : m_type(v), m_value(v)
17975
    {
17976
        assert_invariant();
17977
    }
17978

17979
    /// @brief create a null object
17980
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
17981
    basic_json(std::nullptr_t = nullptr) noexcept
17982
        : basic_json(value_t::null)
17983
    {
17984
        assert_invariant();
17985
    }
17986

17987
    /// @brief create a JSON value from compatible types
17988
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
17989
    template < typename CompatibleType,
17990
               typename U = detail::uncvref_t<CompatibleType>,
17991
               detail::enable_if_t <
17992
                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
17993
    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
17994
                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
17995
                                           std::forward<CompatibleType>(val))))
17996
    {
17997
        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
17998
        set_parents();
17999
        assert_invariant();
18000
    }
18001

18002
    /// @brief create a JSON value from an existing one
18003
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18004
    template < typename BasicJsonType,
18005
               detail::enable_if_t <
18006
                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
18007
    basic_json(const BasicJsonType& val)
18008
    {
18009
        using other_boolean_t = typename BasicJsonType::boolean_t;
18010
        using other_number_float_t = typename BasicJsonType::number_float_t;
18011
        using other_number_integer_t = typename BasicJsonType::number_integer_t;
18012
        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
18013
        using other_string_t = typename BasicJsonType::string_t;
18014
        using other_object_t = typename BasicJsonType::object_t;
18015
        using other_array_t = typename BasicJsonType::array_t;
18016
        using other_binary_t = typename BasicJsonType::binary_t;
18017

18018
        switch (val.type())
18019
        {
18020
            case value_t::boolean:
18021
                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
18022
                break;
18023
            case value_t::number_float:
18024
                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
18025
                break;
18026
            case value_t::number_integer:
18027
                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
18028
                break;
18029
            case value_t::number_unsigned:
18030
                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
18031
                break;
18032
            case value_t::string:
18033
                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
18034
                break;
18035
            case value_t::object:
18036
                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
18037
                break;
18038
            case value_t::array:
18039
                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
18040
                break;
18041
            case value_t::binary:
18042
                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
18043
                break;
18044
            case value_t::null:
18045
                *this = nullptr;
18046
                break;
18047
            case value_t::discarded:
18048
                m_type = value_t::discarded;
18049
                break;
18050
            default:            // LCOV_EXCL_LINE
18051
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
18052
        }
18053
        set_parents();
18054
        assert_invariant();
18055
    }
18056

18057
    /// @brief create a container (array or object) from an initializer list
18058
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18059
    basic_json(initializer_list_t init,
18060
               bool type_deduction = true,
18061
               value_t manual_type = value_t::array)
18062
    {
18063
        // check if each element is an array with two elements whose first
18064
        // element is a string
18065
        bool is_an_object = std::all_of(init.begin(), init.end(),
18066
                                        [](const detail::json_ref<basic_json>& element_ref)
18067
        {
18068
            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
18069
        });
18070

18071
        // adjust type if type deduction is not wanted
18072
        if (!type_deduction)
18073
        {
18074
            // if array is wanted, do not create an object though possible
18075
            if (manual_type == value_t::array)
18076
            {
18077
                is_an_object = false;
18078
            }
18079

18080
            // if object is wanted but impossible, throw an exception
18081
            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
18082
            {
18083
                JSON_THROW(type_error::create(301, "cannot create object from initializer list", basic_json()));
18084
            }
18085
        }
18086

18087
        if (is_an_object)
18088
        {
18089
            // the initializer list is a list of pairs -> create object
18090
            m_type = value_t::object;
18091
            m_value = value_t::object;
18092

18093
            for (auto& element_ref : init)
18094
            {
18095
                auto element = element_ref.moved_or_copied();
18096
                m_value.object->emplace(
18097
                    std::move(*((*element.m_value.array)[0].m_value.string)),
18098
                    std::move((*element.m_value.array)[1]));
18099
            }
18100
        }
18101
        else
18102
        {
18103
            // the initializer list describes an array -> create array
18104
            m_type = value_t::array;
18105
            m_value.array = create<array_t>(init.begin(), init.end());
18106
        }
18107

18108
        set_parents();
18109
        assert_invariant();
18110
    }
18111

18112
    /// @brief explicitly create a binary array (without subtype)
18113
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
18114
    JSON_HEDLEY_WARN_UNUSED_RESULT
18115
    static basic_json binary(const typename binary_t::container_type& init)
18116
    {
18117
        auto res = basic_json();
18118
        res.m_type = value_t::binary;
18119
        res.m_value = init;
18120
        return res;
18121
    }
18122

18123
    /// @brief explicitly create a binary array (with subtype)
18124
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
18125
    JSON_HEDLEY_WARN_UNUSED_RESULT
18126
    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
18127
    {
18128
        auto res = basic_json();
18129
        res.m_type = value_t::binary;
18130
        res.m_value = binary_t(init, subtype);
18131
        return res;
18132
    }
18133

18134
    /// @brief explicitly create a binary array
18135
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
18136
    JSON_HEDLEY_WARN_UNUSED_RESULT
18137
    static basic_json binary(typename binary_t::container_type&& init)
18138
    {
18139
        auto res = basic_json();
18140
        res.m_type = value_t::binary;
18141
        res.m_value = std::move(init);
18142
        return res;
18143
    }
18144

18145
    /// @brief explicitly create a binary array (with subtype)
18146
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
18147
    JSON_HEDLEY_WARN_UNUSED_RESULT
18148
    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
18149
    {
18150
        auto res = basic_json();
18151
        res.m_type = value_t::binary;
18152
        res.m_value = binary_t(std::move(init), subtype);
18153
        return res;
18154
    }
18155

18156
    /// @brief explicitly create an array from an initializer list
18157
    /// @sa https://json.nlohmann.me/api/basic_json/array/
18158
    JSON_HEDLEY_WARN_UNUSED_RESULT
18159
    static basic_json array(initializer_list_t init = {})
18160
    {
18161
        return basic_json(init, false, value_t::array);
18162
    }
18163

18164
    /// @brief explicitly create an object from an initializer list
18165
    /// @sa https://json.nlohmann.me/api/basic_json/object/
18166
    JSON_HEDLEY_WARN_UNUSED_RESULT
18167
    static basic_json object(initializer_list_t init = {})
18168
    {
18169
        return basic_json(init, false, value_t::object);
18170
    }
18171

18172
    /// @brief construct an array with count copies of given value
18173
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18174
    basic_json(size_type cnt, const basic_json& val)
18175
        : m_type(value_t::array)
18176
    {
18177
        m_value.array = create<array_t>(cnt, val);
18178
        set_parents();
18179
        assert_invariant();
18180
    }
18181

18182
    /// @brief construct a JSON container given an iterator range
18183
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18184
    template < class InputIT, typename std::enable_if <
18185
                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
18186
                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
18187
    basic_json(InputIT first, InputIT last)
18188
    {
18189
        JSON_ASSERT(first.m_object != nullptr);
18190
        JSON_ASSERT(last.m_object != nullptr);
18191

18192
        // make sure iterator fits the current value
18193
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
18194
        {
18195
            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", basic_json()));
18196
        }
18197

18198
        // copy type from first iterator
18199
        m_type = first.m_object->m_type;
18200

18201
        // check if iterator range is complete for primitive values
18202
        switch (m_type)
18203
        {
18204
            case value_t::boolean:
18205
            case value_t::number_float:
18206
            case value_t::number_integer:
18207
            case value_t::number_unsigned:
18208
            case value_t::string:
18209
            {
18210
                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
18211
                                         || !last.m_it.primitive_iterator.is_end()))
18212
                {
18213
                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", *first.m_object));
18214
                }
18215
                break;
18216
            }
18217

18218
            case value_t::null:
18219
            case value_t::object:
18220
            case value_t::array:
18221
            case value_t::binary:
18222
            case value_t::discarded:
18223
            default:
18224
                break;
18225
        }
18226

18227
        switch (m_type)
18228
        {
18229
            case value_t::number_integer:
18230
            {
18231
                m_value.number_integer = first.m_object->m_value.number_integer;
18232
                break;
18233
            }
18234

18235
            case value_t::number_unsigned:
18236
            {
18237
                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
18238
                break;
18239
            }
18240

18241
            case value_t::number_float:
18242
            {
18243
                m_value.number_float = first.m_object->m_value.number_float;
18244
                break;
18245
            }
18246

18247
            case value_t::boolean:
18248
            {
18249
                m_value.boolean = first.m_object->m_value.boolean;
18250
                break;
18251
            }
18252

18253
            case value_t::string:
18254
            {
18255
                m_value = *first.m_object->m_value.string;
18256
                break;
18257
            }
18258

18259
            case value_t::object:
18260
            {
18261
                m_value.object = create<object_t>(first.m_it.object_iterator,
18262
                                                  last.m_it.object_iterator);
18263
                break;
18264
            }
18265

18266
            case value_t::array:
18267
            {
18268
                m_value.array = create<array_t>(first.m_it.array_iterator,
18269
                                                last.m_it.array_iterator);
18270
                break;
18271
            }
18272

18273
            case value_t::binary:
18274
            {
18275
                m_value = *first.m_object->m_value.binary;
18276
                break;
18277
            }
18278

18279
            case value_t::null:
18280
            case value_t::discarded:
18281
            default:
18282
                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
18283
        }
18284

18285
        set_parents();
18286
        assert_invariant();
18287
    }
18288

18289

18290
    ///////////////////////////////////////
18291
    // other constructors and destructor //
18292
    ///////////////////////////////////////
18293

18294
    template<typename JsonRef,
18295
             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
18296
                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
18297
    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
18298

18299
    /// @brief copy constructor
18300
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18301
    basic_json(const basic_json& other)
18302
        : m_type(other.m_type)
18303
    {
18304
        // check of passed value is valid
18305
        other.assert_invariant();
18306

18307
        switch (m_type)
18308
        {
18309
            case value_t::object:
18310
            {
18311
                m_value = *other.m_value.object;
18312
                break;
18313
            }
18314

18315
            case value_t::array:
18316
            {
18317
                m_value = *other.m_value.array;
18318
                break;
18319
            }
18320

18321
            case value_t::string:
18322
            {
18323
                m_value = *other.m_value.string;
18324
                break;
18325
            }
18326

18327
            case value_t::boolean:
18328
            {
18329
                m_value = other.m_value.boolean;
18330
                break;
18331
            }
18332

18333
            case value_t::number_integer:
18334
            {
18335
                m_value = other.m_value.number_integer;
18336
                break;
18337
            }
18338

18339
            case value_t::number_unsigned:
18340
            {
18341
                m_value = other.m_value.number_unsigned;
18342
                break;
18343
            }
18344

18345
            case value_t::number_float:
18346
            {
18347
                m_value = other.m_value.number_float;
18348
                break;
18349
            }
18350

18351
            case value_t::binary:
18352
            {
18353
                m_value = *other.m_value.binary;
18354
                break;
18355
            }
18356

18357
            case value_t::null:
18358
            case value_t::discarded:
18359
            default:
18360
                break;
18361
        }
18362

18363
        set_parents();
18364
        assert_invariant();
18365
    }
18366

18367
    /// @brief move constructor
18368
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18369
    basic_json(basic_json&& other) noexcept
18370
        : m_type(std::move(other.m_type)),
18371
          m_value(std::move(other.m_value))
18372
    {
18373
        // check that passed value is valid
18374
        other.assert_invariant(false);
18375

18376
        // invalidate payload
18377
        other.m_type = value_t::null;
18378
        other.m_value = {};
18379

18380
        set_parents();
18381
        assert_invariant();
18382
    }
18383

18384
    /// @brief copy assignment
18385
    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
18386
    basic_json& operator=(basic_json other) noexcept (
18387
        std::is_nothrow_move_constructible<value_t>::value&&
18388
        std::is_nothrow_move_assignable<value_t>::value&&
18389
        std::is_nothrow_move_constructible<json_value>::value&&
18390
        std::is_nothrow_move_assignable<json_value>::value
18391
    )
18392
    {
18393
        // check that passed value is valid
18394
        other.assert_invariant();
18395

18396
        using std::swap;
18397
        swap(m_type, other.m_type);
18398
        swap(m_value, other.m_value);
18399

18400
        set_parents();
18401
        assert_invariant();
18402
        return *this;
18403
    }
18404

18405
    /// @brief destructor
18406
    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
18407
    ~basic_json() noexcept
18408
    {
18409
        assert_invariant(false);
18410
        m_value.destroy(m_type);
18411
    }
18412

18413
    /// @}
18414

18415
  public:
18416
    ///////////////////////
18417
    // object inspection //
18418
    ///////////////////////
18419

18420
    /// @name object inspection
18421
    /// Functions to inspect the type of a JSON value.
18422
    /// @{
18423

18424
    /// @brief serialization
18425
    /// @sa https://json.nlohmann.me/api/basic_json/dump/
18426
    string_t dump(const int indent = -1,
18427
                  const char indent_char = ' ',
18428
                  const bool ensure_ascii = false,
18429
                  const error_handler_t error_handler = error_handler_t::strict) const
18430
    {
18431
        string_t result;
18432
        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
18433

18434
        if (indent >= 0)
18435
        {
18436
            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
18437
        }
18438
        else
18439
        {
18440
            s.dump(*this, false, ensure_ascii, 0);
18441
        }
18442

18443
        return result;
18444
    }
18445

18446
    /// @brief return the type of the JSON value (explicit)
18447
    /// @sa https://json.nlohmann.me/api/basic_json/type/
18448
    constexpr value_t type() const noexcept
18449
    {
18450
        return m_type;
18451
    }
18452

18453
    /// @brief return whether type is primitive
18454
    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
18455
    constexpr bool is_primitive() const noexcept
18456
    {
18457
        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
18458
    }
18459

18460
    /// @brief return whether type is structured
18461
    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
18462
    constexpr bool is_structured() const noexcept
18463
    {
18464
        return is_array() || is_object();
18465
    }
18466

18467
    /// @brief return whether value is null
18468
    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
18469
    constexpr bool is_null() const noexcept
18470
    {
18471
        return m_type == value_t::null;
18472
    }
18473

18474
    /// @brief return whether value is a boolean
18475
    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
18476
    constexpr bool is_boolean() const noexcept
18477
    {
18478
        return m_type == value_t::boolean;
18479
    }
18480

18481
    /// @brief return whether value is a number
18482
    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
18483
    constexpr bool is_number() const noexcept
18484
    {
18485
        return is_number_integer() || is_number_float();
18486
    }
18487

18488
    /// @brief return whether value is an integer number
18489
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
18490
    constexpr bool is_number_integer() const noexcept
18491
    {
18492
        return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
18493
    }
18494

18495
    /// @brief return whether value is an unsigned integer number
18496
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
18497
    constexpr bool is_number_unsigned() const noexcept
18498
    {
18499
        return m_type == value_t::number_unsigned;
18500
    }
18501

18502
    /// @brief return whether value is a floating-point number
18503
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
18504
    constexpr bool is_number_float() const noexcept
18505
    {
18506
        return m_type == value_t::number_float;
18507
    }
18508

18509
    /// @brief return whether value is an object
18510
    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
18511
    constexpr bool is_object() const noexcept
18512
    {
18513
        return m_type == value_t::object;
18514
    }
18515

18516
    /// @brief return whether value is an array
18517
    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
18518
    constexpr bool is_array() const noexcept
18519
    {
18520
        return m_type == value_t::array;
18521
    }
18522

18523
    /// @brief return whether value is a string
18524
    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
18525
    constexpr bool is_string() const noexcept
18526
    {
18527
        return m_type == value_t::string;
18528
    }
18529

18530
    /// @brief return whether value is a binary array
18531
    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
18532
    constexpr bool is_binary() const noexcept
18533
    {
18534
        return m_type == value_t::binary;
18535
    }
18536

18537
    /// @brief return whether value is discarded
18538
    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
18539
    constexpr bool is_discarded() const noexcept
18540
    {
18541
        return m_type == value_t::discarded;
18542
    }
18543

18544
    /// @brief return the type of the JSON value (implicit)
18545
    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
18546
    constexpr operator value_t() const noexcept
18547
    {
18548
        return m_type;
18549
    }
18550

18551
    /// @}
18552

18553
  private:
18554
    //////////////////
18555
    // value access //
18556
    //////////////////
18557

18558
    /// get a boolean (explicit)
18559
    boolean_t get_impl(boolean_t* /*unused*/) const
18560
    {
18561
        if (JSON_HEDLEY_LIKELY(is_boolean()))
18562
        {
18563
            return m_value.boolean;
18564
        }
18565

18566
        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name()), *this));
18567
    }
18568

18569
    /// get a pointer to the value (object)
18570
    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
18571
    {
18572
        return is_object() ? m_value.object : nullptr;
18573
    }
18574

18575
    /// get a pointer to the value (object)
18576
    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
18577
    {
18578
        return is_object() ? m_value.object : nullptr;
18579
    }
18580

18581
    /// get a pointer to the value (array)
18582
    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
18583
    {
18584
        return is_array() ? m_value.array : nullptr;
18585
    }
18586

18587
    /// get a pointer to the value (array)
18588
    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
18589
    {
18590
        return is_array() ? m_value.array : nullptr;
18591
    }
18592

18593
    /// get a pointer to the value (string)
18594
    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
18595
    {
18596
        return is_string() ? m_value.string : nullptr;
18597
    }
18598

18599
    /// get a pointer to the value (string)
18600
    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
18601
    {
18602
        return is_string() ? m_value.string : nullptr;
18603
    }
18604

18605
    /// get a pointer to the value (boolean)
18606
    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
18607
    {
18608
        return is_boolean() ? &m_value.boolean : nullptr;
18609
    }
18610

18611
    /// get a pointer to the value (boolean)
18612
    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
18613
    {
18614
        return is_boolean() ? &m_value.boolean : nullptr;
18615
    }
18616

18617
    /// get a pointer to the value (integer number)
18618
    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
18619
    {
18620
        return is_number_integer() ? &m_value.number_integer : nullptr;
18621
    }
18622

18623
    /// get a pointer to the value (integer number)
18624
    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
18625
    {
18626
        return is_number_integer() ? &m_value.number_integer : nullptr;
18627
    }
18628

18629
    /// get a pointer to the value (unsigned number)
18630
    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
18631
    {
18632
        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
18633
    }
18634

18635
    /// get a pointer to the value (unsigned number)
18636
    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
18637
    {
18638
        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
18639
    }
18640

18641
    /// get a pointer to the value (floating-point number)
18642
    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
18643
    {
18644
        return is_number_float() ? &m_value.number_float : nullptr;
18645
    }
18646

18647
    /// get a pointer to the value (floating-point number)
18648
    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
18649
    {
18650
        return is_number_float() ? &m_value.number_float : nullptr;
18651
    }
18652

18653
    /// get a pointer to the value (binary)
18654
    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
18655
    {
18656
        return is_binary() ? m_value.binary : nullptr;
18657
    }
18658

18659
    /// get a pointer to the value (binary)
18660
    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
18661
    {
18662
        return is_binary() ? m_value.binary : nullptr;
18663
    }
18664

18665
    /*!
18666
    @brief helper function to implement get_ref()
18667

18668
    This function helps to implement get_ref() without code duplication for
18669
    const and non-const overloads
18670

18671
    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
18672

18673
    @throw type_error.303 if ReferenceType does not match underlying value
18674
    type of the current JSON
18675
    */
18676
    template<typename ReferenceType, typename ThisType>
18677
    static ReferenceType get_ref_impl(ThisType& obj)
18678
    {
18679
        // delegate the call to get_ptr<>()
18680
        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
18681

18682
        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
18683
        {
18684
            return *ptr;
18685
        }
18686

18687
        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
18688
    }
18689

18690
  public:
18691
    /// @name value access
18692
    /// Direct access to the stored value of a JSON value.
18693
    /// @{
18694

18695
    /// @brief get a pointer value (implicit)
18696
    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
18697
    template<typename PointerType, typename std::enable_if<
18698
                 std::is_pointer<PointerType>::value, int>::type = 0>
18699
    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
18700
    {
18701
        // delegate the call to get_impl_ptr<>()
18702
        return get_impl_ptr(static_cast<PointerType>(nullptr));
18703
    }
18704

18705
    /// @brief get a pointer value (implicit)
18706
    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
18707
    template < typename PointerType, typename std::enable_if <
18708
                   std::is_pointer<PointerType>::value&&
18709
                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
18710
    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
18711
    {
18712
        // delegate the call to get_impl_ptr<>() const
18713
        return get_impl_ptr(static_cast<PointerType>(nullptr));
18714
    }
18715

18716
  private:
18717
    /*!
18718
    @brief get a value (explicit)
18719

18720
    Explicit type conversion between the JSON value and a compatible value
18721
    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
18722
    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
18723
    The value is converted by calling the @ref json_serializer<ValueType>
18724
    `from_json()` method.
18725

18726
    The function is equivalent to executing
18727
    @code {.cpp}
18728
    ValueType ret;
18729
    JSONSerializer<ValueType>::from_json(*this, ret);
18730
    return ret;
18731
    @endcode
18732

18733
    This overloads is chosen if:
18734
    - @a ValueType is not @ref basic_json,
18735
    - @ref json_serializer<ValueType> has a `from_json()` method of the form
18736
      `void from_json(const basic_json&, ValueType&)`, and
18737
    - @ref json_serializer<ValueType> does not have a `from_json()` method of
18738
      the form `ValueType from_json(const basic_json&)`
18739

18740
    @tparam ValueType the returned value type
18741

18742
    @return copy of the JSON value, converted to @a ValueType
18743

18744
    @throw what @ref json_serializer<ValueType> `from_json()` method throws
18745

18746
    @liveexample{The example below shows several conversions from JSON values
18747
    to other types. There a few things to note: (1) Floating-point numbers can
18748
    be converted to integers\, (2) A JSON array can be converted to a standard
18749
    `std::vector<short>`\, (3) A JSON object can be converted to C++
18750
    associative containers such as `std::unordered_map<std::string\,
18751
    json>`.,get__ValueType_const}
18752

18753
    @since version 2.1.0
18754
    */
18755
    template < typename ValueType,
18756
               detail::enable_if_t <
18757
                   detail::is_default_constructible<ValueType>::value&&
18758
                   detail::has_from_json<basic_json_t, ValueType>::value,
18759
                   int > = 0 >
18760
    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
18761
                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
18762
    {
18763
        auto ret = ValueType();
18764
        JSONSerializer<ValueType>::from_json(*this, ret);
18765
        return ret;
18766
    }
18767

18768
    /*!
18769
    @brief get a value (explicit); special case
18770

18771
    Explicit type conversion between the JSON value and a compatible value
18772
    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
18773
    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
18774
    The value is converted by calling the @ref json_serializer<ValueType>
18775
    `from_json()` method.
18776

18777
    The function is equivalent to executing
18778
    @code {.cpp}
18779
    return JSONSerializer<ValueType>::from_json(*this);
18780
    @endcode
18781

18782
    This overloads is chosen if:
18783
    - @a ValueType is not @ref basic_json and
18784
    - @ref json_serializer<ValueType> has a `from_json()` method of the form
18785
      `ValueType from_json(const basic_json&)`
18786

18787
    @note If @ref json_serializer<ValueType> has both overloads of
18788
    `from_json()`, this one is chosen.
18789

18790
    @tparam ValueType the returned value type
18791

18792
    @return copy of the JSON value, converted to @a ValueType
18793

18794
    @throw what @ref json_serializer<ValueType> `from_json()` method throws
18795

18796
    @since version 2.1.0
18797
    */
18798
    template < typename ValueType,
18799
               detail::enable_if_t <
18800
                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
18801
                   int > = 0 >
18802
    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
18803
                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
18804
    {
18805
        return JSONSerializer<ValueType>::from_json(*this);
18806
    }
18807

18808
    /*!
18809
    @brief get special-case overload
18810

18811
    This overloads converts the current @ref basic_json in a different
18812
    @ref basic_json type
18813

18814
    @tparam BasicJsonType == @ref basic_json
18815

18816
    @return a copy of *this, converted into @a BasicJsonType
18817

18818
    @complexity Depending on the implementation of the called `from_json()`
18819
                method.
18820

18821
    @since version 3.2.0
18822
    */
18823
    template < typename BasicJsonType,
18824
               detail::enable_if_t <
18825
                   detail::is_basic_json<BasicJsonType>::value,
18826
                   int > = 0 >
18827
    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
18828
    {
18829
        return *this;
18830
    }
18831

18832
    /*!
18833
    @brief get special-case overload
18834

18835
    This overloads avoids a lot of template boilerplate, it can be seen as the
18836
    identity method
18837

18838
    @tparam BasicJsonType == @ref basic_json
18839

18840
    @return a copy of *this
18841

18842
    @complexity Constant.
18843

18844
    @since version 2.1.0
18845
    */
18846
    template<typename BasicJsonType,
18847
             detail::enable_if_t<
18848
                 std::is_same<BasicJsonType, basic_json_t>::value,
18849
                 int> = 0>
18850
    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
18851
    {
18852
        return *this;
18853
    }
18854

18855
    /*!
18856
    @brief get a pointer value (explicit)
18857
    @copydoc get()
18858
    */
18859
    template<typename PointerType,
18860
             detail::enable_if_t<
18861
                 std::is_pointer<PointerType>::value,
18862
                 int> = 0>
18863
    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
18864
    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
18865
    {
18866
        // delegate the call to get_ptr
18867
        return get_ptr<PointerType>();
18868
    }
18869

18870
  public:
18871
    /*!
18872
    @brief get a (pointer) value (explicit)
18873

18874
    Performs explicit type conversion between the JSON value and a compatible value if required.
18875

18876
    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
18877
    No copies are made.
18878

18879
    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
18880
    from the current @ref basic_json.
18881

18882
    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
18883
    method.
18884

18885
    @tparam ValueTypeCV the provided value type
18886
    @tparam ValueType the returned value type
18887

18888
    @return copy of the JSON value, converted to @tparam ValueType if necessary
18889

18890
    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
18891

18892
    @since version 2.1.0
18893
    */
18894
    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
18895
#if defined(JSON_HAS_CPP_14)
18896
    constexpr
18897
#endif
18898
    auto get() const noexcept(
18899
    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
18900
    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
18901
    {
18902
        // we cannot static_assert on ValueTypeCV being non-const, because
18903
        // there is support for get<const basic_json_t>(), which is why we
18904
        // still need the uncvref
18905
        static_assert(!std::is_reference<ValueTypeCV>::value,
18906
                      "get() cannot be used with reference types, you might want to use get_ref()");
18907
        return get_impl<ValueType>(detail::priority_tag<4> {});
18908
    }
18909

18910
    /*!
18911
    @brief get a pointer value (explicit)
18912

18913
    Explicit pointer access to the internally stored JSON value. No copies are
18914
    made.
18915

18916
    @warning The pointer becomes invalid if the underlying JSON object
18917
    changes.
18918

18919
    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
18920
    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
18921
    @ref number_unsigned_t, or @ref number_float_t.
18922

18923
    @return pointer to the internally stored JSON value if the requested
18924
    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
18925

18926
    @complexity Constant.
18927

18928
    @liveexample{The example below shows how pointers to internal values of a
18929
    JSON value can be requested. Note that no type conversions are made and a
18930
    `nullptr` is returned if the value and the requested pointer type does not
18931
    match.,get__PointerType}
18932

18933
    @sa see @ref get_ptr() for explicit pointer-member access
18934

18935
    @since version 1.0.0
18936
    */
18937
    template<typename PointerType, typename std::enable_if<
18938
                 std::is_pointer<PointerType>::value, int>::type = 0>
18939
    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
18940
    {
18941
        // delegate the call to get_ptr
18942
        return get_ptr<PointerType>();
18943
    }
18944

18945
    /// @brief get a value (explicit)
18946
    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
18947
    template < typename ValueType,
18948
               detail::enable_if_t <
18949
                   !detail::is_basic_json<ValueType>::value&&
18950
                   detail::has_from_json<basic_json_t, ValueType>::value,
18951
                   int > = 0 >
18952
    ValueType & get_to(ValueType& v) const noexcept(noexcept(
18953
                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
18954
    {
18955
        JSONSerializer<ValueType>::from_json(*this, v);
18956
        return v;
18957
    }
18958

18959
    // specialization to allow calling get_to with a basic_json value
18960
    // see https://github.com/nlohmann/json/issues/2175
18961
    template<typename ValueType,
18962
             detail::enable_if_t <
18963
                 detail::is_basic_json<ValueType>::value,
18964
                 int> = 0>
18965
    ValueType & get_to(ValueType& v) const
18966
    {
18967
        v = *this;
18968
        return v;
18969
    }
18970

18971
    template <
18972
        typename T, std::size_t N,
18973
        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
18974
        detail::enable_if_t <
18975
            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
18976
    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
18977
    noexcept(noexcept(JSONSerializer<Array>::from_json(
18978
                          std::declval<const basic_json_t&>(), v)))
18979
    {
18980
        JSONSerializer<Array>::from_json(*this, v);
18981
        return v;
18982
    }
18983

18984
    /// @brief get a reference value (implicit)
18985
    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
18986
    template<typename ReferenceType, typename std::enable_if<
18987
                 std::is_reference<ReferenceType>::value, int>::type = 0>
18988
    ReferenceType get_ref()
18989
    {
18990
        // delegate call to get_ref_impl
18991
        return get_ref_impl<ReferenceType>(*this);
18992
    }
18993

18994
    /// @brief get a reference value (implicit)
18995
    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
18996
    template < typename ReferenceType, typename std::enable_if <
18997
                   std::is_reference<ReferenceType>::value&&
18998
                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
18999
    ReferenceType get_ref() const
19000
    {
19001
        // delegate call to get_ref_impl
19002
        return get_ref_impl<ReferenceType>(*this);
19003
    }
19004

19005
    /*!
19006
    @brief get a value (implicit)
19007

19008
    Implicit type conversion between the JSON value and a compatible value.
19009
    The call is realized by calling @ref get() const.
19010

19011
    @tparam ValueType non-pointer type compatible to the JSON value, for
19012
    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
19013
    `std::vector` types for JSON arrays. The character type of @ref string_t
19014
    as well as an initializer list of this type is excluded to avoid
19015
    ambiguities as these types implicitly convert to `std::string`.
19016

19017
    @return copy of the JSON value, converted to type @a ValueType
19018

19019
    @throw type_error.302 in case passed type @a ValueType is incompatible
19020
    to the JSON value type (e.g., the JSON value is of type boolean, but a
19021
    string is requested); see example below
19022

19023
    @complexity Linear in the size of the JSON value.
19024

19025
    @liveexample{The example below shows several conversions from JSON values
19026
    to other types. There a few things to note: (1) Floating-point numbers can
19027
    be converted to integers\, (2) A JSON array can be converted to a standard
19028
    `std::vector<short>`\, (3) A JSON object can be converted to C++
19029
    associative containers such as `std::unordered_map<std::string\,
19030
    json>`.,operator__ValueType}
19031

19032
    @since version 1.0.0
19033
    */
19034
    template < typename ValueType, typename std::enable_if <
19035
                   detail::conjunction <
19036
                       detail::negation<std::is_pointer<ValueType>>,
19037
                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
19038
                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
19039
                                        detail::negation<detail::is_basic_json<ValueType>>,
19040
                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
19041

19042
#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
19043
                                                detail::negation<std::is_same<ValueType, std::string_view>>,
19044
#endif
19045
                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
19046
                                                >::value, int >::type = 0 >
19047
                                        JSON_EXPLICIT operator ValueType() const
19048
    {
19049
        // delegate the call to get<>() const
19050
        return get<ValueType>();
19051
    }
19052

19053
    /// @brief get a binary value
19054
    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
19055
    binary_t& get_binary()
19056
    {
19057
        if (!is_binary())
19058
        {
19059
            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
19060
        }
19061

19062
        return *get_ptr<binary_t*>();
19063
    }
19064

19065
    /// @brief get a binary value
19066
    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
19067
    const binary_t& get_binary() const
19068
    {
19069
        if (!is_binary())
19070
        {
19071
            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
19072
        }
19073

19074
        return *get_ptr<const binary_t*>();
19075
    }
19076

19077
    /// @}
19078

19079

19080
    ////////////////////
19081
    // element access //
19082
    ////////////////////
19083

19084
    /// @name element access
19085
    /// Access to the JSON value.
19086
    /// @{
19087

19088
    /// @brief access specified array element with bounds checking
19089
    /// @sa https://json.nlohmann.me/api/basic_json/at/
19090
    reference at(size_type idx)
19091
    {
19092
        // at only works for arrays
19093
        if (JSON_HEDLEY_LIKELY(is_array()))
19094
        {
19095
            JSON_TRY
19096
            {
19097
                return set_parent(m_value.array->at(idx));
19098
            }
19099
            JSON_CATCH (std::out_of_range&)
19100
            {
19101
                // create better exception explanation
19102
                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
19103
            }
19104
        }
19105
        else
19106
        {
19107
            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19108
        }
19109
    }
19110

19111
    /// @brief access specified array element with bounds checking
19112
    /// @sa https://json.nlohmann.me/api/basic_json/at/
19113
    const_reference at(size_type idx) const
19114
    {
19115
        // at only works for arrays
19116
        if (JSON_HEDLEY_LIKELY(is_array()))
19117
        {
19118
            JSON_TRY
19119
            {
19120
                return m_value.array->at(idx);
19121
            }
19122
            JSON_CATCH (std::out_of_range&)
19123
            {
19124
                // create better exception explanation
19125
                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
19126
            }
19127
        }
19128
        else
19129
        {
19130
            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19131
        }
19132
    }
19133

19134
    /// @brief access specified object element with bounds checking
19135
    /// @sa https://json.nlohmann.me/api/basic_json/at/
19136
    reference at(const typename object_t::key_type& key)
19137
    {
19138
        // at only works for objects
19139
        if (JSON_HEDLEY_LIKELY(is_object()))
19140
        {
19141
            JSON_TRY
19142
            {
19143
                return set_parent(m_value.object->at(key));
19144
            }
19145
            JSON_CATCH (std::out_of_range&)
19146
            {
19147
                // create better exception explanation
19148
                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
19149
            }
19150
        }
19151
        else
19152
        {
19153
            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19154
        }
19155
    }
19156

19157
    /// @brief access specified object element with bounds checking
19158
    /// @sa https://json.nlohmann.me/api/basic_json/at/
19159
    const_reference at(const typename object_t::key_type& key) const
19160
    {
19161
        // at only works for objects
19162
        if (JSON_HEDLEY_LIKELY(is_object()))
19163
        {
19164
            JSON_TRY
19165
            {
19166
                return m_value.object->at(key);
19167
            }
19168
            JSON_CATCH (std::out_of_range&)
19169
            {
19170
                // create better exception explanation
19171
                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
19172
            }
19173
        }
19174
        else
19175
        {
19176
            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19177
        }
19178
    }
19179

19180
    /// @brief access specified array element
19181
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19182
    reference operator[](size_type idx)
19183
    {
19184
        // implicitly convert null value to an empty array
19185
        if (is_null())
19186
        {
19187
            m_type = value_t::array;
19188
            m_value.array = create<array_t>();
19189
            assert_invariant();
19190
        }
19191

19192
        // operator[] only works for arrays
19193
        if (JSON_HEDLEY_LIKELY(is_array()))
19194
        {
19195
            // fill up array with null values if given idx is outside range
19196
            if (idx >= m_value.array->size())
19197
            {
19198
#if JSON_DIAGNOSTICS
19199
                // remember array size & capacity before resizing
19200
                const auto old_size = m_value.array->size();
19201
                const auto old_capacity = m_value.array->capacity();
19202
#endif
19203
                m_value.array->resize(idx + 1);
19204

19205
#if JSON_DIAGNOSTICS
19206
                if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
19207
                {
19208
                    // capacity has changed: update all parents
19209
                    set_parents();
19210
                }
19211
                else
19212
                {
19213
                    // set parent for values added above
19214
                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
19215
                }
19216
#endif
19217
                assert_invariant();
19218
            }
19219

19220
            return m_value.array->operator[](idx);
19221
        }
19222

19223
        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
19224
    }
19225

19226
    /// @brief access specified array element
19227
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19228
    const_reference operator[](size_type idx) const
19229
    {
19230
        // const operator[] only works for arrays
19231
        if (JSON_HEDLEY_LIKELY(is_array()))
19232
        {
19233
            return m_value.array->operator[](idx);
19234
        }
19235

19236
        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
19237
    }
19238

19239
    /// @brief access specified object element
19240
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19241
    reference operator[](const typename object_t::key_type& key)
19242
    {
19243
        // implicitly convert null value to an empty object
19244
        if (is_null())
19245
        {
19246
            m_type = value_t::object;
19247
            m_value.object = create<object_t>();
19248
            assert_invariant();
19249
        }
19250

19251
        // operator[] only works for objects
19252
        if (JSON_HEDLEY_LIKELY(is_object()))
19253
        {
19254
            return set_parent(m_value.object->operator[](key));
19255
        }
19256

19257
        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19258
    }
19259

19260
    /// @brief access specified object element
19261
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19262
    const_reference operator[](const typename object_t::key_type& key) const
19263
    {
19264
        // const operator[] only works for objects
19265
        if (JSON_HEDLEY_LIKELY(is_object()))
19266
        {
19267
            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
19268
            return m_value.object->find(key)->second;
19269
        }
19270

19271
        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19272
    }
19273

19274
    /// @brief access specified object element
19275
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19276
    template<typename T>
19277
    JSON_HEDLEY_NON_NULL(2)
19278
    reference operator[](T* key)
19279
    {
19280
        // implicitly convert null to object
19281
        if (is_null())
19282
        {
19283
            m_type = value_t::object;
19284
            m_value = value_t::object;
19285
            assert_invariant();
19286
        }
19287

19288
        // at only works for objects
19289
        if (JSON_HEDLEY_LIKELY(is_object()))
19290
        {
19291
            return set_parent(m_value.object->operator[](key));
19292
        }
19293

19294
        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19295
    }
19296

19297
    /// @brief access specified object element
19298
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19299
    template<typename T>
19300
    JSON_HEDLEY_NON_NULL(2)
19301
    const_reference operator[](T* key) const
19302
    {
19303
        // at only works for objects
19304
        if (JSON_HEDLEY_LIKELY(is_object()))
19305
        {
19306
            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
19307
            return m_value.object->find(key)->second;
19308
        }
19309

19310
        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19311
    }
19312

19313
    /// @brief access specified object element with default value
19314
    /// @sa https://json.nlohmann.me/api/basic_json/value/
19315
    /// using std::is_convertible in a std::enable_if will fail when using explicit conversions
19316
    template < class ValueType, typename std::enable_if <
19317
                   detail::is_getable<basic_json_t, ValueType>::value
19318
                   && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
19319
    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
19320
    {
19321
        // at only works for objects
19322
        if (JSON_HEDLEY_LIKELY(is_object()))
19323
        {
19324
            // if key is found, return value and given default value otherwise
19325
            const auto it = find(key);
19326
            if (it != end())
19327
            {
19328
                return it->template get<ValueType>();
19329
            }
19330

19331
            return default_value;
19332
        }
19333

19334
        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
19335
    }
19336

19337
    /// @brief access specified object element with default value
19338
    /// @sa https://json.nlohmann.me/api/basic_json/value/
19339
    /// overload for a default value of type const char*
19340
    string_t value(const typename object_t::key_type& key, const char* default_value) const
19341
    {
19342
        return value(key, string_t(default_value));
19343
    }
19344

19345
    /// @brief access specified object element via JSON Pointer with default value
19346
    /// @sa https://json.nlohmann.me/api/basic_json/value/
19347
    template<class ValueType, typename std::enable_if<
19348
                 detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
19349
    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
19350
    {
19351
        // at only works for objects
19352
        if (JSON_HEDLEY_LIKELY(is_object()))
19353
        {
19354
            // if pointer resolves a value, return it or use default value
19355
            JSON_TRY
19356
            {
19357
                return ptr.get_checked(this).template get<ValueType>();
19358
            }
19359
            JSON_INTERNAL_CATCH (out_of_range&)
19360
            {
19361
                return default_value;
19362
            }
19363
        }
19364

19365
        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
19366
    }
19367

19368
    /// @brief access specified object element via JSON Pointer with default value
19369
    /// @sa https://json.nlohmann.me/api/basic_json/value/
19370
    /// overload for a default value of type const char*
19371
    JSON_HEDLEY_NON_NULL(3)
19372
    string_t value(const json_pointer& ptr, const char* default_value) const
19373
    {
19374
        return value(ptr, string_t(default_value));
19375
    }
19376

19377
    /// @brief access the first element
19378
    /// @sa https://json.nlohmann.me/api/basic_json/front/
19379
    reference front()
19380
    {
19381
        return *begin();
19382
    }
19383

19384
    /// @brief access the first element
19385
    /// @sa https://json.nlohmann.me/api/basic_json/front/
19386
    const_reference front() const
19387
    {
19388
        return *cbegin();
19389
    }
19390

19391
    /// @brief access the last element
19392
    /// @sa https://json.nlohmann.me/api/basic_json/back/
19393
    reference back()
19394
    {
19395
        auto tmp = end();
19396
        --tmp;
19397
        return *tmp;
19398
    }
19399

19400
    /// @brief access the last element
19401
    /// @sa https://json.nlohmann.me/api/basic_json/back/
19402
    const_reference back() const
19403
    {
19404
        auto tmp = cend();
19405
        --tmp;
19406
        return *tmp;
19407
    }
19408

19409
    /// @brief remove element given an iterator
19410
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
19411
    template < class IteratorType, typename std::enable_if <
19412
                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
19413
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
19414
               = 0 >
19415
    IteratorType erase(IteratorType pos)
19416
    {
19417
        // make sure iterator fits the current value
19418
        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
19419
        {
19420
            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
19421
        }
19422

19423
        IteratorType result = end();
19424

19425
        switch (m_type)
19426
        {
19427
            case value_t::boolean:
19428
            case value_t::number_float:
19429
            case value_t::number_integer:
19430
            case value_t::number_unsigned:
19431
            case value_t::string:
19432
            case value_t::binary:
19433
            {
19434
                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
19435
                {
19436
                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", *this));
19437
                }
19438

19439
                if (is_string())
19440
                {
19441
                    AllocatorType<string_t> alloc;
19442
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
19443
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
19444
                    m_value.string = nullptr;
19445
                }
19446
                else if (is_binary())
19447
                {
19448
                    AllocatorType<binary_t> alloc;
19449
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
19450
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
19451
                    m_value.binary = nullptr;
19452
                }
19453

19454
                m_type = value_t::null;
19455
                assert_invariant();
19456
                break;
19457
            }
19458

19459
            case value_t::object:
19460
            {
19461
                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
19462
                break;
19463
            }
19464

19465
            case value_t::array:
19466
            {
19467
                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
19468
                break;
19469
            }
19470

19471
            case value_t::null:
19472
            case value_t::discarded:
19473
            default:
19474
                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19475
        }
19476

19477
        return result;
19478
    }
19479

19480
    /// @brief remove elements given an iterator range
19481
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
19482
    template < class IteratorType, typename std::enable_if <
19483
                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
19484
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
19485
               = 0 >
19486
    IteratorType erase(IteratorType first, IteratorType last)
19487
    {
19488
        // make sure iterator fits the current value
19489
        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
19490
        {
19491
            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", *this));
19492
        }
19493

19494
        IteratorType result = end();
19495

19496
        switch (m_type)
19497
        {
19498
            case value_t::boolean:
19499
            case value_t::number_float:
19500
            case value_t::number_integer:
19501
            case value_t::number_unsigned:
19502
            case value_t::string:
19503
            case value_t::binary:
19504
            {
19505
                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
19506
                                       || !last.m_it.primitive_iterator.is_end()))
19507
                {
19508
                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", *this));
19509
                }
19510

19511
                if (is_string())
19512
                {
19513
                    AllocatorType<string_t> alloc;
19514
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
19515
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
19516
                    m_value.string = nullptr;
19517
                }
19518
                else if (is_binary())
19519
                {
19520
                    AllocatorType<binary_t> alloc;
19521
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
19522
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
19523
                    m_value.binary = nullptr;
19524
                }
19525

19526
                m_type = value_t::null;
19527
                assert_invariant();
19528
                break;
19529
            }
19530

19531
            case value_t::object:
19532
            {
19533
                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
19534
                                              last.m_it.object_iterator);
19535
                break;
19536
            }
19537

19538
            case value_t::array:
19539
            {
19540
                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
19541
                                             last.m_it.array_iterator);
19542
                break;
19543
            }
19544

19545
            case value_t::null:
19546
            case value_t::discarded:
19547
            default:
19548
                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19549
        }
19550

19551
        return result;
19552
    }
19553

19554
    /// @brief remove element from a JSON object given a key
19555
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
19556
    size_type erase(const typename object_t::key_type& key)
19557
    {
19558
        // this erase only works for objects
19559
        if (JSON_HEDLEY_LIKELY(is_object()))
19560
        {
19561
            return m_value.object->erase(key);
19562
        }
19563

19564
        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19565
    }
19566

19567
    /// @brief remove element from a JSON array given an index
19568
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
19569
    void erase(const size_type idx)
19570
    {
19571
        // this erase only works for arrays
19572
        if (JSON_HEDLEY_LIKELY(is_array()))
19573
        {
19574
            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
19575
            {
19576
                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
19577
            }
19578

19579
            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
19580
        }
19581
        else
19582
        {
19583
            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19584
        }
19585
    }
19586

19587
    /// @}
19588

19589

19590
    ////////////
19591
    // lookup //
19592
    ////////////
19593

19594
    /// @name lookup
19595
    /// @{
19596

19597
    /// @brief find an element in a JSON object
19598
    /// @sa https://json.nlohmann.me/api/basic_json/find/
19599
    template<typename KeyT>
19600
    iterator find(KeyT&& key)
19601
    {
19602
        auto result = end();
19603

19604
        if (is_object())
19605
        {
19606
            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
19607
        }
19608

19609
        return result;
19610
    }
19611

19612
    /// @brief find an element in a JSON object
19613
    /// @sa https://json.nlohmann.me/api/basic_json/find/
19614
    template<typename KeyT>
19615
    const_iterator find(KeyT&& key) const
19616
    {
19617
        auto result = cend();
19618

19619
        if (is_object())
19620
        {
19621
            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
19622
        }
19623

19624
        return result;
19625
    }
19626

19627
    /// @brief returns the number of occurrences of a key in a JSON object
19628
    /// @sa https://json.nlohmann.me/api/basic_json/count/
19629
    template<typename KeyT>
19630
    size_type count(KeyT&& key) const
19631
    {
19632
        // return 0 for all nonobject types
19633
        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
19634
    }
19635

19636
    /// @brief check the existence of an element in a JSON object
19637
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
19638
    template < typename KeyT, typename std::enable_if <
19639
                   !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
19640
    bool contains(KeyT && key) const
19641
    {
19642
        return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
19643
    }
19644

19645
    /// @brief check the existence of an element in a JSON object given a JSON pointer
19646
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
19647
    bool contains(const json_pointer& ptr) const
19648
    {
19649
        return ptr.contains(this);
19650
    }
19651

19652
    /// @}
19653

19654

19655
    ///////////////
19656
    // iterators //
19657
    ///////////////
19658

19659
    /// @name iterators
19660
    /// @{
19661

19662
    /// @brief returns an iterator to the first element
19663
    /// @sa https://json.nlohmann.me/api/basic_json/begin/
19664
    iterator begin() noexcept
19665
    {
19666
        iterator result(this);
19667
        result.set_begin();
19668
        return result;
19669
    }
19670

19671
    /// @brief returns an iterator to the first element
19672
    /// @sa https://json.nlohmann.me/api/basic_json/begin/
19673
    const_iterator begin() const noexcept
19674
    {
19675
        return cbegin();
19676
    }
19677

19678
    /// @brief returns a const iterator to the first element
19679
    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
19680
    const_iterator cbegin() const noexcept
19681
    {
19682
        const_iterator result(this);
19683
        result.set_begin();
19684
        return result;
19685
    }
19686

19687
    /// @brief returns an iterator to one past the last element
19688
    /// @sa https://json.nlohmann.me/api/basic_json/end/
19689
    iterator end() noexcept
19690
    {
19691
        iterator result(this);
19692
        result.set_end();
19693
        return result;
19694
    }
19695

19696
    /// @brief returns an iterator to one past the last element
19697
    /// @sa https://json.nlohmann.me/api/basic_json/end/
19698
    const_iterator end() const noexcept
19699
    {
19700
        return cend();
19701
    }
19702

19703
    /// @brief returns an iterator to one past the last element
19704
    /// @sa https://json.nlohmann.me/api/basic_json/cend/
19705
    const_iterator cend() const noexcept
19706
    {
19707
        const_iterator result(this);
19708
        result.set_end();
19709
        return result;
19710
    }
19711

19712
    /// @brief returns an iterator to the reverse-beginning
19713
    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
19714
    reverse_iterator rbegin() noexcept
19715
    {
19716
        return reverse_iterator(end());
19717
    }
19718

19719
    /// @brief returns an iterator to the reverse-beginning
19720
    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
19721
    const_reverse_iterator rbegin() const noexcept
19722
    {
19723
        return crbegin();
19724
    }
19725

19726
    /// @brief returns an iterator to the reverse-end
19727
    /// @sa https://json.nlohmann.me/api/basic_json/rend/
19728
    reverse_iterator rend() noexcept
19729
    {
19730
        return reverse_iterator(begin());
19731
    }
19732

19733
    /// @brief returns an iterator to the reverse-end
19734
    /// @sa https://json.nlohmann.me/api/basic_json/rend/
19735
    const_reverse_iterator rend() const noexcept
19736
    {
19737
        return crend();
19738
    }
19739

19740
    /// @brief returns a const reverse iterator to the last element
19741
    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
19742
    const_reverse_iterator crbegin() const noexcept
19743
    {
19744
        return const_reverse_iterator(cend());
19745
    }
19746

19747
    /// @brief returns a const reverse iterator to one before the first
19748
    /// @sa https://json.nlohmann.me/api/basic_json/crend/
19749
    const_reverse_iterator crend() const noexcept
19750
    {
19751
        return const_reverse_iterator(cbegin());
19752
    }
19753

19754
  public:
19755
    /// @brief wrapper to access iterator member functions in range-based for
19756
    /// @sa https://json.nlohmann.me/api/basic_json/items/
19757
    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
19758
    ///             version 4.0.0 of the library. Please use @ref items() instead;
19759
    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
19760
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
19761
    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
19762
    {
19763
        return ref.items();
19764
    }
19765

19766
    /// @brief wrapper to access iterator member functions in range-based for
19767
    /// @sa https://json.nlohmann.me/api/basic_json/items/
19768
    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
19769
    ///         version 4.0.0 of the library. Please use @ref items() instead;
19770
    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
19771
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
19772
    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
19773
    {
19774
        return ref.items();
19775
    }
19776

19777
    /// @brief helper to access iterator member functions in range-based for
19778
    /// @sa https://json.nlohmann.me/api/basic_json/items/
19779
    iteration_proxy<iterator> items() noexcept
19780
    {
19781
        return iteration_proxy<iterator>(*this);
19782
    }
19783

19784
    /// @brief helper to access iterator member functions in range-based for
19785
    /// @sa https://json.nlohmann.me/api/basic_json/items/
19786
    iteration_proxy<const_iterator> items() const noexcept
19787
    {
19788
        return iteration_proxy<const_iterator>(*this);
19789
    }
19790

19791
    /// @}
19792

19793

19794
    //////////////
19795
    // capacity //
19796
    //////////////
19797

19798
    /// @name capacity
19799
    /// @{
19800

19801
    /// @brief checks whether the container is empty.
19802
    /// @sa https://json.nlohmann.me/api/basic_json/empty/
19803
    bool empty() const noexcept
19804
    {
19805
        switch (m_type)
19806
        {
19807
            case value_t::null:
19808
            {
19809
                // null values are empty
19810
                return true;
19811
            }
19812

19813
            case value_t::array:
19814
            {
19815
                // delegate call to array_t::empty()
19816
                return m_value.array->empty();
19817
            }
19818

19819
            case value_t::object:
19820
            {
19821
                // delegate call to object_t::empty()
19822
                return m_value.object->empty();
19823
            }
19824

19825
            case value_t::string:
19826
            case value_t::boolean:
19827
            case value_t::number_integer:
19828
            case value_t::number_unsigned:
19829
            case value_t::number_float:
19830
            case value_t::binary:
19831
            case value_t::discarded:
19832
            default:
19833
            {
19834
                // all other types are nonempty
19835
                return false;
19836
            }
19837
        }
19838
    }
19839

19840
    /// @brief returns the number of elements
19841
    /// @sa https://json.nlohmann.me/api/basic_json/size/
19842
    size_type size() const noexcept
19843
    {
19844
        switch (m_type)
19845
        {
19846
            case value_t::null:
19847
            {
19848
                // null values are empty
19849
                return 0;
19850
            }
19851

19852
            case value_t::array:
19853
            {
19854
                // delegate call to array_t::size()
19855
                return m_value.array->size();
19856
            }
19857

19858
            case value_t::object:
19859
            {
19860
                // delegate call to object_t::size()
19861
                return m_value.object->size();
19862
            }
19863

19864
            case value_t::string:
19865
            case value_t::boolean:
19866
            case value_t::number_integer:
19867
            case value_t::number_unsigned:
19868
            case value_t::number_float:
19869
            case value_t::binary:
19870
            case value_t::discarded:
19871
            default:
19872
            {
19873
                // all other types have size 1
19874
                return 1;
19875
            }
19876
        }
19877
    }
19878

19879
    /// @brief returns the maximum possible number of elements
19880
    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
19881
    size_type max_size() const noexcept
19882
    {
19883
        switch (m_type)
19884
        {
19885
            case value_t::array:
19886
            {
19887
                // delegate call to array_t::max_size()
19888
                return m_value.array->max_size();
19889
            }
19890

19891
            case value_t::object:
19892
            {
19893
                // delegate call to object_t::max_size()
19894
                return m_value.object->max_size();
19895
            }
19896

19897
            case value_t::null:
19898
            case value_t::string:
19899
            case value_t::boolean:
19900
            case value_t::number_integer:
19901
            case value_t::number_unsigned:
19902
            case value_t::number_float:
19903
            case value_t::binary:
19904
            case value_t::discarded:
19905
            default:
19906
            {
19907
                // all other types have max_size() == size()
19908
                return size();
19909
            }
19910
        }
19911
    }
19912

19913
    /// @}
19914

19915

19916
    ///////////////
19917
    // modifiers //
19918
    ///////////////
19919

19920
    /// @name modifiers
19921
    /// @{
19922

19923
    /// @brief clears the contents
19924
    /// @sa https://json.nlohmann.me/api/basic_json/clear/
19925
    void clear() noexcept
19926
    {
19927
        switch (m_type)
19928
        {
19929
            case value_t::number_integer:
19930
            {
19931
                m_value.number_integer = 0;
19932
                break;
19933
            }
19934

19935
            case value_t::number_unsigned:
19936
            {
19937
                m_value.number_unsigned = 0;
19938
                break;
19939
            }
19940

19941
            case value_t::number_float:
19942
            {
19943
                m_value.number_float = 0.0;
19944
                break;
19945
            }
19946

19947
            case value_t::boolean:
19948
            {
19949
                m_value.boolean = false;
19950
                break;
19951
            }
19952

19953
            case value_t::string:
19954
            {
19955
                m_value.string->clear();
19956
                break;
19957
            }
19958

19959
            case value_t::binary:
19960
            {
19961
                m_value.binary->clear();
19962
                break;
19963
            }
19964

19965
            case value_t::array:
19966
            {
19967
                m_value.array->clear();
19968
                break;
19969
            }
19970

19971
            case value_t::object:
19972
            {
19973
                m_value.object->clear();
19974
                break;
19975
            }
19976

19977
            case value_t::null:
19978
            case value_t::discarded:
19979
            default:
19980
                break;
19981
        }
19982
    }
19983

19984
    /// @brief add an object to an array
19985
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
19986
    void push_back(basic_json&& val)
19987
    {
19988
        // push_back only works for null objects or arrays
19989
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
19990
        {
19991
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
19992
        }
19993

19994
        // transform null object into an array
19995
        if (is_null())
19996
        {
19997
            m_type = value_t::array;
19998
            m_value = value_t::array;
19999
            assert_invariant();
20000
        }
20001

20002
        // add element to array (move semantics)
20003
        const auto old_capacity = m_value.array->capacity();
20004
        m_value.array->push_back(std::move(val));
20005
        set_parent(m_value.array->back(), old_capacity);
20006
        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
20007
    }
20008

20009
    /// @brief add an object to an array
20010
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20011
    reference operator+=(basic_json&& val)
20012
    {
20013
        push_back(std::move(val));
20014
        return *this;
20015
    }
20016

20017
    /// @brief add an object to an array
20018
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
20019
    void push_back(const basic_json& val)
20020
    {
20021
        // push_back only works for null objects or arrays
20022
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
20023
        {
20024
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
20025
        }
20026

20027
        // transform null object into an array
20028
        if (is_null())
20029
        {
20030
            m_type = value_t::array;
20031
            m_value = value_t::array;
20032
            assert_invariant();
20033
        }
20034

20035
        // add element to array
20036
        const auto old_capacity = m_value.array->capacity();
20037
        m_value.array->push_back(val);
20038
        set_parent(m_value.array->back(), old_capacity);
20039
    }
20040

20041
    /// @brief add an object to an array
20042
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20043
    reference operator+=(const basic_json& val)
20044
    {
20045
        push_back(val);
20046
        return *this;
20047
    }
20048

20049
    /// @brief add an object to an object
20050
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
20051
    void push_back(const typename object_t::value_type& val)
20052
    {
20053
        // push_back only works for null objects or objects
20054
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
20055
        {
20056
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
20057
        }
20058

20059
        // transform null object into an object
20060
        if (is_null())
20061
        {
20062
            m_type = value_t::object;
20063
            m_value = value_t::object;
20064
            assert_invariant();
20065
        }
20066

20067
        // add element to object
20068
        auto res = m_value.object->insert(val);
20069
        set_parent(res.first->second);
20070
    }
20071

20072
    /// @brief add an object to an object
20073
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20074
    reference operator+=(const typename object_t::value_type& val)
20075
    {
20076
        push_back(val);
20077
        return *this;
20078
    }
20079

20080
    /// @brief add an object to an object
20081
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
20082
    void push_back(initializer_list_t init)
20083
    {
20084
        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
20085
        {
20086
            basic_json&& key = init.begin()->moved_or_copied();
20087
            push_back(typename object_t::value_type(
20088
                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
20089
        }
20090
        else
20091
        {
20092
            push_back(basic_json(init));
20093
        }
20094
    }
20095

20096
    /// @brief add an object to an object
20097
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20098
    reference operator+=(initializer_list_t init)
20099
    {
20100
        push_back(init);
20101
        return *this;
20102
    }
20103

20104
    /// @brief add an object to an array
20105
    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
20106
    template<class... Args>
20107
    reference emplace_back(Args&& ... args)
20108
    {
20109
        // emplace_back only works for null objects or arrays
20110
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
20111
        {
20112
            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name()), *this));
20113
        }
20114

20115
        // transform null object into an array
20116
        if (is_null())
20117
        {
20118
            m_type = value_t::array;
20119
            m_value = value_t::array;
20120
            assert_invariant();
20121
        }
20122

20123
        // add element to array (perfect forwarding)
20124
        const auto old_capacity = m_value.array->capacity();
20125
        m_value.array->emplace_back(std::forward<Args>(args)...);
20126
        return set_parent(m_value.array->back(), old_capacity);
20127
    }
20128

20129
    /// @brief add an object to an object if key does not exist
20130
    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
20131
    template<class... Args>
20132
    std::pair<iterator, bool> emplace(Args&& ... args)
20133
    {
20134
        // emplace only works for null objects or arrays
20135
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
20136
        {
20137
            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name()), *this));
20138
        }
20139

20140
        // transform null object into an object
20141
        if (is_null())
20142
        {
20143
            m_type = value_t::object;
20144
            m_value = value_t::object;
20145
            assert_invariant();
20146
        }
20147

20148
        // add element to array (perfect forwarding)
20149
        auto res = m_value.object->emplace(std::forward<Args>(args)...);
20150
        set_parent(res.first->second);
20151

20152
        // create result iterator and set iterator to the result of emplace
20153
        auto it = begin();
20154
        it.m_it.object_iterator = res.first;
20155

20156
        // return pair of iterator and boolean
20157
        return {it, res.second};
20158
    }
20159

20160
    /// Helper for insertion of an iterator
20161
    /// @note: This uses std::distance to support GCC 4.8,
20162
    ///        see https://github.com/nlohmann/json/pull/1257
20163
    template<typename... Args>
20164
    iterator insert_iterator(const_iterator pos, Args&& ... args)
20165
    {
20166
        iterator result(this);
20167
        JSON_ASSERT(m_value.array != nullptr);
20168

20169
        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
20170
        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
20171
        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
20172

20173
        // This could have been written as:
20174
        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
20175
        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
20176

20177
        set_parents();
20178
        return result;
20179
    }
20180

20181
    /// @brief inserts element into array
20182
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
20183
    iterator insert(const_iterator pos, const basic_json& val)
20184
    {
20185
        // insert only works for arrays
20186
        if (JSON_HEDLEY_LIKELY(is_array()))
20187
        {
20188
            // check if iterator pos fits to this JSON value
20189
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20190
            {
20191
                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20192
            }
20193

20194
            // insert to array and return iterator
20195
            return insert_iterator(pos, val);
20196
        }
20197

20198
        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20199
    }
20200

20201
    /// @brief inserts element into array
20202
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
20203
    iterator insert(const_iterator pos, basic_json&& val)
20204
    {
20205
        return insert(pos, val);
20206
    }
20207

20208
    /// @brief inserts copies of element into array
20209
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
20210
    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
20211
    {
20212
        // insert only works for arrays
20213
        if (JSON_HEDLEY_LIKELY(is_array()))
20214
        {
20215
            // check if iterator pos fits to this JSON value
20216
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20217
            {
20218
                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20219
            }
20220

20221
            // insert to array and return iterator
20222
            return insert_iterator(pos, cnt, val);
20223
        }
20224

20225
        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20226
    }
20227

20228
    /// @brief inserts range of elements into array
20229
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
20230
    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
20231
    {
20232
        // insert only works for arrays
20233
        if (JSON_HEDLEY_UNLIKELY(!is_array()))
20234
        {
20235
            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20236
        }
20237

20238
        // check if iterator pos fits to this JSON value
20239
        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20240
        {
20241
            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20242
        }
20243

20244
        // check if range iterators belong to the same JSON object
20245
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20246
        {
20247
            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
20248
        }
20249

20250
        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
20251
        {
20252
            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", *this));
20253
        }
20254

20255
        // insert to array and return iterator
20256
        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
20257
    }
20258

20259
    /// @brief inserts elements from initializer list into array
20260
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
20261
    iterator insert(const_iterator pos, initializer_list_t ilist)
20262
    {
20263
        // insert only works for arrays
20264
        if (JSON_HEDLEY_UNLIKELY(!is_array()))
20265
        {
20266
            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20267
        }
20268

20269
        // check if iterator pos fits to this JSON value
20270
        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20271
        {
20272
            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20273
        }
20274

20275
        // insert to array and return iterator
20276
        return insert_iterator(pos, ilist.begin(), ilist.end());
20277
    }
20278

20279
    /// @brief inserts range of elements into object
20280
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
20281
    void insert(const_iterator first, const_iterator last)
20282
    {
20283
        // insert only works for objects
20284
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
20285
        {
20286
            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20287
        }
20288

20289
        // check if range iterators belong to the same JSON object
20290
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20291
        {
20292
            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
20293
        }
20294

20295
        // passed iterators must belong to objects
20296
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
20297
        {
20298
            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", *this));
20299
        }
20300

20301
        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
20302
    }
20303

20304
    /// @brief updates a JSON object from another object, overwriting existing keys
20305
    /// @sa https://json.nlohmann.me/api/basic_json/update/
20306
    void update(const_reference j, bool merge_objects = false)
20307
    {
20308
        update(j.begin(), j.end(), merge_objects);
20309
    }
20310

20311
    /// @brief updates a JSON object from another object, overwriting existing keys
20312
    /// @sa https://json.nlohmann.me/api/basic_json/update/
20313
    void update(const_iterator first, const_iterator last, bool merge_objects = false)
20314
    {
20315
        // implicitly convert null value to an empty object
20316
        if (is_null())
20317
        {
20318
            m_type = value_t::object;
20319
            m_value.object = create<object_t>();
20320
            assert_invariant();
20321
        }
20322

20323
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
20324
        {
20325
            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), *this));
20326
        }
20327

20328
        // check if range iterators belong to the same JSON object
20329
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20330
        {
20331
            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
20332
        }
20333

20334
        // passed iterators must belong to objects
20335
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
20336
        {
20337
            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(first.m_object->type_name()), *first.m_object));
20338
        }
20339

20340
        for (auto it = first; it != last; ++it)
20341
        {
20342
            if (merge_objects && it.value().is_object())
20343
            {
20344
                auto it2 = m_value.object->find(it.key());
20345
                if (it2 != m_value.object->end())
20346
                {
20347
                    it2->second.update(it.value(), true);
20348
                    continue;
20349
                }
20350
            }
20351
            m_value.object->operator[](it.key()) = it.value();
20352
#if JSON_DIAGNOSTICS
20353
            m_value.object->operator[](it.key()).m_parent = this;
20354
#endif
20355
        }
20356
    }
20357

20358
    /// @brief exchanges the values
20359
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20360
    void swap(reference other) noexcept (
20361
        std::is_nothrow_move_constructible<value_t>::value&&
20362
        std::is_nothrow_move_assignable<value_t>::value&&
20363
        std::is_nothrow_move_constructible<json_value>::value&&
20364
        std::is_nothrow_move_assignable<json_value>::value
20365
    )
20366
    {
20367
        std::swap(m_type, other.m_type);
20368
        std::swap(m_value, other.m_value);
20369

20370
        set_parents();
20371
        other.set_parents();
20372
        assert_invariant();
20373
    }
20374

20375
    /// @brief exchanges the values
20376
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20377
    friend void swap(reference left, reference right) noexcept (
20378
        std::is_nothrow_move_constructible<value_t>::value&&
20379
        std::is_nothrow_move_assignable<value_t>::value&&
20380
        std::is_nothrow_move_constructible<json_value>::value&&
20381
        std::is_nothrow_move_assignable<json_value>::value
20382
    )
20383
    {
20384
        left.swap(right);
20385
    }
20386

20387
    /// @brief exchanges the values
20388
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20389
    void swap(array_t& other) // NOLINT(bugprone-exception-escape)
20390
    {
20391
        // swap only works for arrays
20392
        if (JSON_HEDLEY_LIKELY(is_array()))
20393
        {
20394
            std::swap(*(m_value.array), other);
20395
        }
20396
        else
20397
        {
20398
            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20399
        }
20400
    }
20401

20402
    /// @brief exchanges the values
20403
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20404
    void swap(object_t& other) // NOLINT(bugprone-exception-escape)
20405
    {
20406
        // swap only works for objects
20407
        if (JSON_HEDLEY_LIKELY(is_object()))
20408
        {
20409
            std::swap(*(m_value.object), other);
20410
        }
20411
        else
20412
        {
20413
            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20414
        }
20415
    }
20416

20417
    /// @brief exchanges the values
20418
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20419
    void swap(string_t& other) // NOLINT(bugprone-exception-escape)
20420
    {
20421
        // swap only works for strings
20422
        if (JSON_HEDLEY_LIKELY(is_string()))
20423
        {
20424
            std::swap(*(m_value.string), other);
20425
        }
20426
        else
20427
        {
20428
            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20429
        }
20430
    }
20431

20432
    /// @brief exchanges the values
20433
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20434
    void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
20435
    {
20436
        // swap only works for strings
20437
        if (JSON_HEDLEY_LIKELY(is_binary()))
20438
        {
20439
            std::swap(*(m_value.binary), other);
20440
        }
20441
        else
20442
        {
20443
            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20444
        }
20445
    }
20446

20447
    /// @brief exchanges the values
20448
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
20449
    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
20450
    {
20451
        // swap only works for strings
20452
        if (JSON_HEDLEY_LIKELY(is_binary()))
20453
        {
20454
            std::swap(*(m_value.binary), other);
20455
        }
20456
        else
20457
        {
20458
            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20459
        }
20460
    }
20461

20462
    /// @}
20463

20464
  public:
20465
    //////////////////////////////////////////
20466
    // lexicographical comparison operators //
20467
    //////////////////////////////////////////
20468

20469
    /// @name lexicographical comparison operators
20470
    /// @{
20471

20472
    /// @brief comparison: equal
20473
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
20474
    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
20475
    {
20476
#ifdef __GNUC__
20477
#pragma GCC diagnostic push
20478
#pragma GCC diagnostic ignored "-Wfloat-equal"
20479
#endif
20480
        const auto lhs_type = lhs.type();
20481
        const auto rhs_type = rhs.type();
20482

20483
        if (lhs_type == rhs_type)
20484
        {
20485
            switch (lhs_type)
20486
            {
20487
                case value_t::array:
20488
                    return *lhs.m_value.array == *rhs.m_value.array;
20489

20490
                case value_t::object:
20491
                    return *lhs.m_value.object == *rhs.m_value.object;
20492

20493
                case value_t::null:
20494
                    return true;
20495

20496
                case value_t::string:
20497
                    return *lhs.m_value.string == *rhs.m_value.string;
20498

20499
                case value_t::boolean:
20500
                    return lhs.m_value.boolean == rhs.m_value.boolean;
20501

20502
                case value_t::number_integer:
20503
                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
20504

20505
                case value_t::number_unsigned:
20506
                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
20507

20508
                case value_t::number_float:
20509
                    return lhs.m_value.number_float == rhs.m_value.number_float;
20510

20511
                case value_t::binary:
20512
                    return *lhs.m_value.binary == *rhs.m_value.binary;
20513

20514
                case value_t::discarded:
20515
                default:
20516
                    return false;
20517
            }
20518
        }
20519
        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
20520
        {
20521
            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
20522
        }
20523
        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
20524
        {
20525
            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
20526
        }
20527
        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
20528
        {
20529
            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
20530
        }
20531
        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
20532
        {
20533
            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
20534
        }
20535
        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
20536
        {
20537
            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
20538
        }
20539
        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
20540
        {
20541
            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
20542
        }
20543

20544
        return false;
20545
#ifdef __GNUC__
20546
#pragma GCC diagnostic pop
20547
#endif
20548
    }
20549

20550
    /// @brief comparison: equal
20551
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
20552
    template<typename ScalarType, typename std::enable_if<
20553
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20554
    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
20555
    {
20556
        return lhs == basic_json(rhs);
20557
    }
20558

20559
    /// @brief comparison: equal
20560
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
20561
    template<typename ScalarType, typename std::enable_if<
20562
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20563
    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
20564
    {
20565
        return basic_json(lhs) == rhs;
20566
    }
20567

20568
    /// @brief comparison: not equal
20569
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
20570
    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
20571
    {
20572
        return !(lhs == rhs);
20573
    }
20574

20575
    /// @brief comparison: not equal
20576
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
20577
    template<typename ScalarType, typename std::enable_if<
20578
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20579
    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
20580
    {
20581
        return lhs != basic_json(rhs);
20582
    }
20583

20584
    /// @brief comparison: not equal
20585
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
20586
    template<typename ScalarType, typename std::enable_if<
20587
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20588
    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
20589
    {
20590
        return basic_json(lhs) != rhs;
20591
    }
20592

20593
    /// @brief comparison: less than
20594
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
20595
    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
20596
    {
20597
        const auto lhs_type = lhs.type();
20598
        const auto rhs_type = rhs.type();
20599

20600
        if (lhs_type == rhs_type)
20601
        {
20602
            switch (lhs_type)
20603
            {
20604
                case value_t::array:
20605
                    // note parentheses are necessary, see
20606
                    // https://github.com/nlohmann/json/issues/1530
20607
                    return (*lhs.m_value.array) < (*rhs.m_value.array);
20608

20609
                case value_t::object:
20610
                    return (*lhs.m_value.object) < (*rhs.m_value.object);
20611

20612
                case value_t::null:
20613
                    return false;
20614

20615
                case value_t::string:
20616
                    return (*lhs.m_value.string) < (*rhs.m_value.string);
20617

20618
                case value_t::boolean:
20619
                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);
20620

20621
                case value_t::number_integer:
20622
                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
20623

20624
                case value_t::number_unsigned:
20625
                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
20626

20627
                case value_t::number_float:
20628
                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);
20629

20630
                case value_t::binary:
20631
                    return (*lhs.m_value.binary) < (*rhs.m_value.binary);
20632

20633
                case value_t::discarded:
20634
                default:
20635
                    return false;
20636
            }
20637
        }
20638
        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
20639
        {
20640
            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
20641
        }
20642
        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
20643
        {
20644
            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
20645
        }
20646
        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
20647
        {
20648
            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
20649
        }
20650
        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
20651
        {
20652
            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
20653
        }
20654
        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
20655
        {
20656
            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
20657
        }
20658
        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
20659
        {
20660
            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
20661
        }
20662

20663
        // We only reach this line if we cannot compare values. In that case,
20664
        // we compare types. Note we have to call the operator explicitly,
20665
        // because MSVC has problems otherwise.
20666
        return operator<(lhs_type, rhs_type);
20667
    }
20668

20669
    /// @brief comparison: less than
20670
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
20671
    template<typename ScalarType, typename std::enable_if<
20672
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20673
    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
20674
    {
20675
        return lhs < basic_json(rhs);
20676
    }
20677

20678
    /// @brief comparison: less than
20679
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
20680
    template<typename ScalarType, typename std::enable_if<
20681
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20682
    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
20683
    {
20684
        return basic_json(lhs) < rhs;
20685
    }
20686

20687
    /// @brief comparison: less than or equal
20688
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
20689
    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
20690
    {
20691
        return !(rhs < lhs);
20692
    }
20693

20694
    /// @brief comparison: less than or equal
20695
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
20696
    template<typename ScalarType, typename std::enable_if<
20697
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20698
    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
20699
    {
20700
        return lhs <= basic_json(rhs);
20701
    }
20702

20703
    /// @brief comparison: less than or equal
20704
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
20705
    template<typename ScalarType, typename std::enable_if<
20706
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20707
    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
20708
    {
20709
        return basic_json(lhs) <= rhs;
20710
    }
20711

20712
    /// @brief comparison: greater than
20713
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
20714
    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
20715
    {
20716
        return !(lhs <= rhs);
20717
    }
20718

20719
    /// @brief comparison: greater than
20720
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
20721
    template<typename ScalarType, typename std::enable_if<
20722
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20723
    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
20724
    {
20725
        return lhs > basic_json(rhs);
20726
    }
20727

20728
    /// @brief comparison: greater than
20729
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
20730
    template<typename ScalarType, typename std::enable_if<
20731
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20732
    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
20733
    {
20734
        return basic_json(lhs) > rhs;
20735
    }
20736

20737
    /// @brief comparison: greater than or equal
20738
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
20739
    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
20740
    {
20741
        return !(lhs < rhs);
20742
    }
20743

20744
    /// @brief comparison: greater than or equal
20745
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
20746
    template<typename ScalarType, typename std::enable_if<
20747
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20748
    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
20749
    {
20750
        return lhs >= basic_json(rhs);
20751
    }
20752

20753
    /// @brief comparison: greater than or equal
20754
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
20755
    template<typename ScalarType, typename std::enable_if<
20756
                 std::is_scalar<ScalarType>::value, int>::type = 0>
20757
    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
20758
    {
20759
        return basic_json(lhs) >= rhs;
20760
    }
20761

20762
    /// @}
20763

20764
    ///////////////////
20765
    // serialization //
20766
    ///////////////////
20767

20768
    /// @name serialization
20769
    /// @{
20770
#ifndef JSON_NO_IO
20771
    /// @brief serialize to stream
20772
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
20773
    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
20774
    {
20775
        // read width member and use it as indentation parameter if nonzero
20776
        const bool pretty_print = o.width() > 0;
20777
        const auto indentation = pretty_print ? o.width() : 0;
20778

20779
        // reset width to 0 for subsequent calls to this stream
20780
        o.width(0);
20781

20782
        // do the actual serialization
20783
        serializer s(detail::output_adapter<char>(o), o.fill());
20784
        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
20785
        return o;
20786
    }
20787

20788
    /// @brief serialize to stream
20789
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
20790
    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
20791
    ///             version 4.0.0 of the library. Please use
20792
    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
20793
    ///             replace calls like `j >> o;` with `o << j;`.
20794
    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
20795
    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
20796
    {
20797
        return o << j;
20798
    }
20799
#endif  // JSON_NO_IO
20800
    /// @}
20801

20802

20803
    /////////////////////
20804
    // deserialization //
20805
    /////////////////////
20806

20807
    /// @name deserialization
20808
    /// @{
20809

20810
    /// @brief deserialize from a compatible input
20811
    /// @sa https://json.nlohmann.me/api/basic_json/parse/
20812
    template<typename InputType>
20813
    JSON_HEDLEY_WARN_UNUSED_RESULT
20814
    static basic_json parse(InputType&& i,
20815
                            const parser_callback_t cb = nullptr,
20816
                            const bool allow_exceptions = true,
20817
                            const bool ignore_comments = false)
20818
    {
20819
        basic_json result;
20820
        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
20821
        return result;
20822
    }
20823

20824
    /// @brief deserialize from a pair of character iterators
20825
    /// @sa https://json.nlohmann.me/api/basic_json/parse/
20826
    template<typename IteratorType>
20827
    JSON_HEDLEY_WARN_UNUSED_RESULT
20828
    static basic_json parse(IteratorType first,
20829
                            IteratorType last,
20830
                            const parser_callback_t cb = nullptr,
20831
                            const bool allow_exceptions = true,
20832
                            const bool ignore_comments = false)
20833
    {
20834
        basic_json result;
20835
        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
20836
        return result;
20837
    }
20838

20839
    JSON_HEDLEY_WARN_UNUSED_RESULT
20840
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
20841
    static basic_json parse(detail::span_input_adapter&& i,
20842
                            const parser_callback_t cb = nullptr,
20843
                            const bool allow_exceptions = true,
20844
                            const bool ignore_comments = false)
20845
    {
20846
        basic_json result;
20847
        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
20848
        return result;
20849
    }
20850

20851
    /// @brief check if the input is valid JSON
20852
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
20853
    template<typename InputType>
20854
    static bool accept(InputType&& i,
20855
                       const bool ignore_comments = false)
20856
    {
20857
        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
20858
    }
20859

20860
    /// @brief check if the input is valid JSON
20861
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
20862
    template<typename IteratorType>
20863
    static bool accept(IteratorType first, IteratorType last,
20864
                       const bool ignore_comments = false)
20865
    {
20866
        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
20867
    }
20868

20869
    JSON_HEDLEY_WARN_UNUSED_RESULT
20870
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
20871
    static bool accept(detail::span_input_adapter&& i,
20872
                       const bool ignore_comments = false)
20873
    {
20874
        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
20875
    }
20876

20877
    /// @brief generate SAX events
20878
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
20879
    template <typename InputType, typename SAX>
20880
    JSON_HEDLEY_NON_NULL(2)
20881
    static bool sax_parse(InputType&& i, SAX* sax,
20882
                          input_format_t format = input_format_t::json,
20883
                          const bool strict = true,
20884
                          const bool ignore_comments = false)
20885
    {
20886
        auto ia = detail::input_adapter(std::forward<InputType>(i));
20887
        return format == input_format_t::json
20888
               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
20889
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
20890
    }
20891

20892
    /// @brief generate SAX events
20893
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
20894
    template<class IteratorType, class SAX>
20895
    JSON_HEDLEY_NON_NULL(3)
20896
    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
20897
                          input_format_t format = input_format_t::json,
20898
                          const bool strict = true,
20899
                          const bool ignore_comments = false)
20900
    {
20901
        auto ia = detail::input_adapter(std::move(first), std::move(last));
20902
        return format == input_format_t::json
20903
               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
20904
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
20905
    }
20906

20907
    /// @brief generate SAX events
20908
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
20909
    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
20910
    ///             version 4.0.0 of the library. Please use
20911
    ///             sax_parse(ptr, ptr + len) instead.
20912
    template <typename SAX>
20913
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
20914
    JSON_HEDLEY_NON_NULL(2)
20915
    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
20916
                          input_format_t format = input_format_t::json,
20917
                          const bool strict = true,
20918
                          const bool ignore_comments = false)
20919
    {
20920
        auto ia = i.get();
20921
        return format == input_format_t::json
20922
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
20923
               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
20924
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
20925
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
20926
    }
20927
#ifndef JSON_NO_IO
20928
    /// @brief deserialize from stream
20929
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
20930
    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
20931
    ///             version 4.0.0 of the library. Please use
20932
    ///             operator>>(std::istream&, basic_json&) instead; that is,
20933
    ///             replace calls like `j << i;` with `i >> j;`.
20934
    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
20935
    friend std::istream& operator<<(basic_json& j, std::istream& i)
20936
    {
20937
        return operator>>(i, j);
20938
    }
20939

20940
    /// @brief deserialize from stream
20941
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
20942
    friend std::istream& operator>>(std::istream& i, basic_json& j)
20943
    {
20944
        parser(detail::input_adapter(i)).parse(false, j);
20945
        return i;
20946
    }
20947
#endif  // JSON_NO_IO
20948
    /// @}
20949

20950
    ///////////////////////////
20951
    // convenience functions //
20952
    ///////////////////////////
20953

20954
    /// @brief return the type as string
20955
    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
20956
    JSON_HEDLEY_RETURNS_NON_NULL
20957
    const char* type_name() const noexcept
20958
    {
20959
        switch (m_type)
20960
        {
20961
            case value_t::null:
20962
                return "null";
20963
            case value_t::object:
20964
                return "object";
20965
            case value_t::array:
20966
                return "array";
20967
            case value_t::string:
20968
                return "string";
20969
            case value_t::boolean:
20970
                return "boolean";
20971
            case value_t::binary:
20972
                return "binary";
20973
            case value_t::discarded:
20974
                return "discarded";
20975
            case value_t::number_integer:
20976
            case value_t::number_unsigned:
20977
            case value_t::number_float:
20978
            default:
20979
                return "number";
20980
        }
20981
    }
20982

20983

20984
  JSON_PRIVATE_UNLESS_TESTED:
20985
    //////////////////////
20986
    // member variables //
20987
    //////////////////////
20988

20989
    /// the type of the current element
20990
    value_t m_type = value_t::null;
20991

20992
    /// the value of the current element
20993
    json_value m_value = {};
20994

20995
#if JSON_DIAGNOSTICS
20996
    /// a pointer to a parent value (for debugging purposes)
20997
    basic_json* m_parent = nullptr;
20998
#endif
20999

21000
    //////////////////////////////////////////
21001
    // binary serialization/deserialization //
21002
    //////////////////////////////////////////
21003

21004
    /// @name binary serialization/deserialization support
21005
    /// @{
21006

21007
  public:
21008
    /// @brief create a CBOR serialization of a given JSON value
21009
    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
21010
    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
21011
    {
21012
        std::vector<std::uint8_t> result;
21013
        to_cbor(j, result);
21014
        return result;
21015
    }
21016

21017
    /// @brief create a CBOR serialization of a given JSON value
21018
    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
21019
    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
21020
    {
21021
        binary_writer<std::uint8_t>(o).write_cbor(j);
21022
    }
21023

21024
    /// @brief create a CBOR serialization of a given JSON value
21025
    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
21026
    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
21027
    {
21028
        binary_writer<char>(o).write_cbor(j);
21029
    }
21030

21031
    /// @brief create a MessagePack serialization of a given JSON value
21032
    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
21033
    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
21034
    {
21035
        std::vector<std::uint8_t> result;
21036
        to_msgpack(j, result);
21037
        return result;
21038
    }
21039

21040
    /// @brief create a MessagePack serialization of a given JSON value
21041
    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
21042
    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
21043
    {
21044
        binary_writer<std::uint8_t>(o).write_msgpack(j);
21045
    }
21046

21047
    /// @brief create a MessagePack serialization of a given JSON value
21048
    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
21049
    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
21050
    {
21051
        binary_writer<char>(o).write_msgpack(j);
21052
    }
21053

21054
    /// @brief create a UBJSON serialization of a given JSON value
21055
    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
21056
    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
21057
            const bool use_size = false,
21058
            const bool use_type = false)
21059
    {
21060
        std::vector<std::uint8_t> result;
21061
        to_ubjson(j, result, use_size, use_type);
21062
        return result;
21063
    }
21064

21065
    /// @brief create a UBJSON serialization of a given JSON value
21066
    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
21067
    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
21068
                          const bool use_size = false, const bool use_type = false)
21069
    {
21070
        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
21071
    }
21072

21073
    /// @brief create a UBJSON serialization of a given JSON value
21074
    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
21075
    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
21076
                          const bool use_size = false, const bool use_type = false)
21077
    {
21078
        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
21079
    }
21080

21081
    /// @brief create a BSON serialization of a given JSON value
21082
    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
21083
    static std::vector<std::uint8_t> to_bson(const basic_json& j)
21084
    {
21085
        std::vector<std::uint8_t> result;
21086
        to_bson(j, result);
21087
        return result;
21088
    }
21089

21090
    /// @brief create a BSON serialization of a given JSON value
21091
    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
21092
    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
21093
    {
21094
        binary_writer<std::uint8_t>(o).write_bson(j);
21095
    }
21096

21097
    /// @brief create a BSON serialization of a given JSON value
21098
    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
21099
    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
21100
    {
21101
        binary_writer<char>(o).write_bson(j);
21102
    }
21103

21104
    /// @brief create a JSON value from an input in CBOR format
21105
    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
21106
    template<typename InputType>
21107
    JSON_HEDLEY_WARN_UNUSED_RESULT
21108
    static basic_json from_cbor(InputType&& i,
21109
                                const bool strict = true,
21110
                                const bool allow_exceptions = true,
21111
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21112
    {
21113
        basic_json result;
21114
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21115
        auto ia = detail::input_adapter(std::forward<InputType>(i));
21116
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
21117
        return res ? result : basic_json(value_t::discarded);
21118
    }
21119

21120
    /// @brief create a JSON value from an input in CBOR format
21121
    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
21122
    template<typename IteratorType>
21123
    JSON_HEDLEY_WARN_UNUSED_RESULT
21124
    static basic_json from_cbor(IteratorType first, IteratorType last,
21125
                                const bool strict = true,
21126
                                const bool allow_exceptions = true,
21127
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21128
    {
21129
        basic_json result;
21130
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21131
        auto ia = detail::input_adapter(std::move(first), std::move(last));
21132
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
21133
        return res ? result : basic_json(value_t::discarded);
21134
    }
21135

21136
    template<typename T>
21137
    JSON_HEDLEY_WARN_UNUSED_RESULT
21138
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
21139
    static basic_json from_cbor(const T* ptr, std::size_t len,
21140
                                const bool strict = true,
21141
                                const bool allow_exceptions = true,
21142
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21143
    {
21144
        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
21145
    }
21146

21147

21148
    JSON_HEDLEY_WARN_UNUSED_RESULT
21149
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
21150
    static basic_json from_cbor(detail::span_input_adapter&& i,
21151
                                const bool strict = true,
21152
                                const bool allow_exceptions = true,
21153
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21154
    {
21155
        basic_json result;
21156
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21157
        auto ia = i.get();
21158
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21159
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
21160
        return res ? result : basic_json(value_t::discarded);
21161
    }
21162

21163
    /// @brief create a JSON value from an input in MessagePack format
21164
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
21165
    template<typename InputType>
21166
    JSON_HEDLEY_WARN_UNUSED_RESULT
21167
    static basic_json from_msgpack(InputType&& i,
21168
                                   const bool strict = true,
21169
                                   const bool allow_exceptions = true)
21170
    {
21171
        basic_json result;
21172
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21173
        auto ia = detail::input_adapter(std::forward<InputType>(i));
21174
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
21175
        return res ? result : basic_json(value_t::discarded);
21176
    }
21177

21178
    /// @brief create a JSON value from an input in MessagePack format
21179
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
21180
    template<typename IteratorType>
21181
    JSON_HEDLEY_WARN_UNUSED_RESULT
21182
    static basic_json from_msgpack(IteratorType first, IteratorType last,
21183
                                   const bool strict = true,
21184
                                   const bool allow_exceptions = true)
21185
    {
21186
        basic_json result;
21187
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21188
        auto ia = detail::input_adapter(std::move(first), std::move(last));
21189
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
21190
        return res ? result : basic_json(value_t::discarded);
21191
    }
21192

21193
    template<typename T>
21194
    JSON_HEDLEY_WARN_UNUSED_RESULT
21195
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
21196
    static basic_json from_msgpack(const T* ptr, std::size_t len,
21197
                                   const bool strict = true,
21198
                                   const bool allow_exceptions = true)
21199
    {
21200
        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
21201
    }
21202

21203
    JSON_HEDLEY_WARN_UNUSED_RESULT
21204
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
21205
    static basic_json from_msgpack(detail::span_input_adapter&& i,
21206
                                   const bool strict = true,
21207
                                   const bool allow_exceptions = true)
21208
    {
21209
        basic_json result;
21210
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21211
        auto ia = i.get();
21212
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21213
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
21214
        return res ? result : basic_json(value_t::discarded);
21215
    }
21216

21217
    /// @brief create a JSON value from an input in UBJSON format
21218
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
21219
    template<typename InputType>
21220
    JSON_HEDLEY_WARN_UNUSED_RESULT
21221
    static basic_json from_ubjson(InputType&& i,
21222
                                  const bool strict = true,
21223
                                  const bool allow_exceptions = true)
21224
    {
21225
        basic_json result;
21226
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21227
        auto ia = detail::input_adapter(std::forward<InputType>(i));
21228
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
21229
        return res ? result : basic_json(value_t::discarded);
21230
    }
21231

21232
    /// @brief create a JSON value from an input in UBJSON format
21233
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
21234
    template<typename IteratorType>
21235
    JSON_HEDLEY_WARN_UNUSED_RESULT
21236
    static basic_json from_ubjson(IteratorType first, IteratorType last,
21237
                                  const bool strict = true,
21238
                                  const bool allow_exceptions = true)
21239
    {
21240
        basic_json result;
21241
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21242
        auto ia = detail::input_adapter(std::move(first), std::move(last));
21243
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
21244
        return res ? result : basic_json(value_t::discarded);
21245
    }
21246

21247
    template<typename T>
21248
    JSON_HEDLEY_WARN_UNUSED_RESULT
21249
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
21250
    static basic_json from_ubjson(const T* ptr, std::size_t len,
21251
                                  const bool strict = true,
21252
                                  const bool allow_exceptions = true)
21253
    {
21254
        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
21255
    }
21256

21257
    JSON_HEDLEY_WARN_UNUSED_RESULT
21258
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
21259
    static basic_json from_ubjson(detail::span_input_adapter&& i,
21260
                                  const bool strict = true,
21261
                                  const bool allow_exceptions = true)
21262
    {
21263
        basic_json result;
21264
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21265
        auto ia = i.get();
21266
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21267
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
21268
        return res ? result : basic_json(value_t::discarded);
21269
    }
21270

21271
    /// @brief create a JSON value from an input in BSON format
21272
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
21273
    template<typename InputType>
21274
    JSON_HEDLEY_WARN_UNUSED_RESULT
21275
    static basic_json from_bson(InputType&& i,
21276
                                const bool strict = true,
21277
                                const bool allow_exceptions = true)
21278
    {
21279
        basic_json result;
21280
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21281
        auto ia = detail::input_adapter(std::forward<InputType>(i));
21282
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
21283
        return res ? result : basic_json(value_t::discarded);
21284
    }
21285

21286
    /// @brief create a JSON value from an input in BSON format
21287
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
21288
    template<typename IteratorType>
21289
    JSON_HEDLEY_WARN_UNUSED_RESULT
21290
    static basic_json from_bson(IteratorType first, IteratorType last,
21291
                                const bool strict = true,
21292
                                const bool allow_exceptions = true)
21293
    {
21294
        basic_json result;
21295
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21296
        auto ia = detail::input_adapter(std::move(first), std::move(last));
21297
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
21298
        return res ? result : basic_json(value_t::discarded);
21299
    }
21300

21301
    template<typename T>
21302
    JSON_HEDLEY_WARN_UNUSED_RESULT
21303
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
21304
    static basic_json from_bson(const T* ptr, std::size_t len,
21305
                                const bool strict = true,
21306
                                const bool allow_exceptions = true)
21307
    {
21308
        return from_bson(ptr, ptr + len, strict, allow_exceptions);
21309
    }
21310

21311
    JSON_HEDLEY_WARN_UNUSED_RESULT
21312
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
21313
    static basic_json from_bson(detail::span_input_adapter&& i,
21314
                                const bool strict = true,
21315
                                const bool allow_exceptions = true)
21316
    {
21317
        basic_json result;
21318
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21319
        auto ia = i.get();
21320
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21321
        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
21322
        return res ? result : basic_json(value_t::discarded);
21323
    }
21324
    /// @}
21325

21326
    //////////////////////////
21327
    // JSON Pointer support //
21328
    //////////////////////////
21329

21330
    /// @name JSON Pointer functions
21331
    /// @{
21332

21333
    /// @brief access specified element via JSON Pointer
21334
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
21335
    reference operator[](const json_pointer& ptr)
21336
    {
21337
        return ptr.get_unchecked(this);
21338
    }
21339

21340
    /// @brief access specified element via JSON Pointer
21341
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
21342
    const_reference operator[](const json_pointer& ptr) const
21343
    {
21344
        return ptr.get_unchecked(this);
21345
    }
21346

21347
    /// @brief access specified element via JSON Pointer
21348
    /// @sa https://json.nlohmann.me/api/basic_json/at/
21349
    reference at(const json_pointer& ptr)
21350
    {
21351
        return ptr.get_checked(this);
21352
    }
21353

21354
    /// @brief access specified element via JSON Pointer
21355
    /// @sa https://json.nlohmann.me/api/basic_json/at/
21356
    const_reference at(const json_pointer& ptr) const
21357
    {
21358
        return ptr.get_checked(this);
21359
    }
21360

21361
    /// @brief return flattened JSON value
21362
    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
21363
    basic_json flatten() const
21364
    {
21365
        basic_json result(value_t::object);
21366
        json_pointer::flatten("", *this, result);
21367
        return result;
21368
    }
21369

21370
    /// @brief unflatten a previously flattened JSON value
21371
    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
21372
    basic_json unflatten() const
21373
    {
21374
        return json_pointer::unflatten(*this);
21375
    }
21376

21377
    /// @}
21378

21379
    //////////////////////////
21380
    // JSON Patch functions //
21381
    //////////////////////////
21382

21383
    /// @name JSON Patch functions
21384
    /// @{
21385

21386
    /// @brief applies a JSON patch
21387
    /// @sa https://json.nlohmann.me/api/basic_json/patch/
21388
    basic_json patch(const basic_json& json_patch) const
21389
    {
21390
        // make a working copy to apply the patch to
21391
        basic_json result = *this;
21392

21393
        // the valid JSON Patch operations
21394
        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
21395

21396
        const auto get_op = [](const std::string & op)
21397
        {
21398
            if (op == "add")
21399
            {
21400
                return patch_operations::add;
21401
            }
21402
            if (op == "remove")
21403
            {
21404
                return patch_operations::remove;
21405
            }
21406
            if (op == "replace")
21407
            {
21408
                return patch_operations::replace;
21409
            }
21410
            if (op == "move")
21411
            {
21412
                return patch_operations::move;
21413
            }
21414
            if (op == "copy")
21415
            {
21416
                return patch_operations::copy;
21417
            }
21418
            if (op == "test")
21419
            {
21420
                return patch_operations::test;
21421
            }
21422

21423
            return patch_operations::invalid;
21424
        };
21425

21426
        // wrapper for "add" operation; add value at ptr
21427
        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
21428
        {
21429
            // adding to the root of the target document means replacing it
21430
            if (ptr.empty())
21431
            {
21432
                result = val;
21433
                return;
21434
            }
21435

21436
            // make sure the top element of the pointer exists
21437
            json_pointer top_pointer = ptr.top();
21438
            if (top_pointer != ptr)
21439
            {
21440
                result.at(top_pointer);
21441
            }
21442

21443
            // get reference to parent of JSON pointer ptr
21444
            const auto last_path = ptr.back();
21445
            ptr.pop_back();
21446
            basic_json& parent = result[ptr];
21447

21448
            switch (parent.m_type)
21449
            {
21450
                case value_t::null:
21451
                case value_t::object:
21452
                {
21453
                    // use operator[] to add value
21454
                    parent[last_path] = val;
21455
                    break;
21456
                }
21457

21458
                case value_t::array:
21459
                {
21460
                    if (last_path == "-")
21461
                    {
21462
                        // special case: append to back
21463
                        parent.push_back(val);
21464
                    }
21465
                    else
21466
                    {
21467
                        const auto idx = json_pointer::array_index(last_path);
21468
                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
21469
                        {
21470
                            // avoid undefined behavior
21471
                            JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", parent));
21472
                        }
21473

21474
                        // default case: insert add offset
21475
                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
21476
                    }
21477
                    break;
21478
                }
21479

21480
                // if there exists a parent it cannot be primitive
21481
                case value_t::string: // LCOV_EXCL_LINE
21482
                case value_t::boolean: // LCOV_EXCL_LINE
21483
                case value_t::number_integer: // LCOV_EXCL_LINE
21484
                case value_t::number_unsigned: // LCOV_EXCL_LINE
21485
                case value_t::number_float: // LCOV_EXCL_LINE
21486
                case value_t::binary: // LCOV_EXCL_LINE
21487
                case value_t::discarded: // LCOV_EXCL_LINE
21488
                default:            // LCOV_EXCL_LINE
21489
                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
21490
            }
21491
        };
21492

21493
        // wrapper for "remove" operation; remove value at ptr
21494
        const auto operation_remove = [this, &result](json_pointer & ptr)
21495
        {
21496
            // get reference to parent of JSON pointer ptr
21497
            const auto last_path = ptr.back();
21498
            ptr.pop_back();
21499
            basic_json& parent = result.at(ptr);
21500

21501
            // remove child
21502
            if (parent.is_object())
21503
            {
21504
                // perform range check
21505
                auto it = parent.find(last_path);
21506
                if (JSON_HEDLEY_LIKELY(it != parent.end()))
21507
                {
21508
                    parent.erase(it);
21509
                }
21510
                else
21511
                {
21512
                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found", *this));
21513
                }
21514
            }
21515
            else if (parent.is_array())
21516
            {
21517
                // note erase performs range check
21518
                parent.erase(json_pointer::array_index(last_path));
21519
            }
21520
        };
21521

21522
        // type check: top level value must be an array
21523
        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
21524
        {
21525
            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", json_patch));
21526
        }
21527

21528
        // iterate and apply the operations
21529
        for (const auto& val : json_patch)
21530
        {
21531
            // wrapper to get a value for an operation
21532
            const auto get_value = [&val](const std::string & op,
21533
                                          const std::string & member,
21534
                                          bool string_type) -> basic_json &
21535
            {
21536
                // find value
21537
                auto it = val.m_value.object->find(member);
21538

21539
                // context-sensitive error message
21540
                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
21541

21542
                // check if desired value is present
21543
                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
21544
                {
21545
                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
21546
                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'", val));
21547
                }
21548

21549
                // check if result is of type string
21550
                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
21551
                {
21552
                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
21553
                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'", val));
21554
                }
21555

21556
                // no error: return value
21557
                return it->second;
21558
            };
21559

21560
            // type check: every element of the array must be an object
21561
            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
21562
            {
21563
                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", val));
21564
            }
21565

21566
            // collect mandatory members
21567
            const auto op = get_value("op", "op", true).template get<std::string>();
21568
            const auto path = get_value(op, "path", true).template get<std::string>();
21569
            json_pointer ptr(path);
21570

21571
            switch (get_op(op))
21572
            {
21573
                case patch_operations::add:
21574
                {
21575
                    operation_add(ptr, get_value("add", "value", false));
21576
                    break;
21577
                }
21578

21579
                case patch_operations::remove:
21580
                {
21581
                    operation_remove(ptr);
21582
                    break;
21583
                }
21584

21585
                case patch_operations::replace:
21586
                {
21587
                    // the "path" location must exist - use at()
21588
                    result.at(ptr) = get_value("replace", "value", false);
21589
                    break;
21590
                }
21591

21592
                case patch_operations::move:
21593
                {
21594
                    const auto from_path = get_value("move", "from", true).template get<std::string>();
21595
                    json_pointer from_ptr(from_path);
21596

21597
                    // the "from" location must exist - use at()
21598
                    basic_json v = result.at(from_ptr);
21599

21600
                    // The move operation is functionally identical to a
21601
                    // "remove" operation on the "from" location, followed
21602
                    // immediately by an "add" operation at the target
21603
                    // location with the value that was just removed.
21604
                    operation_remove(from_ptr);
21605
                    operation_add(ptr, v);
21606
                    break;
21607
                }
21608

21609
                case patch_operations::copy:
21610
                {
21611
                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
21612
                    const json_pointer from_ptr(from_path);
21613

21614
                    // the "from" location must exist - use at()
21615
                    basic_json v = result.at(from_ptr);
21616

21617
                    // The copy is functionally identical to an "add"
21618
                    // operation at the target location using the value
21619
                    // specified in the "from" member.
21620
                    operation_add(ptr, v);
21621
                    break;
21622
                }
21623

21624
                case patch_operations::test:
21625
                {
21626
                    bool success = false;
21627
                    JSON_TRY
21628
                    {
21629
                        // check if "value" matches the one at "path"
21630
                        // the "path" location must exist - use at()
21631
                        success = (result.at(ptr) == get_value("test", "value", false));
21632
                    }
21633
                    JSON_INTERNAL_CATCH (out_of_range&)
21634
                    {
21635
                        // ignore out of range errors: success remains false
21636
                    }
21637

21638
                    // throw an exception if test fails
21639
                    if (JSON_HEDLEY_UNLIKELY(!success))
21640
                    {
21641
                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump(), val));
21642
                    }
21643

21644
                    break;
21645
                }
21646

21647
                case patch_operations::invalid:
21648
                default:
21649
                {
21650
                    // op must be "add", "remove", "replace", "move", "copy", or
21651
                    // "test"
21652
                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid", val));
21653
                }
21654
            }
21655
        }
21656

21657
        return result;
21658
    }
21659

21660
    /// @brief creates a diff as a JSON patch
21661
    /// @sa https://json.nlohmann.me/api/basic_json/diff/
21662
    JSON_HEDLEY_WARN_UNUSED_RESULT
21663
    static basic_json diff(const basic_json& source, const basic_json& target,
21664
                           const std::string& path = "")
21665
    {
21666
        // the patch
21667
        basic_json result(value_t::array);
21668

21669
        // if the values are the same, return empty patch
21670
        if (source == target)
21671
        {
21672
            return result;
21673
        }
21674

21675
        if (source.type() != target.type())
21676
        {
21677
            // different types: replace value
21678
            result.push_back(
21679
            {
21680
                {"op", "replace"}, {"path", path}, {"value", target}
21681
            });
21682
            return result;
21683
        }
21684

21685
        switch (source.type())
21686
        {
21687
            case value_t::array:
21688
            {
21689
                // first pass: traverse common elements
21690
                std::size_t i = 0;
21691
                while (i < source.size() && i < target.size())
21692
                {
21693
                    // recursive call to compare array values at index i
21694
                    auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
21695
                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
21696
                    ++i;
21697
                }
21698

21699
                // We now reached the end of at least one array
21700
                // in a second pass, traverse the remaining elements
21701

21702
                // remove my remaining elements
21703
                const auto end_index = static_cast<difference_type>(result.size());
21704
                while (i < source.size())
21705
                {
21706
                    // add operations in reverse order to avoid invalid
21707
                    // indices
21708
                    result.insert(result.begin() + end_index, object(
21709
                    {
21710
                        {"op", "remove"},
21711
                        {"path", path + "/" + std::to_string(i)}
21712
                    }));
21713
                    ++i;
21714
                }
21715

21716
                // add other remaining elements
21717
                while (i < target.size())
21718
                {
21719
                    result.push_back(
21720
                    {
21721
                        {"op", "add"},
21722
                        {"path", path + "/-"},
21723
                        {"value", target[i]}
21724
                    });
21725
                    ++i;
21726
                }
21727

21728
                break;
21729
            }
21730

21731
            case value_t::object:
21732
            {
21733
                // first pass: traverse this object's elements
21734
                for (auto it = source.cbegin(); it != source.cend(); ++it)
21735
                {
21736
                    // escape the key name to be used in a JSON patch
21737
                    const auto path_key = path + "/" + detail::escape(it.key());
21738

21739
                    if (target.find(it.key()) != target.end())
21740
                    {
21741
                        // recursive call to compare object values at key it
21742
                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
21743
                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
21744
                    }
21745
                    else
21746
                    {
21747
                        // found a key that is not in o -> remove it
21748
                        result.push_back(object(
21749
                        {
21750
                            {"op", "remove"}, {"path", path_key}
21751
                        }));
21752
                    }
21753
                }
21754

21755
                // second pass: traverse other object's elements
21756
                for (auto it = target.cbegin(); it != target.cend(); ++it)
21757
                {
21758
                    if (source.find(it.key()) == source.end())
21759
                    {
21760
                        // found a key that is not in this -> add it
21761
                        const auto path_key = path + "/" + detail::escape(it.key());
21762
                        result.push_back(
21763
                        {
21764
                            {"op", "add"}, {"path", path_key},
21765
                            {"value", it.value()}
21766
                        });
21767
                    }
21768
                }
21769

21770
                break;
21771
            }
21772

21773
            case value_t::null:
21774
            case value_t::string:
21775
            case value_t::boolean:
21776
            case value_t::number_integer:
21777
            case value_t::number_unsigned:
21778
            case value_t::number_float:
21779
            case value_t::binary:
21780
            case value_t::discarded:
21781
            default:
21782
            {
21783
                // both primitive type: replace value
21784
                result.push_back(
21785
                {
21786
                    {"op", "replace"}, {"path", path}, {"value", target}
21787
                });
21788
                break;
21789
            }
21790
        }
21791

21792
        return result;
21793
    }
21794

21795
    /// @}
21796

21797
    ////////////////////////////////
21798
    // JSON Merge Patch functions //
21799
    ////////////////////////////////
21800

21801
    /// @name JSON Merge Patch functions
21802
    /// @{
21803

21804
    /// @brief applies a JSON Merge Patch
21805
    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
21806
    void merge_patch(const basic_json& apply_patch)
21807
    {
21808
        if (apply_patch.is_object())
21809
        {
21810
            if (!is_object())
21811
            {
21812
                *this = object();
21813
            }
21814
            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
21815
            {
21816
                if (it.value().is_null())
21817
                {
21818
                    erase(it.key());
21819
                }
21820
                else
21821
                {
21822
                    operator[](it.key()).merge_patch(it.value());
21823
                }
21824
            }
21825
        }
21826
        else
21827
        {
21828
            *this = apply_patch;
21829
        }
21830
    }
21831

21832
    /// @}
21833
};
21834

21835
/// @brief user-defined to_string function for JSON values
21836
/// @sa https://json.nlohmann.me/api/basic_json/to_string/
21837
NLOHMANN_BASIC_JSON_TPL_DECLARATION
21838
std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
21839
{
21840
    return j.dump();
21841
}
21842

21843
} // namespace nlohmann
21844

21845
///////////////////////
21846
// nonmember support //
21847
///////////////////////
21848

21849
namespace std // NOLINT(cert-dcl58-cpp)
21850
{
21851

21852
/// @brief hash value for JSON objects
21853
/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
21854
NLOHMANN_BASIC_JSON_TPL_DECLARATION
21855
struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL>
21856
{
21857
    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
21858
    {
21859
        return nlohmann::detail::hash(j);
21860
    }
21861
};
21862

21863
// specialization for std::less<value_t>
21864
template<>
21865
struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
21866
{
21867
    /*!
21868
    @brief compare two value_t enum values
21869
    @since version 3.0.0
21870
    */
21871
    bool operator()(nlohmann::detail::value_t lhs,
21872
                    nlohmann::detail::value_t rhs) const noexcept
21873
    {
21874
        return nlohmann::detail::operator<(lhs, rhs);
21875
    }
21876
};
21877

21878
// C++20 prohibit function specialization in the std namespace.
21879
#ifndef JSON_HAS_CPP_20
21880

21881
/// @brief exchanges the values of two JSON objects
21882
/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
21883
NLOHMANN_BASIC_JSON_TPL_DECLARATION
21884
inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name)
21885
    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression)
21886
    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
21887
{
21888
    j1.swap(j2);
21889
}
21890

21891
#endif
21892

21893
} // namespace std
21894

21895
/// @brief user-defined string literal for JSON values
21896
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
21897
JSON_HEDLEY_NON_NULL(1)
21898
inline nlohmann::json operator "" _json(const char* s, std::size_t n)
21899
{
21900
    return nlohmann::json::parse(s, s + n);
21901
}
21902

21903
/// @brief user-defined string literal for JSON pointer
21904
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
21905
JSON_HEDLEY_NON_NULL(1)
21906
inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
21907
{
21908
    return nlohmann::json::json_pointer(std::string(s, n));
21909
}
21910

21911
// #include <nlohmann/detail/macro_unscope.hpp>
21912

21913

21914
// restore clang diagnostic settings
21915
#if defined(__clang__)
21916
    #pragma clang diagnostic pop
21917
#endif
21918

21919
// clean up
21920
#undef JSON_ASSERT
21921
#undef JSON_INTERNAL_CATCH
21922
#undef JSON_CATCH
21923
#undef JSON_THROW
21924
#undef JSON_TRY
21925
#undef JSON_PRIVATE_UNLESS_TESTED
21926
#undef JSON_HAS_CPP_11
21927
#undef JSON_HAS_CPP_14
21928
#undef JSON_HAS_CPP_17
21929
#undef JSON_HAS_CPP_20
21930
#undef JSON_HAS_FILESYSTEM
21931
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
21932
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
21933
#undef NLOHMANN_BASIC_JSON_TPL
21934
#undef JSON_EXPLICIT
21935
#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
21936

21937
// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
21938

21939

21940
#undef JSON_HEDLEY_ALWAYS_INLINE
21941
#undef JSON_HEDLEY_ARM_VERSION
21942
#undef JSON_HEDLEY_ARM_VERSION_CHECK
21943
#undef JSON_HEDLEY_ARRAY_PARAM
21944
#undef JSON_HEDLEY_ASSUME
21945
#undef JSON_HEDLEY_BEGIN_C_DECLS
21946
#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
21947
#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
21948
#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
21949
#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
21950
#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
21951
#undef JSON_HEDLEY_CLANG_HAS_FEATURE
21952
#undef JSON_HEDLEY_CLANG_HAS_WARNING
21953
#undef JSON_HEDLEY_COMPCERT_VERSION
21954
#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
21955
#undef JSON_HEDLEY_CONCAT
21956
#undef JSON_HEDLEY_CONCAT3
21957
#undef JSON_HEDLEY_CONCAT3_EX
21958
#undef JSON_HEDLEY_CONCAT_EX
21959
#undef JSON_HEDLEY_CONST
21960
#undef JSON_HEDLEY_CONSTEXPR
21961
#undef JSON_HEDLEY_CONST_CAST
21962
#undef JSON_HEDLEY_CPP_CAST
21963
#undef JSON_HEDLEY_CRAY_VERSION
21964
#undef JSON_HEDLEY_CRAY_VERSION_CHECK
21965
#undef JSON_HEDLEY_C_DECL
21966
#undef JSON_HEDLEY_DEPRECATED
21967
#undef JSON_HEDLEY_DEPRECATED_FOR
21968
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
21969
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
21970
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
21971
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
21972
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
21973
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
21974
#undef JSON_HEDLEY_DIAGNOSTIC_POP
21975
#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
21976
#undef JSON_HEDLEY_DMC_VERSION
21977
#undef JSON_HEDLEY_DMC_VERSION_CHECK
21978
#undef JSON_HEDLEY_EMPTY_BASES
21979
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
21980
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
21981
#undef JSON_HEDLEY_END_C_DECLS
21982
#undef JSON_HEDLEY_FLAGS
21983
#undef JSON_HEDLEY_FLAGS_CAST
21984
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
21985
#undef JSON_HEDLEY_GCC_HAS_BUILTIN
21986
#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
21987
#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
21988
#undef JSON_HEDLEY_GCC_HAS_EXTENSION
21989
#undef JSON_HEDLEY_GCC_HAS_FEATURE
21990
#undef JSON_HEDLEY_GCC_HAS_WARNING
21991
#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
21992
#undef JSON_HEDLEY_GCC_VERSION
21993
#undef JSON_HEDLEY_GCC_VERSION_CHECK
21994
#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
21995
#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
21996
#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
21997
#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
21998
#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
21999
#undef JSON_HEDLEY_GNUC_HAS_FEATURE
22000
#undef JSON_HEDLEY_GNUC_HAS_WARNING
22001
#undef JSON_HEDLEY_GNUC_VERSION
22002
#undef JSON_HEDLEY_GNUC_VERSION_CHECK
22003
#undef JSON_HEDLEY_HAS_ATTRIBUTE
22004
#undef JSON_HEDLEY_HAS_BUILTIN
22005
#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
22006
#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
22007
#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
22008
#undef JSON_HEDLEY_HAS_EXTENSION
22009
#undef JSON_HEDLEY_HAS_FEATURE
22010
#undef JSON_HEDLEY_HAS_WARNING
22011
#undef JSON_HEDLEY_IAR_VERSION
22012
#undef JSON_HEDLEY_IAR_VERSION_CHECK
22013
#undef JSON_HEDLEY_IBM_VERSION
22014
#undef JSON_HEDLEY_IBM_VERSION_CHECK
22015
#undef JSON_HEDLEY_IMPORT
22016
#undef JSON_HEDLEY_INLINE
22017
#undef JSON_HEDLEY_INTEL_CL_VERSION
22018
#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
22019
#undef JSON_HEDLEY_INTEL_VERSION
22020
#undef JSON_HEDLEY_INTEL_VERSION_CHECK
22021
#undef JSON_HEDLEY_IS_CONSTANT
22022
#undef JSON_HEDLEY_IS_CONSTEXPR_
22023
#undef JSON_HEDLEY_LIKELY
22024
#undef JSON_HEDLEY_MALLOC
22025
#undef JSON_HEDLEY_MCST_LCC_VERSION
22026
#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
22027
#undef JSON_HEDLEY_MESSAGE
22028
#undef JSON_HEDLEY_MSVC_VERSION
22029
#undef JSON_HEDLEY_MSVC_VERSION_CHECK
22030
#undef JSON_HEDLEY_NEVER_INLINE
22031
#undef JSON_HEDLEY_NON_NULL
22032
#undef JSON_HEDLEY_NO_ESCAPE
22033
#undef JSON_HEDLEY_NO_RETURN
22034
#undef JSON_HEDLEY_NO_THROW
22035
#undef JSON_HEDLEY_NULL
22036
#undef JSON_HEDLEY_PELLES_VERSION
22037
#undef JSON_HEDLEY_PELLES_VERSION_CHECK
22038
#undef JSON_HEDLEY_PGI_VERSION
22039
#undef JSON_HEDLEY_PGI_VERSION_CHECK
22040
#undef JSON_HEDLEY_PREDICT
22041
#undef JSON_HEDLEY_PRINTF_FORMAT
22042
#undef JSON_HEDLEY_PRIVATE
22043
#undef JSON_HEDLEY_PUBLIC
22044
#undef JSON_HEDLEY_PURE
22045
#undef JSON_HEDLEY_REINTERPRET_CAST
22046
#undef JSON_HEDLEY_REQUIRE
22047
#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
22048
#undef JSON_HEDLEY_REQUIRE_MSG
22049
#undef JSON_HEDLEY_RESTRICT
22050
#undef JSON_HEDLEY_RETURNS_NON_NULL
22051
#undef JSON_HEDLEY_SENTINEL
22052
#undef JSON_HEDLEY_STATIC_ASSERT
22053
#undef JSON_HEDLEY_STATIC_CAST
22054
#undef JSON_HEDLEY_STRINGIFY
22055
#undef JSON_HEDLEY_STRINGIFY_EX
22056
#undef JSON_HEDLEY_SUNPRO_VERSION
22057
#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
22058
#undef JSON_HEDLEY_TINYC_VERSION
22059
#undef JSON_HEDLEY_TINYC_VERSION_CHECK
22060
#undef JSON_HEDLEY_TI_ARMCL_VERSION
22061
#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
22062
#undef JSON_HEDLEY_TI_CL2000_VERSION
22063
#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
22064
#undef JSON_HEDLEY_TI_CL430_VERSION
22065
#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
22066
#undef JSON_HEDLEY_TI_CL6X_VERSION
22067
#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
22068
#undef JSON_HEDLEY_TI_CL7X_VERSION
22069
#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
22070
#undef JSON_HEDLEY_TI_CLPRU_VERSION
22071
#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
22072
#undef JSON_HEDLEY_TI_VERSION
22073
#undef JSON_HEDLEY_TI_VERSION_CHECK
22074
#undef JSON_HEDLEY_UNAVAILABLE
22075
#undef JSON_HEDLEY_UNLIKELY
22076
#undef JSON_HEDLEY_UNPREDICTABLE
22077
#undef JSON_HEDLEY_UNREACHABLE
22078
#undef JSON_HEDLEY_UNREACHABLE_RETURN
22079
#undef JSON_HEDLEY_VERSION
22080
#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
22081
#undef JSON_HEDLEY_VERSION_DECODE_MINOR
22082
#undef JSON_HEDLEY_VERSION_DECODE_REVISION
22083
#undef JSON_HEDLEY_VERSION_ENCODE
22084
#undef JSON_HEDLEY_WARNING
22085
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
22086
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
22087
#undef JSON_HEDLEY_FALL_THROUGH
22088

22089

22090

22091
#endif  // INCLUDE_NLOHMANN_JSON_HPP_
22092

22093
Product

Resources

Company
