30 #ifndef INCLUDE_NLOHMANN_JSON_HPP_
31 #define INCLUDE_NLOHMANN_JSON_HPP_
33 #define NLOHMANN_JSON_VERSION_MAJOR 3
34 #define NLOHMANN_JSON_VERSION_MINOR 10
35 #define NLOHMANN_JSON_VERSION_PATCH 0
40 #include <initializer_list>
54 #include <type_traits>
62 #include <forward_list>
67 #include <type_traits>
68 #include <unordered_map>
120 enum class value_t : std::uint8_t
147 inline bool operator<(
const value_t lhs,
const value_t rhs) noexcept
149 static constexpr std::array<std::uint8_t, 9> order = {{
156 const auto l_index =
static_cast<std::size_t
>(lhs);
157 const auto r_index =
static_cast<std::size_t
>(rhs);
158 return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
186 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
187 #if defined(JSON_HEDLEY_VERSION)
188 #undef JSON_HEDLEY_VERSION
190 #define JSON_HEDLEY_VERSION 15
192 #if defined(JSON_HEDLEY_STRINGIFY_EX)
193 #undef JSON_HEDLEY_STRINGIFY_EX
195 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
197 #if defined(JSON_HEDLEY_STRINGIFY)
198 #undef JSON_HEDLEY_STRINGIFY
200 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
202 #if defined(JSON_HEDLEY_CONCAT_EX)
203 #undef JSON_HEDLEY_CONCAT_EX
205 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
207 #if defined(JSON_HEDLEY_CONCAT)
208 #undef JSON_HEDLEY_CONCAT
210 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
212 #if defined(JSON_HEDLEY_CONCAT3_EX)
213 #undef JSON_HEDLEY_CONCAT3_EX
215 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
217 #if defined(JSON_HEDLEY_CONCAT3)
218 #undef JSON_HEDLEY_CONCAT3
220 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
222 #if defined(JSON_HEDLEY_VERSION_ENCODE)
223 #undef JSON_HEDLEY_VERSION_ENCODE
225 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
227 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
228 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
230 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
232 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
233 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
235 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
237 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
238 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
240 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
242 #if defined(JSON_HEDLEY_GNUC_VERSION)
243 #undef JSON_HEDLEY_GNUC_VERSION
245 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
246 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
247 #elif defined(__GNUC__)
248 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
251 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
252 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
254 #if defined(JSON_HEDLEY_GNUC_VERSION)
255 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
257 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
260 #if defined(JSON_HEDLEY_MSVC_VERSION)
261 #undef JSON_HEDLEY_MSVC_VERSION
263 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
264 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
265 #elif defined(_MSC_FULL_VER) && !defined(__ICL)
266 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
267 #elif defined(_MSC_VER) && !defined(__ICL)
268 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
271 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
272 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
274 #if !defined(JSON_HEDLEY_MSVC_VERSION)
275 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
276 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
277 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
278 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
279 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
281 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
284 #if defined(JSON_HEDLEY_INTEL_VERSION)
285 #undef JSON_HEDLEY_INTEL_VERSION
287 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
288 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
289 #elif defined(__INTEL_COMPILER) && !defined(__ICL)
290 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
293 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
294 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
296 #if defined(JSON_HEDLEY_INTEL_VERSION)
297 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
299 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
302 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
303 #undef JSON_HEDLEY_INTEL_CL_VERSION
305 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
306 #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
309 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
310 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
312 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
313 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
315 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
318 #if defined(JSON_HEDLEY_PGI_VERSION)
319 #undef JSON_HEDLEY_PGI_VERSION
321 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
322 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
325 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
326 #undef JSON_HEDLEY_PGI_VERSION_CHECK
328 #if defined(JSON_HEDLEY_PGI_VERSION)
329 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
331 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
334 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
335 #undef JSON_HEDLEY_SUNPRO_VERSION
337 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
338 #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)
339 #elif defined(__SUNPRO_C)
340 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
341 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
342 #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)
343 #elif defined(__SUNPRO_CC)
344 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
347 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
348 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
350 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
351 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
353 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
356 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
357 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
359 #if defined(__EMSCRIPTEN__)
360 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
363 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
364 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
366 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
367 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
369 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
372 #if defined(JSON_HEDLEY_ARM_VERSION)
373 #undef JSON_HEDLEY_ARM_VERSION
375 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
376 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
377 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
378 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
381 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
382 #undef JSON_HEDLEY_ARM_VERSION_CHECK
384 #if defined(JSON_HEDLEY_ARM_VERSION)
385 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
387 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
390 #if defined(JSON_HEDLEY_IBM_VERSION)
391 #undef JSON_HEDLEY_IBM_VERSION
393 #if defined(__ibmxl__)
394 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
395 #elif defined(__xlC__) && defined(__xlC_ver__)
396 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
397 #elif defined(__xlC__)
398 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
401 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
402 #undef JSON_HEDLEY_IBM_VERSION_CHECK
404 #if defined(JSON_HEDLEY_IBM_VERSION)
405 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
407 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
410 #if defined(JSON_HEDLEY_TI_VERSION)
411 #undef JSON_HEDLEY_TI_VERSION
414 defined(__TI_COMPILER_VERSION__) && \
416 defined(__TMS470__) || defined(__TI_ARM__) || \
417 defined(__MSP430__) || \
418 defined(__TMS320C2000__) \
420 #if (__TI_COMPILER_VERSION__ >= 16000000)
421 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
425 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
426 #undef JSON_HEDLEY_TI_VERSION_CHECK
428 #if defined(JSON_HEDLEY_TI_VERSION)
429 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
431 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
434 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
435 #undef JSON_HEDLEY_TI_CL2000_VERSION
437 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
438 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
441 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
442 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
444 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
445 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
447 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
450 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
451 #undef JSON_HEDLEY_TI_CL430_VERSION
453 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
454 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
457 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
458 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
460 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
461 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
463 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
466 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
467 #undef JSON_HEDLEY_TI_ARMCL_VERSION
469 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
470 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
473 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
474 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
476 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
477 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
479 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
482 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
483 #undef JSON_HEDLEY_TI_CL6X_VERSION
485 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
486 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
489 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
490 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
492 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
493 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
495 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
498 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
499 #undef JSON_HEDLEY_TI_CL7X_VERSION
501 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
502 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
505 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
506 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
508 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
509 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
511 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
514 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
515 #undef JSON_HEDLEY_TI_CLPRU_VERSION
517 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
518 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
521 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
522 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
524 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
525 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
527 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
530 #if defined(JSON_HEDLEY_CRAY_VERSION)
531 #undef JSON_HEDLEY_CRAY_VERSION
534 #if defined(_RELEASE_PATCHLEVEL)
535 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
537 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
541 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
542 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
544 #if defined(JSON_HEDLEY_CRAY_VERSION)
545 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
547 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
550 #if defined(JSON_HEDLEY_IAR_VERSION)
551 #undef JSON_HEDLEY_IAR_VERSION
553 #if defined(__IAR_SYSTEMS_ICC__)
555 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
557 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
561 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
562 #undef JSON_HEDLEY_IAR_VERSION_CHECK
564 #if defined(JSON_HEDLEY_IAR_VERSION)
565 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
567 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
570 #if defined(JSON_HEDLEY_TINYC_VERSION)
571 #undef JSON_HEDLEY_TINYC_VERSION
573 #if defined(__TINYC__)
574 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
577 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
578 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
580 #if defined(JSON_HEDLEY_TINYC_VERSION)
581 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
583 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
586 #if defined(JSON_HEDLEY_DMC_VERSION)
587 #undef JSON_HEDLEY_DMC_VERSION
590 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
593 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
594 #undef JSON_HEDLEY_DMC_VERSION_CHECK
596 #if defined(JSON_HEDLEY_DMC_VERSION)
597 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
599 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
602 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
603 #undef JSON_HEDLEY_COMPCERT_VERSION
605 #if defined(__COMPCERT_VERSION__)
606 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
609 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
610 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
612 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
613 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
615 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
618 #if defined(JSON_HEDLEY_PELLES_VERSION)
619 #undef JSON_HEDLEY_PELLES_VERSION
621 #if defined(__POCC__)
622 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
625 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
626 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
628 #if defined(JSON_HEDLEY_PELLES_VERSION)
629 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
631 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
634 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
635 #undef JSON_HEDLEY_MCST_LCC_VERSION
637 #if defined(__LCC__) && defined(__LCC_MINOR__)
638 #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
641 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
642 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
644 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
645 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
647 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
650 #if defined(JSON_HEDLEY_GCC_VERSION)
651 #undef JSON_HEDLEY_GCC_VERSION
654 defined(JSON_HEDLEY_GNUC_VERSION) && \
655 !defined(__clang__) && \
656 !defined(JSON_HEDLEY_INTEL_VERSION) && \
657 !defined(JSON_HEDLEY_PGI_VERSION) && \
658 !defined(JSON_HEDLEY_ARM_VERSION) && \
659 !defined(JSON_HEDLEY_CRAY_VERSION) && \
660 !defined(JSON_HEDLEY_TI_VERSION) && \
661 !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
662 !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
663 !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
664 !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
665 !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
666 !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
667 !defined(__COMPCERT__) && \
668 !defined(JSON_HEDLEY_MCST_LCC_VERSION)
669 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
672 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
673 #undef JSON_HEDLEY_GCC_VERSION_CHECK
675 #if defined(JSON_HEDLEY_GCC_VERSION)
676 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
678 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
681 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
682 #undef JSON_HEDLEY_HAS_ATTRIBUTE
685 defined(__has_attribute) && \
687 (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
689 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
691 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
694 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
695 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
697 #if defined(__has_attribute)
698 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
700 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
703 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
704 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
706 #if defined(__has_attribute)
707 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
709 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
712 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
713 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
716 defined(__has_cpp_attribute) && \
717 defined(__cplusplus) && \
718 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
719 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
721 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
724 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
725 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
727 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
728 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
730 !defined(JSON_HEDLEY_PGI_VERSION) && \
731 !defined(JSON_HEDLEY_IAR_VERSION) && \
732 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
733 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
734 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
736 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
739 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
740 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
742 #if defined(__has_cpp_attribute) && defined(__cplusplus)
743 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
745 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
748 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
749 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
751 #if defined(__has_cpp_attribute) && defined(__cplusplus)
752 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
754 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
757 #if defined(JSON_HEDLEY_HAS_BUILTIN)
758 #undef JSON_HEDLEY_HAS_BUILTIN
760 #if defined(__has_builtin)
761 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
763 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
766 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
767 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
769 #if defined(__has_builtin)
770 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
772 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
775 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
776 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
778 #if defined(__has_builtin)
779 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
781 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
784 #if defined(JSON_HEDLEY_HAS_FEATURE)
785 #undef JSON_HEDLEY_HAS_FEATURE
787 #if defined(__has_feature)
788 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
790 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
793 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
794 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
796 #if defined(__has_feature)
797 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
799 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
802 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
803 #undef JSON_HEDLEY_GCC_HAS_FEATURE
805 #if defined(__has_feature)
806 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
808 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
811 #if defined(JSON_HEDLEY_HAS_EXTENSION)
812 #undef JSON_HEDLEY_HAS_EXTENSION
814 #if defined(__has_extension)
815 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
817 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
820 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
821 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
823 #if defined(__has_extension)
824 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
826 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
829 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
830 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
832 #if defined(__has_extension)
833 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
835 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
838 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
839 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
841 #if defined(__has_declspec_attribute)
842 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
844 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
847 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
848 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
850 #if defined(__has_declspec_attribute)
851 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
853 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
856 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
857 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
859 #if defined(__has_declspec_attribute)
860 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
862 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
865 #if defined(JSON_HEDLEY_HAS_WARNING)
866 #undef JSON_HEDLEY_HAS_WARNING
868 #if defined(__has_warning)
869 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
871 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
874 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
875 #undef JSON_HEDLEY_GNUC_HAS_WARNING
877 #if defined(__has_warning)
878 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
880 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
883 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
884 #undef JSON_HEDLEY_GCC_HAS_WARNING
886 #if defined(__has_warning)
887 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
889 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
893 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
894 defined(__clang__) || \
895 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
896 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
897 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
898 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
899 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
900 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
901 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
902 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
903 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
904 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
905 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
906 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
907 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
908 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
909 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
910 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
911 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
912 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
913 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
915 #define JSON_HEDLEY_PRAGMA(value)
918 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
919 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
921 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
922 #undef JSON_HEDLEY_DIAGNOSTIC_POP
924 #if defined(__clang__)
925 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
926 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
927 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
928 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
929 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
930 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
931 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
932 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
934 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
935 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
936 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
937 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
938 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
939 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
940 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
942 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
943 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
944 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
945 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
946 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
947 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
948 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
949 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
950 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
951 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
952 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
954 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
955 #define JSON_HEDLEY_DIAGNOSTIC_POP
960 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
961 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
963 #if defined(__cplusplus)
964 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
965 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
966 # if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
967 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
968 JSON_HEDLEY_DIAGNOSTIC_PUSH \
969 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
970 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
971 _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
973 JSON_HEDLEY_DIAGNOSTIC_POP
975 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
976 JSON_HEDLEY_DIAGNOSTIC_PUSH \
977 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
978 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
980 JSON_HEDLEY_DIAGNOSTIC_POP
983 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
984 JSON_HEDLEY_DIAGNOSTIC_PUSH \
985 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
987 JSON_HEDLEY_DIAGNOSTIC_POP
991 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
992 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
995 #if defined(JSON_HEDLEY_CONST_CAST)
996 #undef JSON_HEDLEY_CONST_CAST
998 #if defined(__cplusplus)
999 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1001 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1002 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1003 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1004 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1005 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1006 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1008 JSON_HEDLEY_DIAGNOSTIC_POP \
1011 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1014 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
1015 #undef JSON_HEDLEY_REINTERPRET_CAST
1017 #if defined(__cplusplus)
1018 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1020 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1023 #if defined(JSON_HEDLEY_STATIC_CAST)
1024 #undef JSON_HEDLEY_STATIC_CAST
1026 #if defined(__cplusplus)
1027 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1029 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1032 #if defined(JSON_HEDLEY_CPP_CAST)
1033 #undef JSON_HEDLEY_CPP_CAST
1035 #if defined(__cplusplus)
1036 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1037 # define JSON_HEDLEY_CPP_CAST(T, expr) \
1038 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1039 _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1041 JSON_HEDLEY_DIAGNOSTIC_POP
1042 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1043 # define JSON_HEDLEY_CPP_CAST(T, expr) \
1044 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1045 _Pragma("diag_suppress=Pe137") \
1046 JSON_HEDLEY_DIAGNOSTIC_POP
1048 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1051 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1054 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1055 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1057 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1058 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1059 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1060 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1061 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1062 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1063 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1064 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1065 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1066 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1067 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1068 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1069 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1070 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1071 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1072 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1074 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1075 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1076 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1077 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1078 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1079 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1080 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1081 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1082 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1083 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1084 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1085 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1086 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1087 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1088 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1089 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1090 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1091 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1092 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1093 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1095 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1098 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1099 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1101 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1102 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1103 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1104 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1105 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1106 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1107 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1108 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1109 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1110 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1111 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1112 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1114 JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1115 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1116 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1117 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1118 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1119 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1120 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1121 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1122 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1123 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1124 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1126 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1129 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1130 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1132 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1133 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1134 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1135 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1136 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1137 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1138 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1139 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1140 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1141 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1142 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1143 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1144 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1145 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1146 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1147 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1149 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1150 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1151 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1152 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1153 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1154 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1155 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1156 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1158 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1161 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1162 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1164 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1165 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1166 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1167 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1168 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1169 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1171 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1174 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1175 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1177 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1178 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1179 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1180 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1181 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1182 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1183 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1184 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1186 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1189 #if defined(JSON_HEDLEY_DEPRECATED)
1190 #undef JSON_HEDLEY_DEPRECATED
1192 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1193 #undef JSON_HEDLEY_DEPRECATED_FOR
1196 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1197 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1198 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1199 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1201 (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1202 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1203 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1204 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1205 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1206 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1207 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1208 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1209 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1210 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1211 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1212 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1213 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1214 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1215 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1216 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1217 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1219 JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1220 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1221 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1222 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1223 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1224 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1225 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1226 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1227 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1228 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1229 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1230 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1231 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1232 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1233 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1234 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1235 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1236 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1238 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1239 JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1240 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1241 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1242 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1243 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1244 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1245 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1247 #define JSON_HEDLEY_DEPRECATED(since)
1248 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1251 #if defined(JSON_HEDLEY_UNAVAILABLE)
1252 #undef JSON_HEDLEY_UNAVAILABLE
1255 JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1256 JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1257 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1258 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1259 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1261 #define JSON_HEDLEY_UNAVAILABLE(available_since)
1271 JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1272 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1273 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1274 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1275 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1276 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1277 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1278 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1279 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1280 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1281 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1282 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1283 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1284 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1285 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1286 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1287 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1288 #define __attribute__((__warn_unused_result__))
1289 #define _MSG(msg) __attribute__((__warn_unused_result__))
1290 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1291 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1292 #define _MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1293 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1294 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1295 #define _MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1296 #elif defined(_Check_return_)
1297 #define _Check_return_
1298 #define _MSG(msg) _Check_return_
1304 #if defined(JSON_HEDLEY_SENTINEL)
1305 #undef JSON_HEDLEY_SENTINEL
1308 JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1309 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1310 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1311 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1312 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1313 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1315 #define JSON_HEDLEY_SENTINEL(position)
1318 #if defined(JSON_HEDLEY_NO_RETURN)
1319 #undef JSON_HEDLEY_NO_RETURN
1321 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1322 #define JSON_HEDLEY_NO_RETURN __noreturn
1324 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1325 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1326 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1327 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1328 #define JSON_HEDLEY_NO_RETURN _Noreturn
1329 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1330 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1332 JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1333 JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1334 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1335 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1336 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1337 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1338 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1339 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1340 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1341 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1342 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1343 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1344 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1345 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1346 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1347 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1348 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1349 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1350 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1351 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1353 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1354 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1355 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1356 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1357 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1358 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1359 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1360 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1361 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1363 #define JSON_HEDLEY_NO_RETURN
1366 #if defined(JSON_HEDLEY_NO_ESCAPE)
1367 #undef JSON_HEDLEY_NO_ESCAPE
1369 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1370 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1372 #define JSON_HEDLEY_NO_ESCAPE
1375 #if defined(JSON_HEDLEY_UNREACHABLE)
1376 #undef JSON_HEDLEY_UNREACHABLE
1378 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1379 #undef JSON_HEDLEY_UNREACHABLE_RETURN
1381 #if defined(JSON_HEDLEY_ASSUME)
1382 #undef JSON_HEDLEY_ASSUME
1385 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1386 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1387 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1388 #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1389 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1390 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1392 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1393 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1394 #if defined(__cplusplus)
1395 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1397 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1401 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1402 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1403 JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1404 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1405 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1406 JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1407 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1408 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1409 #elif defined(JSON_HEDLEY_ASSUME)
1410 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1412 #if !defined(JSON_HEDLEY_ASSUME)
1413 #if defined(JSON_HEDLEY_UNREACHABLE)
1414 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1416 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1419 #if defined(JSON_HEDLEY_UNREACHABLE)
1421 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1422 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1423 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1425 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1428 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1430 #if !defined(JSON_HEDLEY_UNREACHABLE)
1431 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1434 JSON_HEDLEY_DIAGNOSTIC_PUSH
1435 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1436 #pragma clang diagnostic ignored "-Wpedantic"
1438 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1439 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1441 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1442 #if defined(__clang__)
1443 #pragma clang diagnostic ignored "-Wvariadic-macros"
1444 #elif defined(JSON_HEDLEY_GCC_VERSION)
1445 #pragma GCC diagnostic ignored "-Wvariadic-macros"
1448 #if defined(JSON_HEDLEY_NON_NULL)
1449 #undef JSON_HEDLEY_NON_NULL
1452 JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1453 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1454 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1455 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1456 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1458 #define JSON_HEDLEY_NON_NULL(...)
1460 JSON_HEDLEY_DIAGNOSTIC_POP
1462 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1463 #undef JSON_HEDLEY_PRINTF_FORMAT
1465 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1466 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1467 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1468 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1470 JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1471 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1472 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1473 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1474 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1475 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1476 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1477 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1478 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1479 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1480 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1481 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1482 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1483 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1484 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1485 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1486 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1487 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1488 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1489 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1491 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1494 #if defined(JSON_HEDLEY_CONSTEXPR)
1495 #undef JSON_HEDLEY_CONSTEXPR
1497 #if defined(__cplusplus)
1498 #if __cplusplus >= 201103L
1499 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1502 #if !defined(JSON_HEDLEY_CONSTEXPR)
1503 #define JSON_HEDLEY_CONSTEXPR
1506 #if defined(JSON_HEDLEY_PREDICT)
1507 #undef JSON_HEDLEY_PREDICT
1509 #if defined(JSON_HEDLEY_LIKELY)
1510 #undef JSON_HEDLEY_LIKELY
1512 #if defined(JSON_HEDLEY_UNLIKELY)
1513 #undef JSON_HEDLEY_UNLIKELY
1515 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1516 #undef JSON_HEDLEY_UNPREDICTABLE
1518 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1519 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1522 (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1523 JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1524 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1525 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))
1526 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))
1527 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))
1528 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )
1529 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )
1531 (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1532 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1533 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1534 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1535 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1536 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1537 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1538 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1539 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1540 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1541 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1542 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1543 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1544 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1545 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1546 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1547 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1548 (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1549 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1551 double hedley_probability_ = (probability); \
1552 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1554 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1556 double hedley_probability_ = (probability); \
1557 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1559 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1560 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1562 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1563 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1564 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1565 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1566 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1568 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1569 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1572 #if defined(JSON_HEDLEY_MALLOC)
1573 #undef JSON_HEDLEY_MALLOC
1576 JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1577 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1578 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1579 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1580 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1581 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1582 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1583 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1584 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1585 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1586 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1587 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1588 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1589 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1590 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1591 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1592 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1593 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1594 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1595 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1596 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1598 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1599 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1600 #define JSON_HEDLEY_MALLOC __declspec(restrict)
1602 #define JSON_HEDLEY_MALLOC
1605 #if defined(JSON_HEDLEY_PURE)
1606 #undef JSON_HEDLEY_PURE
1609 JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1610 JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1611 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1612 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1613 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1614 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1615 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1616 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1617 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1618 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1619 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1620 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1621 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1622 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1623 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1624 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1625 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1626 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1627 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1628 # define JSON_HEDLEY_PURE __attribute__((__pure__))
1629 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1630 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1631 #elif defined(__cplusplus) && \
1633 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1634 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1635 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1637 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1639 # define JSON_HEDLEY_PURE
1642 #if defined(JSON_HEDLEY_CONST)
1643 #undef JSON_HEDLEY_CONST
1646 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1647 JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1648 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1649 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1650 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1651 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1652 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1653 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1654 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1655 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1656 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1657 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1658 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1659 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1660 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1661 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1662 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1663 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1664 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1665 #define JSON_HEDLEY_CONST __attribute__((__const__))
1667 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1668 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1670 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1673 #if defined(JSON_HEDLEY_RESTRICT)
1674 #undef JSON_HEDLEY_RESTRICT
1676 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1677 #define JSON_HEDLEY_RESTRICT restrict
1679 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1680 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1681 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1682 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1683 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1684 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1685 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1686 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1687 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1688 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1689 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1690 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1691 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1692 defined(__clang__) || \
1693 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1694 #define JSON_HEDLEY_RESTRICT __restrict
1695 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1696 #define JSON_HEDLEY_RESTRICT _Restrict
1698 #define JSON_HEDLEY_RESTRICT
1701 #if defined(JSON_HEDLEY_INLINE)
1702 #undef JSON_HEDLEY_INLINE
1705 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1706 (defined(__cplusplus) && (__cplusplus >= 199711L))
1707 #define JSON_HEDLEY_INLINE inline
1709 defined(JSON_HEDLEY_GCC_VERSION) || \
1710 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1711 #define JSON_HEDLEY_INLINE __inline__
1713 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1714 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1715 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1716 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1717 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1718 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1719 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1720 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1721 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1722 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1723 #define JSON_HEDLEY_INLINE __inline
1725 #define JSON_HEDLEY_INLINE
1728 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1729 #undef JSON_HEDLEY_ALWAYS_INLINE
1732 JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1733 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1734 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1735 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1736 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1737 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1738 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1739 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1740 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1741 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1742 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1743 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1744 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1745 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1746 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1747 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1748 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1749 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1750 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1751 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1753 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1754 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1755 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1756 #elif defined(__cplusplus) && \
1758 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1759 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1760 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1761 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1762 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1763 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1765 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1766 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1767 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1769 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1772 #if defined(JSON_HEDLEY_NEVER_INLINE)
1773 #undef JSON_HEDLEY_NEVER_INLINE
1776 JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1777 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1778 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1779 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1780 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1781 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1782 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1783 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1784 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1785 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1786 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1787 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1788 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1789 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1790 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1791 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1792 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1793 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1794 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1795 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1797 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1798 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1799 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1800 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1801 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1802 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1803 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1804 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1805 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1806 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1807 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1808 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1809 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1811 #define JSON_HEDLEY_NEVER_INLINE
1814 #if defined(JSON_HEDLEY_PRIVATE)
1815 #undef JSON_HEDLEY_PRIVATE
1817 #if defined(JSON_HEDLEY_PUBLIC)
1818 #undef JSON_HEDLEY_PUBLIC
1820 #if defined(JSON_HEDLEY_IMPORT)
1821 #undef JSON_HEDLEY_IMPORT
1823 #if defined(_WIN32) || defined(__CYGWIN__)
1824 # define JSON_HEDLEY_PRIVATE
1825 # define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1826 # define JSON_HEDLEY_IMPORT __declspec(dllimport)
1829 JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1830 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1831 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1832 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1833 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1834 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1836 defined(__TI_EABI__) && \
1838 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1839 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1842 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1843 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1844 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1846 # define JSON_HEDLEY_PRIVATE
1847 # define JSON_HEDLEY_PUBLIC
1849 # define JSON_HEDLEY_IMPORT extern
1852 #if defined(JSON_HEDLEY_NO_THROW)
1853 #undef JSON_HEDLEY_NO_THROW
1856 JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1857 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1858 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1859 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1860 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1862 JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1863 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1864 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1865 #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1867 #define JSON_HEDLEY_NO_THROW
1870 #if defined(JSON_HEDLEY_FALL_THROUGH)
1871 #undef JSON_HEDLEY_FALL_THROUGH
1874 JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1875 JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
1876 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1877 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1878 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1879 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1880 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1881 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1882 #elif defined(__fallthrough)
1883 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1885 #define JSON_HEDLEY_FALL_THROUGH
1892 JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1893 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1894 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1895 #define __attribute__((__returns_nonnull__))
1896 #elif defined(_Ret_notnull_)
1897 #define _Ret_notnull_
1902 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1903 #undef JSON_HEDLEY_ARRAY_PARAM
1906 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1907 !defined(__STDC_NO_VLA__) && \
1908 !defined(__cplusplus) && \
1909 !defined(JSON_HEDLEY_PGI_VERSION) && \
1910 !defined(JSON_HEDLEY_TINYC_VERSION)
1911 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1913 #define JSON_HEDLEY_ARRAY_PARAM(name)
1916 #if defined(JSON_HEDLEY_IS_CONSTANT)
1917 #undef JSON_HEDLEY_IS_CONSTANT
1919 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1920 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1924 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1925 #undef JSON_HEDLEY_IS_CONSTEXPR_
1928 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1929 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1930 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1931 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1932 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1933 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1934 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1935 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1936 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1937 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1938 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1940 #if !defined(__cplusplus)
1942 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1943 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1944 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1945 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1946 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1947 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1948 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1949 #if defined(__INTPTR_TYPE__)
1950 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1953 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1957 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1958 !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1959 !defined(JSON_HEDLEY_PGI_VERSION) && \
1960 !defined(JSON_HEDLEY_IAR_VERSION)) || \
1961 (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1962 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1963 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1964 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1965 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1966 #if defined(__INTPTR_TYPE__)
1967 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1970 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1973 defined(JSON_HEDLEY_GCC_VERSION) || \
1974 defined(JSON_HEDLEY_INTEL_VERSION) || \
1975 defined(JSON_HEDLEY_TINYC_VERSION) || \
1976 defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1977 JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1978 defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1979 defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1980 defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1981 defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1983 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1987 ((void*) ((expr) * 0L) ) : \
1988 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1994 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1995 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1996 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1998 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2000 #if !defined(JSON_HEDLEY_IS_CONSTANT)
2001 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2003 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2006 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2007 #undef JSON_HEDLEY_BEGIN_C_DECLS
2009 #if defined(JSON_HEDLEY_END_C_DECLS)
2010 #undef JSON_HEDLEY_END_C_DECLS
2012 #if defined(JSON_HEDLEY_C_DECL)
2013 #undef JSON_HEDLEY_C_DECL
2015 #if defined(__cplusplus)
2016 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2017 #define JSON_HEDLEY_END_C_DECLS }
2018 #define JSON_HEDLEY_C_DECL extern "C"
2020 #define JSON_HEDLEY_BEGIN_C_DECLS
2021 #define JSON_HEDLEY_END_C_DECLS
2022 #define JSON_HEDLEY_C_DECL
2025 #if defined(JSON_HEDLEY_STATIC_ASSERT)
2026 #undef JSON_HEDLEY_STATIC_ASSERT
2029 !defined(__cplusplus) && ( \
2030 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2031 (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2032 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2033 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2034 defined(_Static_assert) \
2036 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2038 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2039 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2040 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2041 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2043 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2046 #if defined(JSON_HEDLEY_NULL)
2047 #undef JSON_HEDLEY_NULL
2049 #if defined(__cplusplus)
2050 #if __cplusplus >= 201103L
2051 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2053 #define JSON_HEDLEY_NULL NULL
2055 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2058 #define JSON_HEDLEY_NULL NULL
2060 #define JSON_HEDLEY_NULL ((void*) 0)
2063 #if defined(JSON_HEDLEY_MESSAGE)
2064 #undef JSON_HEDLEY_MESSAGE
2066 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2067 # define JSON_HEDLEY_MESSAGE(msg) \
2068 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2069 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2070 JSON_HEDLEY_PRAGMA(message msg) \
2071 JSON_HEDLEY_DIAGNOSTIC_POP
2073 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2074 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2075 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2076 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2077 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2078 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2079 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2080 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2081 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2083 # define JSON_HEDLEY_MESSAGE(msg)
2086 #if defined(JSON_HEDLEY_WARNING)
2087 #undef JSON_HEDLEY_WARNING
2089 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2090 # define JSON_HEDLEY_WARNING(msg) \
2091 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2092 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2093 JSON_HEDLEY_PRAGMA(clang warning msg) \
2094 JSON_HEDLEY_DIAGNOSTIC_POP
2096 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2097 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2098 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2099 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2101 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2102 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2103 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2105 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2108 #if defined(JSON_HEDLEY_REQUIRE)
2109 #undef JSON_HEDLEY_REQUIRE
2111 #if defined(JSON_HEDLEY_REQUIRE_MSG)
2112 #undef JSON_HEDLEY_REQUIRE_MSG
2114 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2115 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2116 # define JSON_HEDLEY_REQUIRE(expr) \
2117 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2118 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2119 __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2120 JSON_HEDLEY_DIAGNOSTIC_POP
2121 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2122 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2123 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2124 __attribute__((diagnose_if(!(expr), msg, "error"))) \
2125 JSON_HEDLEY_DIAGNOSTIC_POP
2127 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2128 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2131 # define JSON_HEDLEY_REQUIRE(expr)
2132 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2135 #if defined(JSON_HEDLEY_FLAGS)
2136 #undef JSON_HEDLEY_FLAGS
2138 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2139 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2141 #define JSON_HEDLEY_FLAGS
2144 #if defined(JSON_HEDLEY_FLAGS_CAST)
2145 #undef JSON_HEDLEY_FLAGS_CAST
2147 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2148 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2149 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2150 _Pragma("warning(disable:188)") \
2152 JSON_HEDLEY_DIAGNOSTIC_POP \
2155 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2158 #if defined(JSON_HEDLEY_EMPTY_BASES)
2159 #undef JSON_HEDLEY_EMPTY_BASES
2162 (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2163 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2164 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2166 #define JSON_HEDLEY_EMPTY_BASES
2171 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2172 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2174 #if defined(__clang__)
2175 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2177 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2180 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2181 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2183 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2185 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2186 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2188 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2190 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2191 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2193 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2195 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2196 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2198 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2200 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2201 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2203 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2205 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2206 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2208 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2210 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2211 #undef JSON_HEDLEY_CLANG_HAS_WARNING
2213 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2222 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2223 #if defined(__clang__)
2224 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2225 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2227 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2228 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2229 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2236 #if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2237 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2238 #define JSON_HAS_CPP_20
2239 #define JSON_HAS_CPP_17
2240 #define JSON_HAS_CPP_14
2241 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
2242 #define JSON_HAS_CPP_17
2243 #define JSON_HAS_CPP_14
2244 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2245 #define JSON_HAS_CPP_14
2248 #define JSON_HAS_CPP_11
2252 #if defined(__clang__)
2253 #pragma clang diagnostic push
2254 #pragma clang diagnostic ignored "-Wdocumentation"
2255 #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2259 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2260 #define JSON_THROW(exception) throw exception
2261 #define JSON_TRY try
2262 #define JSON_CATCH(exception) catch(exception)
2263 #define JSON_INTERNAL_CATCH(exception) catch(exception)
2266 #define JSON_THROW(exception) std::abort()
2267 #define JSON_TRY if(true)
2268 #define JSON_CATCH(exception) if(false)
2269 #define JSON_INTERNAL_CATCH(exception) if(false)
2273 #if defined(JSON_THROW_USER)
2275 #define JSON_THROW JSON_THROW_USER
2277 #if defined(JSON_TRY_USER)
2279 #define JSON_TRY JSON_TRY_USER
2281 #if defined(JSON_CATCH_USER)
2283 #define JSON_CATCH JSON_CATCH_USER
2284 #undef JSON_INTERNAL_CATCH
2285 #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2287 #if defined(JSON_INTERNAL_CATCH_USER)
2288 #undef JSON_INTERNAL_CATCH
2289 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2293 #if !defined(JSON_ASSERT)
2295 #define JSON_ASSERT(x) assert(x)
2299 #if defined(JSON_TESTS_PRIVATE)
2300 #define JSON_PRIVATE_UNLESS_TESTED public
2302 #define JSON_PRIVATE_UNLESS_TESTED private
2310 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2311 template<typename BasicJsonType> \
2312 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2314 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2315 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2316 auto it = std::find_if(std::begin(m), std::end(m), \
2317 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2319 return ej_pair.first == e; \
2321 j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2323 template<typename BasicJsonType> \
2324 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2326 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2327 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2328 auto it = std::find_if(std::begin(m), std::end(m), \
2329 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2331 return ej_pair.second == j; \
2333 e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2339 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2340 template<template<typename, typename, typename...> class ObjectType, \
2341 template<typename, typename...> class ArrayType, \
2342 class StringType, class BooleanType, class NumberIntegerType, \
2343 class NumberUnsignedType, class NumberFloatType, \
2344 template<typename> class AllocatorType, \
2345 template<typename, typename = void> class JSONSerializer, \
2348 #define NLOHMANN_BASIC_JSON_TPL \
2349 basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2350 NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2351 AllocatorType, JSONSerializer, BinaryType>
2355 #define NLOHMANN_JSON_EXPAND( x ) x
2356 #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
2357 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2358 NLOHMANN_JSON_PASTE64, \
2359 NLOHMANN_JSON_PASTE63, \
2360 NLOHMANN_JSON_PASTE62, \
2361 NLOHMANN_JSON_PASTE61, \
2362 NLOHMANN_JSON_PASTE60, \
2363 NLOHMANN_JSON_PASTE59, \
2364 NLOHMANN_JSON_PASTE58, \
2365 NLOHMANN_JSON_PASTE57, \
2366 NLOHMANN_JSON_PASTE56, \
2367 NLOHMANN_JSON_PASTE55, \
2368 NLOHMANN_JSON_PASTE54, \
2369 NLOHMANN_JSON_PASTE53, \
2370 NLOHMANN_JSON_PASTE52, \
2371 NLOHMANN_JSON_PASTE51, \
2372 NLOHMANN_JSON_PASTE50, \
2373 NLOHMANN_JSON_PASTE49, \
2374 NLOHMANN_JSON_PASTE48, \
2375 NLOHMANN_JSON_PASTE47, \
2376 NLOHMANN_JSON_PASTE46, \
2377 NLOHMANN_JSON_PASTE45, \
2378 NLOHMANN_JSON_PASTE44, \
2379 NLOHMANN_JSON_PASTE43, \
2380 NLOHMANN_JSON_PASTE42, \
2381 NLOHMANN_JSON_PASTE41, \
2382 NLOHMANN_JSON_PASTE40, \
2383 NLOHMANN_JSON_PASTE39, \
2384 NLOHMANN_JSON_PASTE38, \
2385 NLOHMANN_JSON_PASTE37, \
2386 NLOHMANN_JSON_PASTE36, \
2387 NLOHMANN_JSON_PASTE35, \
2388 NLOHMANN_JSON_PASTE34, \
2389 NLOHMANN_JSON_PASTE33, \
2390 NLOHMANN_JSON_PASTE32, \
2391 NLOHMANN_JSON_PASTE31, \
2392 NLOHMANN_JSON_PASTE30, \
2393 NLOHMANN_JSON_PASTE29, \
2394 NLOHMANN_JSON_PASTE28, \
2395 NLOHMANN_JSON_PASTE27, \
2396 NLOHMANN_JSON_PASTE26, \
2397 NLOHMANN_JSON_PASTE25, \
2398 NLOHMANN_JSON_PASTE24, \
2399 NLOHMANN_JSON_PASTE23, \
2400 NLOHMANN_JSON_PASTE22, \
2401 NLOHMANN_JSON_PASTE21, \
2402 NLOHMANN_JSON_PASTE20, \
2403 NLOHMANN_JSON_PASTE19, \
2404 NLOHMANN_JSON_PASTE18, \
2405 NLOHMANN_JSON_PASTE17, \
2406 NLOHMANN_JSON_PASTE16, \
2407 NLOHMANN_JSON_PASTE15, \
2408 NLOHMANN_JSON_PASTE14, \
2409 NLOHMANN_JSON_PASTE13, \
2410 NLOHMANN_JSON_PASTE12, \
2411 NLOHMANN_JSON_PASTE11, \
2412 NLOHMANN_JSON_PASTE10, \
2413 NLOHMANN_JSON_PASTE9, \
2414 NLOHMANN_JSON_PASTE8, \
2415 NLOHMANN_JSON_PASTE7, \
2416 NLOHMANN_JSON_PASTE6, \
2417 NLOHMANN_JSON_PASTE5, \
2418 NLOHMANN_JSON_PASTE4, \
2419 NLOHMANN_JSON_PASTE3, \
2420 NLOHMANN_JSON_PASTE2, \
2421 NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2422 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2423 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2424 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2425 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2426 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2427 #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)
2428 #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)
2429 #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)
2430 #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)
2431 #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)
2432 #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)
2433 #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)
2434 #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)
2435 #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)
2436 #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)
2437 #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)
2438 #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)
2439 #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)
2440 #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)
2441 #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)
2442 #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)
2443 #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)
2444 #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)
2445 #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)
2446 #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)
2447 #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)
2448 #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)
2449 #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)
2450 #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)
2451 #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)
2452 #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)
2453 #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)
2454 #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)
2455 #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)
2456 #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)
2457 #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)
2458 #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)
2459 #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)
2460 #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)
2461 #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)
2462 #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)
2463 #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)
2464 #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)
2465 #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)
2466 #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)
2467 #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)
2468 #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)
2469 #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)
2470 #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)
2471 #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)
2472 #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)
2473 #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)
2474 #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)
2475 #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)
2476 #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)
2477 #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)
2478 #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)
2479 #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)
2480 #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)
2481 #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)
2482 #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)
2483 #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)
2484 #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)
2486 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2487 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2494 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2495 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__)) } \
2496 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__)) }
2503 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2504 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__)) } \
2505 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__)) }
2507 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2508 #define JSON_USE_IMPLICIT_CONVERSIONS 1
2511 #if JSON_USE_IMPLICIT_CONVERSIONS
2512 #define JSON_EXPLICIT
2514 #define JSON_EXPLICIT explicit
2536 inline void replace_substring(std::string& s,
const std::string& f,
2537 const std::string& t)
2539 JSON_ASSERT(!f.empty());
2540 for (
auto pos = s.find(f);
2541 pos != std::string::npos;
2542 s.replace(pos, f.size(), t),
2543 pos = s.find(f, pos + t.size()))
2554 inline std::string escape(std::string s)
2556 replace_substring(s,
"~",
"~0");
2557 replace_substring(s,
"/",
"~1");
2568 static void unescape(std::string& s)
2570 replace_substring(s,
"~1",
"/");
2571 replace_substring(s,
"~0",
"~");
2590 std::size_t chars_read_total = 0;
2592 std::size_t chars_read_current_line = 0;
2594 std::size_t lines_read = 0;
2597 constexpr
operator size_t()
const
2599 return chars_read_total;
2645 class exception :
public std::exception
2649 const char* what() const noexcept
override
2658 JSON_HEDLEY_NON_NULL(3)
2659 exception(
int id_, const
char* what_arg) :
id(id_), m(what_arg) {}
2661 static std::string name(
const std::string& ename,
int id_)
2663 return "[json.exception." + ename +
"." + std::to_string(id_) +
"] ";
2666 template<
typename BasicJsonType>
2667 static std::string diagnostics(
const BasicJsonType& leaf_element)
2669 #if JSON_DIAGNOSTICS
2670 std::vector<std::string> tokens;
2671 for (
const auto* current = &leaf_element; current->m_parent !=
nullptr; current = current->m_parent)
2673 switch (current->m_parent->type())
2675 case value_t::array:
2677 for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
2679 if (¤t->m_parent->m_value.array->operator[](i) == current)
2681 tokens.emplace_back(std::to_string(i));
2688 case value_t::object:
2690 for (
const auto& element : *current->m_parent->m_value.object)
2692 if (&element.second == current)
2694 tokens.emplace_back(element.first.c_str());
2702 case value_t::string:
2703 case value_t::boolean:
2704 case value_t::number_integer:
2705 case value_t::number_unsigned:
2706 case value_t::number_float:
2707 case value_t::binary:
2708 case value_t::discarded:
2719 return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
2720 [](
const std::string & a,
const std::string & b)
2722 return a +
"/" + detail::escape(b);
2725 static_cast<void>(leaf_element);
2732 std::runtime_error m;
2780 class parse_error :
public exception
2792 template<
typename BasicJsonType>
2793 static parse_error create(
int id_,
const position_t& pos,
const std::string& what_arg,
const BasicJsonType& context)
2795 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2796 position_string(pos) +
": " + exception::diagnostics(context) + what_arg;
2797 return parse_error(id_, pos.chars_read_total, w.c_str());
2800 template<
typename BasicJsonType>
2801 static parse_error create(
int id_, std::size_t byte_,
const std::string& what_arg,
const BasicJsonType& context)
2803 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2804 (byte_ != 0 ? (
" at byte " + std::to_string(byte_)) :
"") +
2805 ": " + exception::diagnostics(context) + what_arg;
2806 return parse_error(id_, byte_, w.c_str());
2818 const std::size_t byte;
2821 parse_error(
int id_, std::size_t byte_,
const char* what_arg)
2822 : exception(id_, what_arg), byte(byte_) {}
2824 static std::string position_string(
const position_t& pos)
2826 return " at line " + std::to_string(pos.lines_read + 1) +
2827 ", column " + std::to_string(pos.chars_read_current_line);
2868 class invalid_iterator :
public exception
2871 template<
typename BasicJsonType>
2872 static invalid_iterator create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2874 std::string w = exception::name(
"invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
2875 return invalid_iterator(id_, w.c_str());
2879 JSON_HEDLEY_NON_NULL(3)
2880 invalid_iterator(
int id_, const
char* what_arg)
2881 : exception(id_, what_arg) {}
2923 class type_error :
public exception
2926 template<
typename BasicJsonType>
2927 static type_error create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2929 std::string w = exception::name(
"type_error", id_) + exception::diagnostics(context) + what_arg;
2930 return type_error(id_, w.c_str());
2934 JSON_HEDLEY_NON_NULL(3)
2935 type_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
2971 class out_of_range :
public exception
2974 template<
typename BasicJsonType>
2975 static out_of_range create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2977 std::string w = exception::name(
"out_of_range", id_) + exception::diagnostics(context) + what_arg;
2978 return out_of_range(id_, w.c_str());
2982 JSON_HEDLEY_NON_NULL(3)
2983 out_of_range(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3010 class other_error :
public exception
3013 template<
typename BasicJsonType>
3014 static other_error create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
3016 std::string w = exception::name(
"other_error", id_) + exception::diagnostics(context) + what_arg;
3017 return other_error(id_, w.c_str());
3021 JSON_HEDLEY_NON_NULL(3)
3022 other_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3033 #include <type_traits>
3044 template<
typename T>
3045 using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3047 #ifdef JSON_HAS_CPP_14
3050 using std::enable_if_t;
3051 using std::index_sequence;
3052 using std::make_index_sequence;
3053 using std::index_sequence_for;
3058 template<
bool B,
typename T =
void>
3059 using enable_if_t =
typename std::enable_if<B, T>::type;
3085 template <
typename T, T... Ints>
3086 struct integer_sequence
3088 using value_type = T;
3089 static constexpr std::size_t size() noexcept
3091 return sizeof...(Ints);
3100 template <
size_t... Ints>
3101 using index_sequence = integer_sequence<size_t, Ints...>;
3103 namespace utility_internal
3106 template <
typename Seq,
size_t SeqSize,
size_t Rem>
3110 template <
typename T, T... Ints,
size_t SeqSize>
3111 struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3113 using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3116 template <
typename T, T... Ints,
size_t SeqSize>
3117 struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3119 using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3124 template <
typename T,
size_t N>
3128 typename Extend <
typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3131 template <
typename T>
3134 using type = integer_sequence<T>;
3146 template <
typename T, T N>
3147 using make_integer_sequence =
typename utility_internal::Gen<T, N>::type;
3155 using make_index_sequence = make_integer_sequence<size_t, N>;
3162 template <
typename... Ts>
3163 using index_sequence_for = make_index_sequence<
sizeof...(Ts)>;
3170 template<
unsigned N>
struct priority_tag : priority_tag < N - 1 > {};
3171 template<>
struct priority_tag<0> {};
3174 template<
typename T>
3177 static constexpr T value{};
3180 template<
typename T>
3181 constexpr T static_const<T>::value;
3194 template <
class T>
struct identity_tag {};
3202 #include <type_traits>
3218 template<
typename ...Ts>
struct make_void
3222 template<
typename ...Ts>
using void_t =
typename make_void<Ts...>::type;
3233 template<
typename It,
typename =
void>
3234 struct iterator_types {};
3236 template<
typename It>
3237 struct iterator_types <
3239 void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3240 typename It::reference, typename It::iterator_category >>
3242 using difference_type =
typename It::difference_type;
3243 using value_type =
typename It::value_type;
3244 using pointer =
typename It::pointer;
3245 using reference =
typename It::reference;
3246 using iterator_category =
typename It::iterator_category;
3251 template<
typename T,
typename =
void>
3252 struct iterator_traits
3256 template<
typename T>
3257 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3262 template<
typename T>
3263 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3265 using iterator_category = std::random_access_iterator_tag;
3266 using value_type = T;
3267 using difference_type = ptrdiff_t;
3269 using reference = T&;
3281 #include <type_traits>
3293 nonesuch() =
delete;
3294 ~nonesuch() =
delete;
3295 nonesuch(nonesuch
const&) =
delete;
3296 nonesuch(nonesuch
const&&) =
delete;
3297 void operator=(nonesuch
const&) =
delete;
3298 void operator=(nonesuch&&) =
delete;
3301 template<
class Default,
3303 template<
class...>
class Op,
3307 using value_t = std::false_type;
3308 using type = Default;
3311 template<
class Default,
template<
class...>
class Op,
class... Args>
3312 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
3314 using value_t = std::true_type;
3315 using type = Op<Args...>;
3318 template<
template<
class...>
class Op,
class... Args>
3319 using is_detected =
typename detector<nonesuch, void, Op, Args...>::value_t;
3321 template<
template<
class...>
class Op,
class... Args>
3322 struct is_detected_lazy : is_detected<Op, Args...> { };
3324 template<
template<
class...>
class Op,
class... Args>
3325 using detected_t =
typename detector<nonesuch, void, Op, Args...>::type;
3327 template<
class Default,
template<
class...>
class Op,
class... Args>
3328 using detected_or = detector<Default, void, Op, Args...>;
3330 template<
class Default,
template<
class...>
class Op,
class... Args>
3331 using detected_or_t =
typename detected_or<Default, Op, Args...>::type;
3333 template<
class Expected,
template<
class...>
class Op,
class... Args>
3334 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
3336 template<
class To,
template<
class...>
class Op,
class... Args>
3337 using is_detected_convertible =
3338 std::is_convertible<detected_t<Op, Args...>, To>;
3343 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3344 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3366 template<
typename T =
void,
typename SFINAE =
void>
3367 struct adl_serializer;
3369 template<
template<
typename U,
typename V,
typename... Args>
class ObjectType =
3371 template<
typename U,
typename... Args>
class ArrayType = std::vector,
3372 class StringType = std::string,
class BooleanType = bool,
3373 class NumberIntegerType = std::int64_t,
3374 class NumberUnsignedType = std::uint64_t,
3375 class NumberFloatType = double,
3376 template<
typename U>
class AllocatorType = std::allocator,
3377 template<
typename T,
typename SFINAE =
void>
class JSONSerializer =
3379 class BinaryType = std::vector<std::uint8_t>>
3393 template<
typename BasicJsonType>
3406 template<
class Key,
class T,
class IgnoredLess,
class Allocator>
3448 template<
typename>
struct is_basic_json : std::false_type {};
3450 NLOHMANN_BASIC_JSON_TPL_DECLARATION
3451 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3461 struct is_json_ref : std::false_type {};
3463 template<
typename T>
3464 struct is_json_ref<json_ref<T>> : std::true_type {};
3470 template<
typename T>
3471 using mapped_type_t =
typename T::mapped_type;
3473 template<
typename T>
3474 using key_type_t =
typename T::key_type;
3476 template<
typename T>
3477 using value_type_t =
typename T::value_type;
3479 template<
typename T>
3480 using difference_type_t =
typename T::difference_type;
3482 template<
typename T>
3483 using pointer_t =
typename T::pointer;
3485 template<
typename T>
3486 using reference_t =
typename T::reference;
3488 template<
typename T>
3489 using iterator_category_t =
typename T::iterator_category;
3491 template<
typename T>
3492 using iterator_t =
typename T::iterator;
3494 template<
typename T,
typename... Args>
3495 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3497 template<
typename T,
typename... Args>
3498 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3500 template<
typename T,
typename U>
3501 using get_template_function = decltype(std::declval<T>().
template get<U>());
3504 template<
typename BasicJsonType,
typename T,
typename =
void>
3505 struct has_from_json : std::false_type {};
3511 template <
typename BasicJsonType,
typename T>
3514 static constexpr
bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3517 template<
typename BasicJsonType,
typename T>
3518 struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3520 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3522 static constexpr
bool value =
3523 is_detected_exact<void, from_json_function, serializer,
3524 const BasicJsonType&, T&>::value;
3529 template<
typename BasicJsonType,
typename T,
typename =
void>
3530 struct has_non_default_from_json : std::false_type {};
3532 template<
typename BasicJsonType,
typename T>
3533 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3535 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3537 static constexpr
bool value =
3538 is_detected_exact<T, from_json_function, serializer,
3539 const BasicJsonType&>::value;
3544 template<
typename BasicJsonType,
typename T,
typename =
void>
3545 struct has_to_json : std::false_type {};
3547 template<
typename BasicJsonType,
typename T>
3548 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3550 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3552 static constexpr
bool value =
3553 is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3563 template<
class...>
struct conjunction : std::true_type { };
3564 template<
class B1>
struct conjunction<B1> : B1 { };
3565 template<
class B1,
class... Bn>
3566 struct conjunction<B1, Bn...>
3567 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3570 template<
class B>
struct negation : std::integral_constant < bool, !B::value > { };
3575 template <
typename T>
3576 struct is_default_constructible : std::is_default_constructible<T> {};
3578 template <
typename T1,
typename T2>
3579 struct is_default_constructible<std::pair<T1, T2>>
3580 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3582 template <
typename T1,
typename T2>
3583 struct is_default_constructible<const std::pair<T1, T2>>
3584 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3586 template <
typename... Ts>
3587 struct is_default_constructible<std::tuple<Ts...>>
3588 : conjunction<is_default_constructible<Ts>...> {};
3590 template <
typename... Ts>
3591 struct is_default_constructible<const std::tuple<Ts...>>
3592 : conjunction<is_default_constructible<Ts>...> {};
3595 template <
typename T,
typename... Args>
3596 struct is_constructible : std::is_constructible<T, Args...> {};
3598 template <
typename T1,
typename T2>
3599 struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3601 template <
typename T1,
typename T2>
3602 struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3604 template <
typename... Ts>
3605 struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3607 template <
typename... Ts>
3608 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3611 template<
typename T,
typename =
void>
3612 struct is_iterator_traits : std::false_type {};
3614 template<
typename T>
3615 struct is_iterator_traits<iterator_traits<T>>
3618 using traits = iterator_traits<T>;
3621 static constexpr
auto value =
3622 is_detected<value_type_t, traits>::value &&
3623 is_detected<difference_type_t, traits>::value &&
3624 is_detected<pointer_t, traits>::value &&
3625 is_detected<iterator_category_t, traits>::value &&
3626 is_detected<reference_t, traits>::value;
3633 template<
typename T,
typename =
void>
3634 struct is_complete_type : std::false_type {};
3636 template<
typename T>
3637 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3639 template<
typename BasicJsonType,
typename CompatibleObjectType,
3641 struct is_compatible_object_type_impl : std::false_type {};
3643 template<
typename BasicJsonType,
typename CompatibleObjectType>
3644 struct is_compatible_object_type_impl <
3645 BasicJsonType, CompatibleObjectType,
3646 enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3647 is_detected<key_type_t, CompatibleObjectType>::value >>
3649 using object_t =
typename BasicJsonType::object_t;
3652 static constexpr
bool value =
3653 is_constructible<
typename object_t::key_type,
3654 typename CompatibleObjectType::key_type>::value &&
3655 is_constructible<
typename object_t::mapped_type,
3656 typename CompatibleObjectType::mapped_type>::value;
3659 template<
typename BasicJsonType,
typename CompatibleObjectType>
3660 struct is_compatible_object_type
3661 : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3663 template<
typename BasicJsonType,
typename ConstructibleObjectType,
3665 struct is_constructible_object_type_impl : std::false_type {};
3667 template<
typename BasicJsonType,
typename ConstructibleObjectType>
3668 struct is_constructible_object_type_impl <
3669 BasicJsonType, ConstructibleObjectType,
3670 enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3671 is_detected<key_type_t, ConstructibleObjectType>::value >>
3673 using object_t =
typename BasicJsonType::object_t;
3675 static constexpr
bool value =
3676 (is_default_constructible<ConstructibleObjectType>::value &&
3677 (std::is_move_assignable<ConstructibleObjectType>::value ||
3678 std::is_copy_assignable<ConstructibleObjectType>::value) &&
3679 (is_constructible<
typename ConstructibleObjectType::key_type,
3680 typename object_t::key_type>::value &&
3682 typename object_t::mapped_type,
3683 typename ConstructibleObjectType::mapped_type >::value)) ||
3684 (has_from_json<BasicJsonType,
3685 typename ConstructibleObjectType::mapped_type>::value ||
3686 has_non_default_from_json <
3688 typename ConstructibleObjectType::mapped_type >::value);
3691 template<
typename BasicJsonType,
typename ConstructibleObjectType>
3692 struct is_constructible_object_type
3693 : is_constructible_object_type_impl<BasicJsonType,
3694 ConstructibleObjectType> {};
3696 template<
typename BasicJsonType,
typename CompatibleStringType,
3698 struct is_compatible_string_type_impl : std::false_type {};
3700 template<
typename BasicJsonType,
typename CompatibleStringType>
3701 struct is_compatible_string_type_impl <
3702 BasicJsonType, CompatibleStringType,
3703 enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3704 value_type_t, CompatibleStringType>::value >>
3706 static constexpr
auto value =
3707 is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3710 template<
typename BasicJsonType,
typename ConstructibleStringType>
3711 struct is_compatible_string_type
3712 : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3714 template<
typename BasicJsonType,
typename ConstructibleStringType,
3716 struct is_constructible_string_type_impl : std::false_type {};
3718 template<
typename BasicJsonType,
typename ConstructibleStringType>
3719 struct is_constructible_string_type_impl <
3720 BasicJsonType, ConstructibleStringType,
3721 enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3722 value_type_t, ConstructibleStringType>::value >>
3724 static constexpr
auto value =
3725 is_constructible<ConstructibleStringType,
3726 typename BasicJsonType::string_t>::value;
3729 template<
typename BasicJsonType,
typename ConstructibleStringType>
3730 struct is_constructible_string_type
3731 : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3733 template<
typename BasicJsonType,
typename CompatibleArrayType,
typename =
void>
3734 struct is_compatible_array_type_impl : std::false_type {};
3736 template<
typename BasicJsonType,
typename CompatibleArrayType>
3737 struct is_compatible_array_type_impl <
3738 BasicJsonType, CompatibleArrayType,
3739 enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
3740 is_detected<iterator_t, CompatibleArrayType>::value&&
3744 !is_iterator_traits <
3745 iterator_traits<CompatibleArrayType >>::value >>
3747 static constexpr
bool value =
3748 is_constructible<BasicJsonType,
3749 typename CompatibleArrayType::value_type>::value;
3752 template<
typename BasicJsonType,
typename CompatibleArrayType>
3753 struct is_compatible_array_type
3754 : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3756 template<
typename BasicJsonType,
typename ConstructibleArrayType,
typename =
void>
3757 struct is_constructible_array_type_impl : std::false_type {};
3759 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3760 struct is_constructible_array_type_impl <
3761 BasicJsonType, ConstructibleArrayType,
3762 enable_if_t<std::is_same<ConstructibleArrayType,
3763 typename BasicJsonType::value_type>::value >>
3764 : std::true_type {};
3766 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3767 struct is_constructible_array_type_impl <
3768 BasicJsonType, ConstructibleArrayType,
3769 enable_if_t < !std::is_same<ConstructibleArrayType,
3770 typename BasicJsonType::value_type>::value&&
3771 is_default_constructible<ConstructibleArrayType>::value&&
3772 (std::is_move_assignable<ConstructibleArrayType>::value ||
3773 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3774 is_detected<value_type_t, ConstructibleArrayType>::value&&
3775 is_detected<iterator_t, ConstructibleArrayType>::value&&
3777 detected_t<value_type_t, ConstructibleArrayType >>::value >>
3779 static constexpr
bool value =
3785 !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
3787 (std::is_same<
typename ConstructibleArrayType::value_type,
3788 typename BasicJsonType::array_t::value_type>::value ||
3789 has_from_json<BasicJsonType,
3790 typename ConstructibleArrayType::value_type>::value ||
3791 has_non_default_from_json <
3792 BasicJsonType,
typename ConstructibleArrayType::value_type >::value);
3795 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3796 struct is_constructible_array_type
3797 : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3799 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType,
3801 struct is_compatible_integer_type_impl : std::false_type {};
3803 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3804 struct is_compatible_integer_type_impl <
3805 RealIntegerType, CompatibleNumberIntegerType,
3806 enable_if_t < std::is_integral<RealIntegerType>::value&&
3807 std::is_integral<CompatibleNumberIntegerType>::value&&
3808 !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3811 using RealLimits = std::numeric_limits<RealIntegerType>;
3812 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3814 static constexpr
auto value =
3815 is_constructible<RealIntegerType,
3816 CompatibleNumberIntegerType>::value &&
3817 CompatibleLimits::is_integer &&
3818 RealLimits::is_signed == CompatibleLimits::is_signed;
3821 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3822 struct is_compatible_integer_type
3823 : is_compatible_integer_type_impl<RealIntegerType,
3824 CompatibleNumberIntegerType> {};
3826 template<
typename BasicJsonType,
typename CompatibleType,
typename =
void>
3827 struct is_compatible_type_impl: std::false_type {};
3829 template<
typename BasicJsonType,
typename CompatibleType>
3830 struct is_compatible_type_impl <
3831 BasicJsonType, CompatibleType,
3832 enable_if_t<is_complete_type<CompatibleType>::value >>
3834 static constexpr
bool value =
3835 has_to_json<BasicJsonType, CompatibleType>::value;
3838 template<
typename BasicJsonType,
typename CompatibleType>
3839 struct is_compatible_type
3840 : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3842 template<
typename T1,
typename T2>
3843 struct is_constructible_tuple : std::false_type {};
3845 template<
typename T1,
typename... Args>
3846 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3849 template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value,
int > = 0 >
3850 T conditional_static_cast(U value)
3852 return static_cast<T
>(value);
3855 template<typename T, typename U, enable_if_t<std::is_same<T, U>::value,
int> = 0>
3856 T conditional_static_cast(U value)
3871 template<
typename BasicJsonType>
3872 void from_json(
const BasicJsonType& j,
typename std::nullptr_t& n)
3874 if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3876 JSON_THROW(type_error::create(302,
"type must be null, but is " + std::string(j.type_name()), j));
3882 template <
typename BasicJsonType,
typename ArithmeticType,
3883 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3884 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3886 void get_arithmetic_value(
const BasicJsonType& j, ArithmeticType& val)
3888 switch (
static_cast<value_t
>(j))
3890 case value_t::number_unsigned:
3892 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3895 case value_t::number_integer:
3897 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3900 case value_t::number_float:
3902 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3907 case value_t::object:
3908 case value_t::array:
3909 case value_t::string:
3910 case value_t::boolean:
3911 case value_t::binary:
3912 case value_t::discarded:
3914 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name()), j));
3918 template<
typename BasicJsonType>
3919 void from_json(
const BasicJsonType& j,
typename BasicJsonType::boolean_t& b)
3921 if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3923 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(j.type_name()), j));
3925 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3928 template<
typename BasicJsonType>
3929 void from_json(
const BasicJsonType& j,
typename BasicJsonType::string_t& s)
3931 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3933 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
3935 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3939 typename BasicJsonType,
typename ConstructibleStringType,
3941 is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3942 !std::is_same<
typename BasicJsonType::string_t,
3943 ConstructibleStringType>::value,
3945 void from_json(
const BasicJsonType& j, ConstructibleStringType& s)
3947 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3949 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
3952 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3955 template<
typename BasicJsonType>
3956 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_float_t& val)
3958 get_arithmetic_value(j, val);
3961 template<
typename BasicJsonType>
3962 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_unsigned_t& val)
3964 get_arithmetic_value(j, val);
3967 template<
typename BasicJsonType>
3968 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_integer_t& val)
3970 get_arithmetic_value(j, val);
3973 template<
typename BasicJsonType,
typename EnumType,
3974 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
3975 void from_json(
const BasicJsonType& j, EnumType& e)
3977 typename std::underlying_type<EnumType>::type val;
3978 get_arithmetic_value(j, val);
3979 e =
static_cast<EnumType
>(val);
3983 template<
typename BasicJsonType,
typename T,
typename Allocator,
3984 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
3985 void from_json(
const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3987 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3989 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
3992 std::transform(j.rbegin(), j.rend(),
3993 std::front_inserter(l), [](
const BasicJsonType & i)
3995 return i.template get<T>();
4000 template<
typename BasicJsonType,
typename T,
4001 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
4002 void from_json(
const BasicJsonType& j, std::valarray<T>& l)
4004 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4006 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4009 std::transform(j.begin(), j.end(), std::begin(l),
4010 [](
const BasicJsonType & elem)
4012 return elem.template get<T>();
4016 template<
typename BasicJsonType,
typename T, std::
size_t N>
4017 auto from_json(
const BasicJsonType& j, T (&arr)[N])
4018 -> decltype(j.template get<T>(),
void())
4020 for (std::size_t i = 0; i < N; ++i)
4022 arr[i] = j.at(i).template get<T>();
4026 template<
typename BasicJsonType>
4027 void from_json_array_impl(
const BasicJsonType& j,
typename BasicJsonType::array_t& arr, priority_tag<3> )
4029 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
4032 template<
typename BasicJsonType,
typename T, std::
size_t N>
4033 auto from_json_array_impl(
const BasicJsonType& j, std::array<T, N>& arr,
4035 -> decltype(j.template get<T>(),
void())
4037 for (std::size_t i = 0; i < N; ++i)
4039 arr[i] = j.at(i).template get<T>();
4043 template<
typename BasicJsonType,
typename ConstructibleArrayType,
4045 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4047 auto from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> )
4049 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4050 j.template get<typename ConstructibleArrayType::value_type>(),
4055 ConstructibleArrayType ret;
4056 ret.reserve(j.size());
4057 std::transform(j.begin(), j.end(),
4058 std::inserter(ret, end(ret)), [](
const BasicJsonType & i)
4062 return i.template get<typename ConstructibleArrayType::value_type>();
4064 arr = std::move(ret);
4067 template<
typename BasicJsonType,
typename ConstructibleArrayType,
4069 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4071 void from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr,
4076 ConstructibleArrayType ret;
4078 j.begin(), j.end(), std::inserter(ret, end(ret)),
4079 [](
const BasicJsonType & i)
4083 return i.template get<typename ConstructibleArrayType::value_type>();
4085 arr = std::move(ret);
4088 template <
typename BasicJsonType,
typename ConstructibleArrayType,
4090 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
4091 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
4092 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4093 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4094 !is_basic_json<ConstructibleArrayType>::value,
4096 auto from_json(
const BasicJsonType& j, ConstructibleArrayType& arr)
4097 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
4098 j.template get<typename ConstructibleArrayType::value_type>(),
4101 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4103 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4106 from_json_array_impl(j, arr, priority_tag<3> {});
4109 template <
typename BasicJsonType,
typename T, std::size_t... Idx >
4110 std::array<T,
sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4111 identity_tag<std::array<T,
sizeof...(Idx)>> , index_sequence<Idx...> )
4113 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4116 template <
typename BasicJsonType,
typename T, std::
size_t N >
4117 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4118 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4120 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4122 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4125 return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4128 template<
typename BasicJsonType>
4129 void from_json(
const BasicJsonType& j,
typename BasicJsonType::binary_t& bin)
4131 if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
4133 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(j.type_name()), j));
4136 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4139 template<
typename BasicJsonType,
typename ConstructibleObjectType,
4140 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value,
int> = 0>
4141 void from_json(
const BasicJsonType& j, ConstructibleObjectType& obj)
4143 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
4145 JSON_THROW(type_error::create(302,
"type must be object, but is " + std::string(j.type_name()), j));
4148 ConstructibleObjectType ret;
4149 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4150 using value_type =
typename ConstructibleObjectType::value_type;
4152 inner_object->begin(), inner_object->end(),
4153 std::inserter(ret, ret.begin()),
4154 [](
typename BasicJsonType::object_t::value_type
const & p)
4156 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4158 obj = std::move(ret);
4165 template <
typename BasicJsonType,
typename ArithmeticType,
4167 std::is_arithmetic<ArithmeticType>::value&&
4168 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4169 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4170 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4171 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4173 void from_json(
const BasicJsonType& j, ArithmeticType& val)
4175 switch (
static_cast<value_t
>(j))
4177 case value_t::number_unsigned:
4179 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4182 case value_t::number_integer:
4184 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4187 case value_t::number_float:
4189 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4192 case value_t::boolean:
4194 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4199 case value_t::object:
4200 case value_t::array:
4201 case value_t::string:
4202 case value_t::binary:
4203 case value_t::discarded:
4205 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name()), j));
4209 template<
typename BasicJsonType,
typename... Args, std::size_t... Idx>
4210 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> )
4212 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).
template get<Args>()...);
4215 template <
typename BasicJsonType,
class A1,
class A2 >
4216 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> , priority_tag<0> )
4218 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4219 std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4222 template<
typename BasicJsonType,
typename A1,
typename A2>
4223 void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> )
4225 p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
4228 template<
typename BasicJsonType,
typename... Args>
4229 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> , priority_tag<2> )
4231 return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4234 template<
typename BasicJsonType,
typename... Args>
4235 void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> )
4237 t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4240 template<
typename BasicJsonType,
typename TupleRelated>
4241 auto from_json(BasicJsonType&& j, TupleRelated&& t)
4242 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
4244 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4246 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4249 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4252 template <
typename BasicJsonType,
typename Key,
typename Value,
typename Compare,
typename Allocator,
4253 typename = enable_if_t < !std::is_constructible <
4254 typename BasicJsonType::string_t, Key >::value >>
4255 void from_json(
const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4257 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4259 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4262 for (
const auto& p : j)
4264 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4266 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name()), j));
4268 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4272 template <
typename BasicJsonType,
typename Key,
typename Value,
typename Hash,
typename KeyEqual,
typename Allocator,
4273 typename = enable_if_t < !std::is_constructible <
4274 typename BasicJsonType::string_t, Key >::value >>
4275 void from_json(
const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
4277 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4279 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4282 for (
const auto& p : j)
4284 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4286 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name()), j));
4288 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4294 template<
typename BasicJsonType,
typename T>
4295 auto operator()(
const BasicJsonType& j, T&& val)
const
4296 noexcept(noexcept(
from_json(j, std::forward<T>(val))))
4297 -> decltype(
from_json(j, std::forward<T>(val)))
4299 return from_json(j, std::forward<T>(val));
4309 constexpr
const auto&
from_json = detail::static_const<detail::from_json_fn>::value;
4316 #include <algorithm>
4320 #include <type_traits>
4343 template<
typename string_type>
4344 void int_to_string( string_type& target, std::size_t value )
4347 using std::to_string;
4350 template<
typename IteratorType>
class iteration_proxy_value
4353 using difference_type = std::ptrdiff_t;
4354 using value_type = iteration_proxy_value;
4355 using pointer = value_type * ;
4356 using reference = value_type & ;
4357 using iterator_category = std::input_iterator_tag;
4358 using string_type =
typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
4362 IteratorType anchor;
4364 std::size_t array_index = 0;
4366 mutable std::size_t array_index_last = 0;
4368 mutable string_type array_index_str =
"0";
4370 const string_type empty_str{};
4373 explicit iteration_proxy_value(IteratorType it) noexcept
4374 : anchor(std::move(it))
4378 iteration_proxy_value& operator*()
4384 iteration_proxy_value& operator++()
4393 bool operator==(
const iteration_proxy_value& o)
const
4395 return anchor == o.anchor;
4399 bool operator!=(
const iteration_proxy_value& o)
const
4401 return anchor != o.anchor;
4405 const string_type& key()
const
4407 JSON_ASSERT(anchor.m_object !=
nullptr);
4409 switch (anchor.m_object->type())
4412 case value_t::array:
4414 if (array_index != array_index_last)
4416 int_to_string( array_index_str, array_index );
4417 array_index_last = array_index;
4419 return array_index_str;
4423 case value_t::object:
4424 return anchor.key();
4428 case value_t::string:
4429 case value_t::boolean:
4430 case value_t::number_integer:
4431 case value_t::number_unsigned:
4432 case value_t::number_float:
4433 case value_t::binary:
4434 case value_t::discarded:
4441 typename IteratorType::reference value()
const
4443 return anchor.value();
4448 template<
typename IteratorType>
class iteration_proxy
4452 typename IteratorType::reference container;
4456 explicit iteration_proxy(
typename IteratorType::reference cont) noexcept
4457 : container(cont) {}
4460 iteration_proxy_value<IteratorType> begin() noexcept
4462 return iteration_proxy_value<IteratorType>(container.begin());
4466 iteration_proxy_value<IteratorType> end() noexcept
4468 return iteration_proxy_value<IteratorType>(container.end());
4474 template<std::
size_t N,
typename IteratorType, enable_if_t<N == 0,
int> = 0>
4475 auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
4482 template<std::
size_t N,
typename IteratorType, enable_if_t<N == 1,
int> = 0>
4483 auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
4496 #if defined(__clang__)
4498 #pragma clang diagnostic push
4499 #pragma clang diagnostic ignored "-Wmismatched-tags"
4501 template<
typename IteratorType>
4502 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
4503 :
public std::integral_constant<std::size_t, 2> {};
4505 template<std::
size_t N,
typename IteratorType>
4506 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
4509 using type = decltype(
4510 get<N>(std::declval <
4511 ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
4513 #if defined(__clang__)
4514 #pragma clang diagnostic pop
4540 template<value_t>
struct external_constructor;
4543 struct external_constructor<value_t::boolean>
4545 template<
typename BasicJsonType>
4546 static void construct(BasicJsonType& j,
typename BasicJsonType::boolean_t b) noexcept
4548 j.m_value.destroy(j.m_type);
4549 j.m_type = value_t::boolean;
4551 j.assert_invariant();
4556 struct external_constructor<value_t::string>
4558 template<
typename BasicJsonType>
4559 static void construct(BasicJsonType& j,
const typename BasicJsonType::string_t& s)
4561 j.m_value.destroy(j.m_type);
4562 j.m_type = value_t::string;
4564 j.assert_invariant();
4567 template<
typename BasicJsonType>
4568 static void construct(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4570 j.m_value.destroy(j.m_type);
4571 j.m_type = value_t::string;
4572 j.m_value = std::move(s);
4573 j.assert_invariant();
4576 template <
typename BasicJsonType,
typename CompatibleStringType,
4577 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4579 static void construct(BasicJsonType& j,
const CompatibleStringType& str)
4581 j.m_value.destroy(j.m_type);
4582 j.m_type = value_t::string;
4583 j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4584 j.assert_invariant();
4589 struct external_constructor<value_t::binary>
4591 template<
typename BasicJsonType>
4592 static void construct(BasicJsonType& j,
const typename BasicJsonType::binary_t& b)
4594 j.m_value.destroy(j.m_type);
4595 j.m_type = value_t::binary;
4596 j.m_value =
typename BasicJsonType::binary_t(b);
4597 j.assert_invariant();
4600 template<
typename BasicJsonType>
4601 static void construct(BasicJsonType& j,
typename BasicJsonType::binary_t&& b)
4603 j.m_value.destroy(j.m_type);
4604 j.m_type = value_t::binary;
4605 j.m_value =
typename BasicJsonType::binary_t(std::move(b));;
4606 j.assert_invariant();
4611 struct external_constructor<value_t::number_float>
4613 template<
typename BasicJsonType>
4614 static void construct(BasicJsonType& j,
typename BasicJsonType::number_float_t val) noexcept
4616 j.m_value.destroy(j.m_type);
4617 j.m_type = value_t::number_float;
4619 j.assert_invariant();
4624 struct external_constructor<value_t::number_unsigned>
4626 template<
typename BasicJsonType>
4627 static void construct(BasicJsonType& j,
typename BasicJsonType::number_unsigned_t val) noexcept
4629 j.m_value.destroy(j.m_type);
4630 j.m_type = value_t::number_unsigned;
4632 j.assert_invariant();
4637 struct external_constructor<value_t::number_integer>
4639 template<
typename BasicJsonType>
4640 static void construct(BasicJsonType& j,
typename BasicJsonType::number_integer_t val) noexcept
4642 j.m_value.destroy(j.m_type);
4643 j.m_type = value_t::number_integer;
4645 j.assert_invariant();
4650 struct external_constructor<value_t::array>
4652 template<
typename BasicJsonType>
4653 static void construct(BasicJsonType& j,
const typename BasicJsonType::array_t& arr)
4655 j.m_value.destroy(j.m_type);
4656 j.m_type = value_t::array;
4659 j.assert_invariant();
4662 template<
typename BasicJsonType>
4663 static void construct(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4665 j.m_value.destroy(j.m_type);
4666 j.m_type = value_t::array;
4667 j.m_value = std::move(arr);
4669 j.assert_invariant();
4672 template <
typename BasicJsonType,
typename CompatibleArrayType,
4673 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4675 static void construct(BasicJsonType& j,
const CompatibleArrayType& arr)
4680 j.m_value.destroy(j.m_type);
4681 j.m_type = value_t::array;
4682 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4684 j.assert_invariant();
4687 template<
typename BasicJsonType>
4688 static void construct(BasicJsonType& j,
const std::vector<bool>& arr)
4690 j.m_value.destroy(j.m_type);
4691 j.m_type = value_t::array;
4692 j.m_value = value_t::array;
4693 j.m_value.array->reserve(arr.size());
4694 for (
const bool x : arr)
4696 j.m_value.array->push_back(x);
4697 j.set_parent(j.m_value.array->back());
4699 j.assert_invariant();
4702 template<
typename BasicJsonType,
typename T,
4703 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4704 static void construct(BasicJsonType& j,
const std::valarray<T>& arr)
4706 j.m_value.destroy(j.m_type);
4707 j.m_type = value_t::array;
4708 j.m_value = value_t::array;
4709 j.m_value.array->resize(arr.size());
4712 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4715 j.assert_invariant();
4720 struct external_constructor<value_t::object>
4722 template<
typename BasicJsonType>
4723 static void construct(BasicJsonType& j,
const typename BasicJsonType::object_t& obj)
4725 j.m_value.destroy(j.m_type);
4726 j.m_type = value_t::object;
4729 j.assert_invariant();
4732 template<
typename BasicJsonType>
4733 static void construct(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4735 j.m_value.destroy(j.m_type);
4736 j.m_type = value_t::object;
4737 j.m_value = std::move(obj);
4739 j.assert_invariant();
4742 template <
typename BasicJsonType,
typename CompatibleObjectType,
4743 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value,
int > = 0 >
4744 static void construct(BasicJsonType& j,
const CompatibleObjectType& obj)
4749 j.m_value.destroy(j.m_type);
4750 j.m_type = value_t::object;
4751 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4753 j.assert_invariant();
4761 template<
typename BasicJsonType,
typename T,
4762 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value,
int> = 0>
4763 void to_json(BasicJsonType& j, T b) noexcept
4765 external_constructor<value_t::boolean>::construct(j, b);
4768 template<
typename BasicJsonType,
typename CompatibleString,
4769 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value,
int> = 0>
4770 void to_json(BasicJsonType& j,
const CompatibleString& s)
4772 external_constructor<value_t::string>::construct(j, s);
4775 template<
typename BasicJsonType>
4776 void to_json(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4778 external_constructor<value_t::string>::construct(j, std::move(s));
4781 template<
typename BasicJsonType,
typename FloatType,
4782 enable_if_t<std::is_floating_point<FloatType>::value,
int> = 0>
4783 void to_json(BasicJsonType& j, FloatType val) noexcept
4785 external_constructor<value_t::number_float>::construct(j,
static_cast<typename BasicJsonType::number_float_t
>(val));
4788 template<
typename BasicJsonType,
typename CompatibleNumberUnsignedType,
4789 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value,
int> = 0>
4790 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4792 external_constructor<value_t::number_unsigned>::construct(j,
static_cast<typename BasicJsonType::number_unsigned_t
>(val));
4795 template<
typename BasicJsonType,
typename CompatibleNumberIntegerType,
4796 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value,
int> = 0>
4797 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4799 external_constructor<value_t::number_integer>::construct(j,
static_cast<typename BasicJsonType::number_integer_t
>(val));
4802 template<
typename BasicJsonType,
typename EnumType,
4803 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
4804 void to_json(BasicJsonType& j, EnumType e) noexcept
4806 using underlying_type =
typename std::underlying_type<EnumType>::type;
4807 external_constructor<value_t::number_integer>::construct(j,
static_cast<underlying_type
>(e));
4810 template<
typename BasicJsonType>
4811 void to_json(BasicJsonType& j,
const std::vector<bool>& e)
4813 external_constructor<value_t::array>::construct(j, e);
4816 template <
typename BasicJsonType,
typename CompatibleArrayType,
4817 enable_if_t < is_compatible_array_type<BasicJsonType,
4818 CompatibleArrayType>::value&&
4819 !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4820 !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4821 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4822 !is_basic_json<CompatibleArrayType>::value,
4824 void to_json(BasicJsonType& j,
const CompatibleArrayType& arr)
4826 external_constructor<value_t::array>::construct(j, arr);
4829 template<
typename BasicJsonType>
4830 void to_json(BasicJsonType& j,
const typename BasicJsonType::binary_t& bin)
4832 external_constructor<value_t::binary>::construct(j, bin);
4835 template<
typename BasicJsonType,
typename T,
4836 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4837 void to_json(BasicJsonType& j,
const std::valarray<T>& arr)
4839 external_constructor<value_t::array>::construct(j, std::move(arr));
4842 template<
typename BasicJsonType>
4843 void to_json(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4845 external_constructor<value_t::array>::construct(j, std::move(arr));
4848 template <
typename BasicJsonType,
typename CompatibleObjectType,
4849 enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value,
int > = 0 >
4850 void to_json(BasicJsonType& j,
const CompatibleObjectType& obj)
4852 external_constructor<value_t::object>::construct(j, obj);
4855 template<
typename BasicJsonType>
4856 void to_json(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4858 external_constructor<value_t::object>::construct(j, std::move(obj));
4862 typename BasicJsonType,
typename T, std::size_t N,
4863 enable_if_t < !std::is_constructible<
typename BasicJsonType::string_t,
4864 const T(&)[N]>::value,
4866 void to_json(BasicJsonType& j,
const T(&arr)[N])
4868 external_constructor<value_t::array>::construct(j, arr);
4871 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value,
int > = 0 >
4872 void to_json(BasicJsonType& j,
const std::pair<T1, T2>& p)
4874 j = { p.first, p.second };
4878 template<
typename BasicJsonType,
typename T,
4879 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value,
int> = 0>
4880 void to_json(BasicJsonType& j,
const T& b)
4882 j = { {b.key(), b.value()} };
4885 template<
typename BasicJsonType,
typename Tuple, std::size_t... Idx>
4886 void to_json_tuple_impl(BasicJsonType& j,
const Tuple& t, index_sequence<Idx...> )
4888 j = { std::get<Idx>(t)... };
4891 template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value,
int > = 0>
4892 void to_json(BasicJsonType& j,
const T& t)
4894 to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4899 template<
typename BasicJsonType,
typename T>
4900 auto operator()(BasicJsonType& j, T&& val)
const noexcept(noexcept(
to_json(j, std::forward<T>(val))))
4901 -> decltype(
to_json(j, std::forward<T>(val)),
void())
4903 return to_json(j, std::forward<T>(val));
4913 constexpr
const auto&
to_json = detail::static_const<detail::to_json_fn>::value;
4925 template<
typename ValueType,
typename>
4939 template<
typename BasicJsonType,
typename TargetType = ValueType>
4940 static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
4941 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4942 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val),
void())
4944 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4959 template<
typename BasicJsonType,
typename TargetType = ValueType>
4961 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
4962 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
4964 return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
4976 template<
typename BasicJsonType,
typename TargetType = ValueType>
4977 static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
4978 noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
4979 -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)),
void())
4981 ::nlohmann::to_json(j, std::forward<TargetType>(val));
5009 template<
typename BinaryType>
5032 , m_subtype(subtype_)
5033 , m_has_subtype(true)
5038 , m_subtype(subtype_)
5039 , m_has_subtype(true)
5044 return std::tie(
static_cast<const BinaryType&
>(*
this), m_subtype, m_has_subtype) ==
5045 std::tie(
static_cast<const BinaryType&
>(rhs), rhs.m_subtype, rhs.m_has_subtype);
5050 return !(rhs == *
this);
5073 m_subtype = subtype_;
5074 m_has_subtype =
true;
5122 return m_has_subtype;
5147 m_has_subtype =
false;
5152 bool m_has_subtype =
false;
5168 #include <functional>
5181 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
5183 seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
5198 template<
typename BasicJsonType>
5199 std::size_t hash(
const BasicJsonType& j)
5201 using string_t =
typename BasicJsonType::string_t;
5202 using number_integer_t =
typename BasicJsonType::number_integer_t;
5203 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5204 using number_float_t =
typename BasicJsonType::number_float_t;
5206 const auto type =
static_cast<std::size_t
>(j.type());
5209 case BasicJsonType::value_t::null:
5210 case BasicJsonType::value_t::discarded:
5212 return combine(type, 0);
5215 case BasicJsonType::value_t::object:
5217 auto seed = combine(type, j.size());
5218 for (
const auto& element : j.items())
5220 const auto h = std::hash<string_t> {}(element.key());
5221 seed = combine(seed, h);
5222 seed = combine(seed, hash(element.value()));
5227 case BasicJsonType::value_t::array:
5229 auto seed = combine(type, j.size());
5230 for (
const auto& element : j)
5232 seed = combine(seed, hash(element));
5237 case BasicJsonType::value_t::string:
5239 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5240 return combine(type, h);
5243 case BasicJsonType::value_t::boolean:
5245 const auto h = std::hash<bool> {}(j.template get<bool>());
5246 return combine(type, h);
5249 case BasicJsonType::value_t::number_integer:
5251 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
5252 return combine(type, h);
5255 case BasicJsonType::value_t::number_unsigned:
5257 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
5258 return combine(type, h);
5261 case BasicJsonType::value_t::number_float:
5263 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
5264 return combine(type, h);
5267 case BasicJsonType::value_t::binary:
5269 auto seed = combine(type, j.get_binary().size());
5270 const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
5271 seed = combine(seed, h);
5272 seed = combine(seed,
static_cast<std::size_t
>(j.get_binary().subtype()));
5273 for (
const auto byte : j.get_binary())
5275 seed = combine(seed, std::hash<std::uint8_t> {}(byte));
5292 #include <algorithm>
5317 #include <type_traits>
5335 enum class input_format_t {
json, cbor, msgpack, ubjson, bson };
5346 class file_input_adapter
5349 using char_type = char;
5351 JSON_HEDLEY_NON_NULL(2)
5352 explicit file_input_adapter(std::FILE* f) noexcept
5357 file_input_adapter(
const file_input_adapter&) =
delete;
5358 file_input_adapter(file_input_adapter&&) noexcept = default;
5359 file_input_adapter& operator=(const file_input_adapter&) = delete;
5360 file_input_adapter& operator=(file_input_adapter&&) = delete;
5361 ~file_input_adapter() = default;
5363 std::char_traits<
char>::int_type get_character() noexcept
5365 return std::fgetc(m_file);
5383 class input_stream_adapter
5386 using char_type = char;
5388 ~input_stream_adapter()
5394 is->clear(is->rdstate() & std::ios::eofbit);
5398 explicit input_stream_adapter(std::istream& i)
5399 : is(&i), sb(i.rdbuf())
5403 input_stream_adapter(
const input_stream_adapter&) =
delete;
5404 input_stream_adapter& operator=(input_stream_adapter&) =
delete;
5405 input_stream_adapter& operator=(input_stream_adapter&&) =
delete;
5407 input_stream_adapter(input_stream_adapter&& rhs) noexcept
5408 : is(rhs.is), sb(rhs.sb)
5417 std::char_traits<char>::int_type get_character()
5419 auto res = sb->sbumpc();
5421 if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
5423 is->clear(is->rdstate() | std::ios::eofbit);
5430 std::istream* is =
nullptr;
5431 std::streambuf* sb =
nullptr;
5437 template<
typename IteratorType>
5438 class iterator_input_adapter
5441 using char_type =
typename std::iterator_traits<IteratorType>::value_type;
5443 iterator_input_adapter(IteratorType first, IteratorType last)
5444 : current(std::move(first)), end(std::move(last))
5447 typename std::char_traits<char_type>::int_type get_character()
5449 if (JSON_HEDLEY_LIKELY(current != end))
5451 auto result = std::char_traits<char_type>::to_int_type(*current);
5452 std::advance(current, 1);
5456 return std::char_traits<char_type>::eof();
5460 IteratorType current;
5463 template<
typename BaseInputAdapter,
size_t T>
5464 friend struct wide_string_input_helper;
5468 return current == end;
5473 template<
typename BaseInputAdapter,
size_t T>
5474 struct wide_string_input_helper;
5476 template<
typename BaseInputAdapter>
5477 struct wide_string_input_helper<BaseInputAdapter, 4>
5480 static void fill_buffer(BaseInputAdapter& input,
5481 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5482 size_t& utf8_bytes_index,
5483 size_t& utf8_bytes_filled)
5485 utf8_bytes_index = 0;
5487 if (JSON_HEDLEY_UNLIKELY(input.empty()))
5489 utf8_bytes[0] = std::char_traits<char>::eof();
5490 utf8_bytes_filled = 1;
5495 const auto wc = input.get_character();
5500 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5501 utf8_bytes_filled = 1;
5503 else if (wc <= 0x7FF)
5505 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
5506 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5507 utf8_bytes_filled = 2;
5509 else if (wc <= 0xFFFF)
5511 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
5512 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5513 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5514 utf8_bytes_filled = 3;
5516 else if (wc <= 0x10FFFF)
5518 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | ((
static_cast<unsigned int>(wc) >> 18u) & 0x07u));
5519 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
5520 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5521 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5522 utf8_bytes_filled = 4;
5527 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5528 utf8_bytes_filled = 1;
5534 template<
typename BaseInputAdapter>
5535 struct wide_string_input_helper<BaseInputAdapter, 2>
5538 static void fill_buffer(BaseInputAdapter& input,
5539 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5540 size_t& utf8_bytes_index,
5541 size_t& utf8_bytes_filled)
5543 utf8_bytes_index = 0;
5545 if (JSON_HEDLEY_UNLIKELY(input.empty()))
5547 utf8_bytes[0] = std::char_traits<char>::eof();
5548 utf8_bytes_filled = 1;
5553 const auto wc = input.get_character();
5558 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5559 utf8_bytes_filled = 1;
5561 else if (wc <= 0x7FF)
5563 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u)));
5564 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5565 utf8_bytes_filled = 2;
5567 else if (0xD800 > wc || wc >= 0xE000)
5569 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u)));
5570 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5571 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5572 utf8_bytes_filled = 3;
5576 if (JSON_HEDLEY_UNLIKELY(!input.empty()))
5578 const auto wc2 =
static_cast<unsigned int>(input.get_character());
5579 const auto charcode = 0x10000u + (((
static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
5580 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | (charcode >> 18u));
5581 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 12u) & 0x3Fu));
5582 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 6u) & 0x3Fu));
5583 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (charcode & 0x3Fu));
5584 utf8_bytes_filled = 4;
5588 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5589 utf8_bytes_filled = 1;
5597 template<
typename BaseInputAdapter,
typename W
ideCharType>
5598 class wide_string_input_adapter
5601 using char_type = char;
5603 wide_string_input_adapter(BaseInputAdapter base)
5604 : base_adapter(base) {}
5606 typename std::char_traits<char>::int_type get_character() noexcept
5609 if (utf8_bytes_index == utf8_bytes_filled)
5611 fill_buffer<sizeof(WideCharType)>();
5613 JSON_ASSERT(utf8_bytes_filled > 0);
5614 JSON_ASSERT(utf8_bytes_index == 0);
5618 JSON_ASSERT(utf8_bytes_filled > 0);
5619 JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5620 return utf8_bytes[utf8_bytes_index++];
5624 BaseInputAdapter base_adapter;
5629 wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
5633 std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5636 std::size_t utf8_bytes_index = 0;
5638 std::size_t utf8_bytes_filled = 0;
5642 template<
typename IteratorType,
typename Enable =
void>
5643 struct iterator_input_adapter_factory
5645 using iterator_type = IteratorType;
5646 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5647 using adapter_type = iterator_input_adapter<iterator_type>;
5649 static adapter_type create(IteratorType first, IteratorType last)
5651 return adapter_type(std::move(first), std::move(last));
5655 template<
typename T>
5656 struct is_iterator_of_multibyte
5658 using value_type =
typename std::iterator_traits<T>::value_type;
5661 value =
sizeof(value_type) > 1
5665 template<
typename IteratorType>
5666 struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5668 using iterator_type = IteratorType;
5669 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5670 using base_adapter_type = iterator_input_adapter<iterator_type>;
5671 using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
5673 static adapter_type create(IteratorType first, IteratorType last)
5675 return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5680 template<
typename IteratorType>
5681 typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5683 using factory_type = iterator_input_adapter_factory<IteratorType>;
5684 return factory_type::create(first, last);
5691 namespace container_input_adapter_factory_impl
5697 template<
typename ContainerType,
typename Enable =
void>
5698 struct container_input_adapter_factory {};
5700 template<
typename ContainerType>
5701 struct container_input_adapter_factory< ContainerType,
5702 void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
5704 using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
5706 static adapter_type create(
const ContainerType& container)
5708 return input_adapter(begin(container), end(container));
5714 template<
typename ContainerType>
5715 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(
const ContainerType& container)
5717 return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
5722 inline file_input_adapter input_adapter(std::FILE* file)
5724 return file_input_adapter(file);
5727 inline input_stream_adapter input_adapter(std::istream& stream)
5729 return input_stream_adapter(stream);
5732 inline input_stream_adapter input_adapter(std::istream&& stream)
5734 return input_stream_adapter(stream);
5738 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5741 template <
typename CharT,
5742 typename std::enable_if <
5743 std::is_pointer<CharT>::value&&
5744 !std::is_array<CharT>::value&&
5745 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5746 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5748 contiguous_bytes_input_adapter input_adapter(CharT b)
5750 auto length = std::strlen(
reinterpret_cast<const char*
>(b));
5751 const auto* ptr =
reinterpret_cast<const char*
>(b);
5752 return input_adapter(ptr, ptr + length);
5755 template<
typename T, std::
size_t N>
5756 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
5758 return input_adapter(array, array + N);
5764 class span_input_adapter
5767 template <
typename CharT,
5768 typename std::enable_if <
5769 std::is_pointer<CharT>::value&&
5770 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5771 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5773 span_input_adapter(CharT b, std::size_t l)
5774 : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5776 template<
class IteratorType,
5777 typename std::enable_if<
5778 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5780 span_input_adapter(IteratorType first, IteratorType last)
5781 : ia(input_adapter(first, last)) {}
5783 contiguous_bytes_input_adapter&& get()
5785 return std::move(ia);
5789 contiguous_bytes_input_adapter ia;
5818 template<
typename BasicJsonType>
5831 virtual bool null() = 0;
5922 const std::string& last_token,
5923 const detail::exception& ex) = 0;
5949 template<
typename BasicJsonType>
5950 class json_sax_dom_parser
5956 using string_t =
typename BasicJsonType::string_t;
5957 using binary_t =
typename BasicJsonType::binary_t;
5964 explicit json_sax_dom_parser(BasicJsonType& r,
const bool allow_exceptions_ =
true)
5965 : root(r), allow_exceptions(allow_exceptions_)
5969 json_sax_dom_parser(
const json_sax_dom_parser&) =
delete;
5970 json_sax_dom_parser(json_sax_dom_parser&&) =
default;
5971 json_sax_dom_parser&
operator=(
const json_sax_dom_parser&) =
delete;
5972 json_sax_dom_parser&
operator=(json_sax_dom_parser&&) =
default;
5973 ~json_sax_dom_parser() =
default;
5977 handle_value(
nullptr);
6013 handle_value(std::move(val));
6019 ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
6021 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6023 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6032 object_element = &(ref_stack.back()->m_value.object->operator[](val));
6038 ref_stack.back()->set_parents();
6039 ref_stack.pop_back();
6045 ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
6047 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6049 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6057 ref_stack.back()->set_parents();
6058 ref_stack.pop_back();
6062 template<
class Exception>
6063 bool parse_error(std::size_t ,
const std::string& ,
6064 const Exception& ex)
6067 static_cast<void>(ex);
6068 if (allow_exceptions)
6075 constexpr
bool is_errored()
const
6087 template<
typename Value>
6089 BasicJsonType* handle_value(Value&& v)
6091 if (ref_stack.empty())
6093 root = BasicJsonType(std::forward<Value>(v));
6097 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6099 if (ref_stack.back()->is_array())
6101 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6102 return &(ref_stack.back()->m_value.array->back());
6105 JSON_ASSERT(ref_stack.back()->is_object());
6106 JSON_ASSERT(object_element);
6107 *object_element = BasicJsonType(std::forward<Value>(v));
6108 return object_element;
6112 BasicJsonType& root;
6114 std::vector<BasicJsonType*> ref_stack {};
6116 BasicJsonType* object_element =
nullptr;
6118 bool errored =
false;
6120 const bool allow_exceptions =
true;
6123 template<
typename BasicJsonType>
6124 class json_sax_dom_callback_parser
6130 using string_t =
typename BasicJsonType::string_t;
6131 using binary_t =
typename BasicJsonType::binary_t;
6132 using parser_callback_t =
typename BasicJsonType::parser_callback_t;
6133 using parse_event_t =
typename BasicJsonType::parse_event_t;
6135 json_sax_dom_callback_parser(BasicJsonType& r,
6136 const parser_callback_t cb,
6137 const bool allow_exceptions_ =
true)
6138 : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6140 keep_stack.push_back(
true);
6144 json_sax_dom_callback_parser(
const json_sax_dom_callback_parser&) =
delete;
6145 json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) =
default;
6146 json_sax_dom_callback_parser&
operator=(
const json_sax_dom_callback_parser&) =
delete;
6147 json_sax_dom_callback_parser&
operator=(json_sax_dom_callback_parser&&) =
default;
6148 ~json_sax_dom_callback_parser() =
default;
6152 handle_value(
nullptr);
6188 handle_value(std::move(val));
6195 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
6196 keep_stack.push_back(keep);
6198 auto val = handle_value(BasicJsonType::value_t::object,
true);
6199 ref_stack.push_back(val.second);
6202 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6204 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6212 BasicJsonType k = BasicJsonType(val);
6215 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::key, k);
6216 key_keep_stack.push_back(keep);
6219 if (keep && ref_stack.back())
6221 object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
6229 if (ref_stack.back())
6231 if (!callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
6234 *ref_stack.back() = discarded;
6238 ref_stack.back()->set_parents();
6242 JSON_ASSERT(!ref_stack.empty());
6243 JSON_ASSERT(!keep_stack.empty());
6244 ref_stack.pop_back();
6245 keep_stack.pop_back();
6247 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
6250 for (
auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
6252 if (it->is_discarded())
6254 ref_stack.back()->erase(it);
6265 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
6266 keep_stack.push_back(keep);
6268 auto val = handle_value(BasicJsonType::value_t::array,
true);
6269 ref_stack.push_back(val.second);
6272 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6274 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6284 if (ref_stack.back())
6286 keep = callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
6289 ref_stack.back()->set_parents();
6294 *ref_stack.back() = discarded;
6298 JSON_ASSERT(!ref_stack.empty());
6299 JSON_ASSERT(!keep_stack.empty());
6300 ref_stack.pop_back();
6301 keep_stack.pop_back();
6304 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
6306 ref_stack.back()->m_value.array->pop_back();
6312 template<
class Exception>
6313 bool parse_error(std::size_t ,
const std::string& ,
6314 const Exception& ex)
6317 static_cast<void>(ex);
6318 if (allow_exceptions)
6325 constexpr
bool is_errored()
const
6346 template<
typename Value>
6347 std::pair<bool, BasicJsonType*> handle_value(Value&& v,
const bool skip_callback =
false)
6349 JSON_ASSERT(!keep_stack.empty());
6353 if (!keep_stack.back())
6355 return {
false,
nullptr};
6359 auto value = BasicJsonType(std::forward<Value>(v));
6362 const bool keep = skip_callback || callback(
static_cast<int>(ref_stack.size()), parse_event_t::value, value);
6367 return {
false,
nullptr};
6370 if (ref_stack.empty())
6372 root = std::move(value);
6373 return {
true, &root};
6378 if (!ref_stack.back())
6380 return {
false,
nullptr};
6384 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6387 if (ref_stack.back()->is_array())
6389 ref_stack.back()->m_value.array->emplace_back(std::move(value));
6390 return {
true, &(ref_stack.back()->m_value.array->back())};
6394 JSON_ASSERT(ref_stack.back()->is_object());
6396 JSON_ASSERT(!key_keep_stack.empty());
6397 const bool store_element = key_keep_stack.back();
6398 key_keep_stack.pop_back();
6402 return {
false,
nullptr};
6405 JSON_ASSERT(object_element);
6406 *object_element = std::move(value);
6407 return {
true, object_element};
6411 BasicJsonType& root;
6413 std::vector<BasicJsonType*> ref_stack {};
6415 std::vector<bool> keep_stack {};
6417 std::vector<bool> key_keep_stack {};
6419 BasicJsonType* object_element =
nullptr;
6421 bool errored =
false;
6423 const parser_callback_t callback =
nullptr;
6425 const bool allow_exceptions =
true;
6427 BasicJsonType discarded = BasicJsonType::value_t::discarded;
6430 template<
typename BasicJsonType>
6431 class json_sax_acceptor
6437 using string_t =
typename BasicJsonType::string_t;
6438 using binary_t =
typename BasicJsonType::binary_t;
6500 bool parse_error(std::size_t ,
const std::string& ,
const detail::exception& )
6517 #include <initializer_list>
6537 template<
typename BasicJsonType>
6542 enum class token_type
6566 static const char* token_type_name(
const token_type t) noexcept
6570 case token_type::uninitialized:
6571 return "<uninitialized>";
6572 case token_type::literal_true:
6573 return "true literal";
6574 case token_type::literal_false:
6575 return "false literal";
6576 case token_type::literal_null:
6577 return "null literal";
6578 case token_type::value_string:
6579 return "string literal";
6580 case token_type::value_unsigned:
6581 case token_type::value_integer:
6582 case token_type::value_float:
6583 return "number literal";
6584 case token_type::begin_array:
6586 case token_type::begin_object:
6588 case token_type::end_array:
6590 case token_type::end_object:
6592 case token_type::name_separator:
6594 case token_type::value_separator:
6596 case token_type::parse_error:
6597 return "<parse error>";
6598 case token_type::end_of_input:
6599 return "end of input";
6600 case token_type::literal_or_value:
6601 return "'[', '{', or a literal";
6604 return "unknown token";
6614 template<
typename BasicJsonType,
typename InputAdapterType>
6615 class lexer :
public lexer_base<BasicJsonType>
6617 using number_integer_t =
typename BasicJsonType::number_integer_t;
6618 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
6619 using number_float_t =
typename BasicJsonType::number_float_t;
6620 using string_t =
typename BasicJsonType::string_t;
6621 using char_type =
typename InputAdapterType::char_type;
6622 using char_int_type =
typename std::char_traits<char_type>::int_type;
6625 using token_type =
typename lexer_base<BasicJsonType>::token_type;
6627 explicit lexer(InputAdapterType&& adapter,
bool ignore_comments_ =
false) noexcept
6628 : ia(std::move(adapter))
6629 , ignore_comments(ignore_comments_)
6630 , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
6634 lexer(
const lexer&) =
delete;
6635 lexer(lexer&&) =
default;
6636 lexer& operator=(lexer&) =
delete;
6637 lexer& operator=(lexer&&) =
default;
6647 static char get_decimal_point() noexcept
6649 const auto* loc = localeconv();
6650 JSON_ASSERT(loc !=
nullptr);
6651 return (loc->decimal_point ==
nullptr) ?
'.' : *(loc->decimal_point);
6676 JSON_ASSERT(current ==
'u');
6679 const auto factors = { 12u, 8u, 4u, 0u };
6680 for (
const auto factor : factors)
6684 if (current >=
'0' && current <=
'9')
6686 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x30u) << factor);
6688 else if (current >=
'A' && current <=
'F')
6690 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x37u) << factor);
6692 else if (current >=
'a' && current <=
'f')
6694 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x57u) << factor);
6702 JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6721 bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6723 JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6726 for (
auto range = ranges.begin(); range != ranges.end(); ++range)
6729 if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6735 error_message =
"invalid string: ill-formed UTF-8 byte";
6758 token_type scan_string()
6764 JSON_ASSERT(current ==
'\"');
6772 case std::char_traits<char_type>::eof():
6774 error_message =
"invalid string: missing closing quote";
6775 return token_type::parse_error;
6781 return token_type::value_string;
6825 const int codepoint1 = get_codepoint();
6826 int codepoint = codepoint1;
6828 if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6830 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6831 return token_type::parse_error;
6835 if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6838 if (JSON_HEDLEY_LIKELY(get() ==
'\\' && get() ==
'u'))
6840 const int codepoint2 = get_codepoint();
6842 if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6844 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6845 return token_type::parse_error;
6849 if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6852 codepoint =
static_cast<int>(
6854 (
static_cast<unsigned int>(codepoint1) << 10u)
6856 +
static_cast<unsigned int>(codepoint2)
6864 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6865 return token_type::parse_error;
6870 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6871 return token_type::parse_error;
6876 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6878 error_message =
"invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6879 return token_type::parse_error;
6884 JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6887 if (codepoint < 0x80)
6890 add(
static_cast<char_int_type
>(codepoint));
6892 else if (codepoint <= 0x7FF)
6895 add(
static_cast<char_int_type
>(0xC0u | (
static_cast<unsigned int>(codepoint) >> 6u)));
6896 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6898 else if (codepoint <= 0xFFFF)
6901 add(
static_cast<char_int_type
>(0xE0u | (
static_cast<unsigned int>(codepoint) >> 12u)));
6902 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6903 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6908 add(
static_cast<char_int_type
>(0xF0u | (
static_cast<unsigned int>(codepoint) >> 18u)));
6909 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6910 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6911 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6919 error_message =
"invalid string: forbidden character after backslash";
6920 return token_type::parse_error;
6929 error_message =
"invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6930 return token_type::parse_error;
6935 error_message =
"invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6936 return token_type::parse_error;
6941 error_message =
"invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6942 return token_type::parse_error;
6947 error_message =
"invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6948 return token_type::parse_error;
6953 error_message =
"invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6954 return token_type::parse_error;
6959 error_message =
"invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6960 return token_type::parse_error;
6965 error_message =
"invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6966 return token_type::parse_error;
6971 error_message =
"invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6972 return token_type::parse_error;
6977 error_message =
"invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6978 return token_type::parse_error;
6983 error_message =
"invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6984 return token_type::parse_error;
6989 error_message =
"invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6990 return token_type::parse_error;
6995 error_message =
"invalid string: control character U+000B (VT) must be escaped to \\u000B";
6996 return token_type::parse_error;
7001 error_message =
"invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
7002 return token_type::parse_error;
7007 error_message =
"invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
7008 return token_type::parse_error;
7013 error_message =
"invalid string: control character U+000E (SO) must be escaped to \\u000E";
7014 return token_type::parse_error;
7019 error_message =
"invalid string: control character U+000F (SI) must be escaped to \\u000F";
7020 return token_type::parse_error;
7025 error_message =
"invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
7026 return token_type::parse_error;
7031 error_message =
"invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
7032 return token_type::parse_error;
7037 error_message =
"invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
7038 return token_type::parse_error;
7043 error_message =
"invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
7044 return token_type::parse_error;
7049 error_message =
"invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
7050 return token_type::parse_error;
7055 error_message =
"invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7056 return token_type::parse_error;
7061 error_message =
"invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7062 return token_type::parse_error;
7067 error_message =
"invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7068 return token_type::parse_error;
7073 error_message =
"invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7074 return token_type::parse_error;
7079 error_message =
"invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7080 return token_type::parse_error;
7085 error_message =
"invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7086 return token_type::parse_error;
7091 error_message =
"invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7092 return token_type::parse_error;
7097 error_message =
"invalid string: control character U+001C (FS) must be escaped to \\u001C";
7098 return token_type::parse_error;
7103 error_message =
"invalid string: control character U+001D (GS) must be escaped to \\u001D";
7104 return token_type::parse_error;
7109 error_message =
"invalid string: control character U+001E (RS) must be escaped to \\u001E";
7110 return token_type::parse_error;
7115 error_message =
"invalid string: control character U+001F (US) must be escaped to \\u001F";
7116 return token_type::parse_error;
7251 if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
7253 return token_type::parse_error;
7261 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7263 return token_type::parse_error;
7285 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7287 return token_type::parse_error;
7295 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7297 return token_type::parse_error;
7305 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7307 return token_type::parse_error;
7317 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7319 return token_type::parse_error;
7327 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7329 return token_type::parse_error;
7337 error_message =
"invalid string: ill-formed UTF-8 byte";
7338 return token_type::parse_error;
7361 case std::char_traits<char_type>::eof():
7378 case std::char_traits<char_type>::eof():
7381 error_message =
"invalid comment; missing closing '*/'";
7409 error_message =
"invalid comment; expecting '/' or '*' after '/'";
7415 JSON_HEDLEY_NON_NULL(2)
7416 static
void strtof(
float& f, const
char* str,
char** endptr) noexcept
7418 f = std::strtof(str, endptr);
7421 JSON_HEDLEY_NON_NULL(2)
7422 static
void strtof(
double& f, const
char* str,
char** endptr) noexcept
7424 f = std::strtod(str, endptr);
7427 JSON_HEDLEY_NON_NULL(2)
7428 static
void strtof(
long double& f, const
char* str,
char** endptr) noexcept
7430 f = std::strtold(str, endptr);
7473 token_type scan_number()
7480 token_type number_type = token_type::value_unsigned;
7488 goto scan_number_minus;
7494 goto scan_number_zero;
7508 goto scan_number_any1;
7518 number_type = token_type::value_integer;
7524 goto scan_number_zero;
7538 goto scan_number_any1;
7543 error_message =
"invalid number; expected digit after '-'";
7544 return token_type::parse_error;
7554 add(decimal_point_char);
7555 goto scan_number_decimal1;
7562 goto scan_number_exponent;
7566 goto scan_number_done;
7585 goto scan_number_any1;
7590 add(decimal_point_char);
7591 goto scan_number_decimal1;
7598 goto scan_number_exponent;
7602 goto scan_number_done;
7605 scan_number_decimal1:
7607 number_type = token_type::value_float;
7622 goto scan_number_decimal2;
7627 error_message =
"invalid number; expected digit after '.'";
7628 return token_type::parse_error;
7632 scan_number_decimal2:
7648 goto scan_number_decimal2;
7655 goto scan_number_exponent;
7659 goto scan_number_done;
7662 scan_number_exponent:
7664 number_type = token_type::value_float;
7671 goto scan_number_sign;
7686 goto scan_number_any2;
7692 "invalid number; expected '+', '-', or digit after exponent";
7693 return token_type::parse_error;
7713 goto scan_number_any2;
7718 error_message =
"invalid number; expected digit after exponent sign";
7719 return token_type::parse_error;
7739 goto scan_number_any2;
7743 goto scan_number_done;
7751 char* endptr =
nullptr;
7755 if (number_type == token_type::value_unsigned)
7757 const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7760 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7764 value_unsigned =
static_cast<number_unsigned_t
>(x);
7765 if (value_unsigned == x)
7767 return token_type::value_unsigned;
7771 else if (number_type == token_type::value_integer)
7773 const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7776 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7780 value_integer =
static_cast<number_integer_t
>(x);
7781 if (value_integer == x)
7783 return token_type::value_integer;
7790 strtof(value_float, token_buffer.data(), &endptr);
7793 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7795 return token_type::value_float;
7803 JSON_HEDLEY_NON_NULL(2)
7804 token_type scan_literal(const char_type* literal_text, const std::
size_t length,
7805 token_type return_type)
7807 JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7808 for (std::size_t i = 1; i < length; ++i)
7810 if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7812 error_message =
"invalid literal";
7813 return token_type::parse_error;
7824 void reset() noexcept
7826 token_buffer.clear();
7827 token_string.clear();
7828 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7843 ++position.chars_read_total;
7844 ++position.chars_read_current_line;
7853 current = ia.get_character();
7856 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7858 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7861 if (current ==
'\n')
7863 ++position.lines_read;
7864 position.chars_read_current_line = 0;
7882 --position.chars_read_total;
7885 if (position.chars_read_current_line == 0)
7887 if (position.lines_read > 0)
7889 --position.lines_read;
7894 --position.chars_read_current_line;
7897 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7899 JSON_ASSERT(!token_string.empty());
7900 token_string.pop_back();
7905 void add(char_int_type c)
7907 token_buffer.push_back(
static_cast<typename string_t::value_type
>(c));
7916 constexpr number_integer_t get_number_integer() const noexcept
7918 return value_integer;
7922 constexpr number_unsigned_t get_number_unsigned() const noexcept
7924 return value_unsigned;
7928 constexpr number_float_t get_number_float() const noexcept
7934 string_t& get_string()
7936 return token_buffer;
7944 constexpr position_t get_position() const noexcept
7952 std::string get_token_string()
const
7956 for (
const auto c : token_string)
7958 if (
static_cast<unsigned char>(c) <=
'\x1F')
7961 std::array<char, 9> cs{{}};
7962 (std::snprintf)(cs.data(), cs.size(),
"<U+%.4X>",
static_cast<unsigned char>(c));
7963 result += cs.data();
7968 result.push_back(
static_cast<std::string::value_type
>(c));
7977 constexpr
const char* get_error_message() const noexcept
7979 return error_message;
7995 return get() == 0xBB && get() == 0xBF;
8004 void skip_whitespace()
8010 while (current ==
' ' || current ==
'\t' || current ==
'\n' || current ==
'\r');
8016 if (position.chars_read_total == 0 && !skip_bom())
8018 error_message =
"invalid BOM; must be 0xEF 0xBB 0xBF if given";
8019 return token_type::parse_error;
8026 while (ignore_comments && current ==
'/')
8028 if (!scan_comment())
8030 return token_type::parse_error;
8041 return token_type::begin_array;
8043 return token_type::end_array;
8045 return token_type::begin_object;
8047 return token_type::end_object;
8049 return token_type::name_separator;
8051 return token_type::value_separator;
8056 std::array<char_type, 4> true_literal = {{char_type(
't'), char_type(
'r'), char_type(
'u'), char_type(
'e')}};
8057 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
8061 std::array<char_type, 5> false_literal = {{char_type(
'f'), char_type(
'a'), char_type(
'l'), char_type(
's'), char_type(
'e')}};
8062 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
8066 std::array<char_type, 4> null_literal = {{char_type(
'n'), char_type(
'u'), char_type(
'l'), char_type(
'l')}};
8067 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
8072 return scan_string();
8086 return scan_number();
8091 case std::char_traits<char_type>::eof():
8092 return token_type::end_of_input;
8096 error_message =
"invalid literal";
8097 return token_type::parse_error;
8103 InputAdapterType ia;
8106 const bool ignore_comments =
false;
8109 char_int_type current = std::char_traits<char_type>::eof();
8112 bool next_unget =
false;
8115 position_t position {};
8118 std::vector<char_type> token_string {};
8121 string_t token_buffer {};
8124 const char* error_message =
"";
8127 number_integer_t value_integer = 0;
8128 number_unsigned_t value_unsigned = 0;
8129 number_float_t value_float = 0;
8132 const char_int_type decimal_point_char =
'.';
8155 template<
typename T>
8156 using null_function_t = decltype(std::declval<T&>().
null());
8158 template<
typename T>
8159 using boolean_function_t =
8160 decltype(std::declval<T&>().
boolean(std::declval<bool>()));
8162 template<
typename T,
typename Integer>
8163 using number_integer_function_t =
8164 decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8166 template<
typename T,
typename Un
signed>
8167 using number_unsigned_function_t =
8168 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8170 template<
typename T,
typename Float,
typename String>
8171 using number_float_function_t = decltype(std::declval<T&>().number_float(
8172 std::declval<Float>(), std::declval<const String&>()));
8174 template<
typename T,
typename String>
8175 using string_function_t =
8176 decltype(std::declval<T&>().
string(std::declval<String&>()));
8178 template<
typename T,
typename Binary>
8179 using binary_function_t =
8180 decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8182 template<
typename T>
8183 using start_object_function_t =
8184 decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8186 template<
typename T,
typename String>
8187 using key_function_t =
8188 decltype(std::declval<T&>().key(std::declval<String&>()));
8190 template<
typename T>
8191 using end_object_function_t = decltype(std::declval<T&>().end_object());
8193 template<
typename T>
8194 using start_array_function_t =
8195 decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
8197 template<
typename T>
8198 using end_array_function_t = decltype(std::declval<T&>().end_array());
8200 template<
typename T,
typename Exception>
8201 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
8202 std::declval<std::size_t>(), std::declval<const std::string&>(),
8203 std::declval<const Exception&>()));
8205 template<
typename SAX,
typename BasicJsonType>
8209 static_assert(is_basic_json<BasicJsonType>::value,
8210 "BasicJsonType must be of type basic_json<...>");
8212 using number_integer_t =
typename BasicJsonType::number_integer_t;
8213 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8214 using number_float_t =
typename BasicJsonType::number_float_t;
8215 using string_t =
typename BasicJsonType::string_t;
8216 using binary_t =
typename BasicJsonType::binary_t;
8217 using exception_t =
typename BasicJsonType::exception;
8220 static constexpr
bool value =
8221 is_detected_exact<bool, null_function_t, SAX>::value &&
8222 is_detected_exact<bool, boolean_function_t, SAX>::value &&
8223 is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
8224 is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
8225 is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
8226 is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
8227 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
8228 is_detected_exact<bool, start_object_function_t, SAX>::value &&
8229 is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
8230 is_detected_exact<bool, end_object_function_t, SAX>::value &&
8231 is_detected_exact<bool, start_array_function_t, SAX>::value &&
8232 is_detected_exact<bool, end_array_function_t, SAX>::value &&
8233 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
8236 template<
typename SAX,
typename BasicJsonType>
8237 struct is_sax_static_asserts
8240 static_assert(is_basic_json<BasicJsonType>::value,
8241 "BasicJsonType must be of type basic_json<...>");
8243 using number_integer_t =
typename BasicJsonType::number_integer_t;
8244 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8245 using number_float_t =
typename BasicJsonType::number_float_t;
8246 using string_t =
typename BasicJsonType::string_t;
8247 using binary_t =
typename BasicJsonType::binary_t;
8248 using exception_t =
typename BasicJsonType::exception;
8251 static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
8252 "Missing/invalid function: bool null()");
8253 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8254 "Missing/invalid function: bool boolean(bool)");
8255 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8256 "Missing/invalid function: bool boolean(bool)");
8258 is_detected_exact<
bool, number_integer_function_t, SAX,
8259 number_integer_t>::value,
8260 "Missing/invalid function: bool number_integer(number_integer_t)");
8262 is_detected_exact<
bool, number_unsigned_function_t, SAX,
8263 number_unsigned_t>::value,
8264 "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
8265 static_assert(is_detected_exact<
bool, number_float_function_t, SAX,
8266 number_float_t, string_t>::value,
8267 "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
8269 is_detected_exact<bool, string_function_t, SAX, string_t>::value,
8270 "Missing/invalid function: bool string(string_t&)");
8272 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
8273 "Missing/invalid function: bool binary(binary_t&)");
8274 static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
8275 "Missing/invalid function: bool start_object(std::size_t)");
8276 static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
8277 "Missing/invalid function: bool key(string_t&)");
8278 static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
8279 "Missing/invalid function: bool end_object()");
8280 static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
8281 "Missing/invalid function: bool start_array(std::size_t)");
8282 static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
8283 "Missing/invalid function: bool end_array()");
8285 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
8286 "Missing/invalid function: bool parse_error(std::size_t, const "
8287 "std::string&, const exception&)");
8303 enum class cbor_tag_handler_t
8317 static inline bool little_endianess(
int num = 1) noexcept
8319 return *
reinterpret_cast<char*
>(&num) == 1;
8330 template<
typename BasicJsonType,
typename InputAdapterType,
typename SAX = json_sax_dom_parser<BasicJsonType>>
8333 using number_integer_t =
typename BasicJsonType::number_integer_t;
8334 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8335 using number_float_t =
typename BasicJsonType::number_float_t;
8336 using string_t =
typename BasicJsonType::string_t;
8337 using binary_t =
typename BasicJsonType::binary_t;
8338 using json_sax_t = SAX;
8339 using char_type =
typename InputAdapterType::char_type;
8340 using char_int_type =
typename std::char_traits<char_type>::int_type;
8348 explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
8350 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
8354 binary_reader(
const binary_reader&) =
delete;
8355 binary_reader(binary_reader&&) =
default;
8356 binary_reader& operator=(
const binary_reader&) =
delete;
8357 binary_reader& operator=(binary_reader&&) =
default;
8358 ~binary_reader() =
default;
8368 JSON_HEDLEY_NON_NULL(3)
8369 bool sax_parse(const input_format_t format,
8371 const
bool strict = true,
8372 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
8375 bool result =
false;
8379 case input_format_t::bson:
8380 result = parse_bson_internal();
8383 case input_format_t::cbor:
8384 result = parse_cbor_internal(
true, tag_handler);
8387 case input_format_t::msgpack:
8388 result = parse_msgpack_internal();
8391 case input_format_t::ubjson:
8392 result = parse_ubjson_internal();
8395 case input_format_t::json:
8401 if (result && strict)
8403 if (format == input_format_t::ubjson)
8412 if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
8414 return sax->parse_error(chars_read, get_token_string(),
8415 parse_error::create(110, chars_read, exception_message(format,
"expected end of input; last byte: 0x" + get_token_string(),
"value"), BasicJsonType()));
8431 bool parse_bson_internal()
8433 std::int32_t document_size{};
8434 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8436 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
8441 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
false)))
8446 return sax->end_object();
8456 bool get_bson_cstr(string_t& result)
8458 auto out = std::back_inserter(result);
8462 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"cstring")))
8466 if (current == 0x00)
8470 *out++ =
static_cast<typename string_t::value_type
>(current);
8485 template<
typename NumberType>
8486 bool get_bson_string(
const NumberType len, string_t& result)
8488 if (JSON_HEDLEY_UNLIKELY(len < 1))
8490 auto last_token = get_token_string();
8491 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()));
8494 return get_string(input_format_t::bson, len -
static_cast<NumberType
>(1), result) && get() != std::char_traits<char_type>::eof();
8506 template<
typename NumberType>
8507 bool get_bson_binary(
const NumberType len, binary_t& result)
8509 if (JSON_HEDLEY_UNLIKELY(len < 0))
8511 auto last_token = get_token_string();
8512 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()));
8516 std::uint8_t subtype{};
8517 get_number<std::uint8_t>(input_format_t::bson, subtype);
8518 result.set_subtype(subtype);
8520 return get_binary(input_format_t::bson, len, result);
8533 bool parse_bson_element_internal(
const char_int_type element_type,
8534 const std::size_t element_type_parse_position)
8536 switch (element_type)
8541 return get_number<double, true>(input_format_t::bson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
8548 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
8553 return parse_bson_internal();
8558 return parse_bson_array();
8565 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
8570 return sax->boolean(get() != 0);
8580 std::int32_t value{};
8581 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8586 std::int64_t value{};
8587 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8592 std::array<char, 3> cr{{}};
8593 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(element_type));
8594 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()));
8611 bool parse_bson_element_list(
const bool is_array)
8615 while (
auto element_type = get())
8617 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"element list")))
8622 const std::size_t element_type_parse_position = chars_read;
8623 if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
8628 if (!is_array && !sax->key(key))
8633 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
8649 bool parse_bson_array()
8651 std::int32_t document_size{};
8652 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8654 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
8659 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
true)))
8664 return sax->end_array();
8679 bool parse_cbor_internal(
const bool get_char,
8680 const cbor_tag_handler_t tag_handler)
8682 switch (get_char ? get() : current)
8685 case std::char_traits<char_type>::eof():
8686 return unexpect_eof(input_format_t::cbor,
"value");
8713 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
8717 std::uint8_t number{};
8718 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8723 std::uint16_t number{};
8724 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8729 std::uint32_t number{};
8730 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8735 std::uint64_t number{};
8736 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8764 return sax->number_integer(
static_cast<std::int8_t
>(0x20 - 1 - current));
8768 std::uint8_t number{};
8769 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8774 std::uint16_t number{};
8775 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8780 std::uint32_t number{};
8781 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8786 std::uint64_t number{};
8787 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1)
8788 -
static_cast<number_integer_t
>(number));
8823 return get_cbor_binary(b) && sax->binary(b);
8858 return get_cbor_string(s) && sax->string(s);
8886 return get_cbor_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8891 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8896 std::uint16_t len{};
8897 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8902 std::uint32_t len{};
8903 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8908 std::uint64_t len{};
8909 return get_number(input_format_t::cbor, len) && get_cbor_array(detail::conditional_static_cast<std::size_t>(len), tag_handler);
8913 return get_cbor_array(std::size_t(-1), tag_handler);
8940 return get_cbor_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8945 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8950 std::uint16_t len{};
8951 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8956 std::uint32_t len{};
8957 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8962 std::uint64_t len{};
8963 return get_number(input_format_t::cbor, len) && get_cbor_object(detail::conditional_static_cast<std::size_t>(len), tag_handler);
8967 return get_cbor_object(std::size_t(-1), tag_handler);
8989 switch (tag_handler)
8991 case cbor_tag_handler_t::error:
8993 auto last_token = get_token_string();
8994 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()));
8997 case cbor_tag_handler_t::ignore:
9004 std::uint8_t subtype_to_ignore{};
9005 get_number(input_format_t::cbor, subtype_to_ignore);
9010 std::uint16_t subtype_to_ignore{};
9011 get_number(input_format_t::cbor, subtype_to_ignore);
9016 std::uint32_t subtype_to_ignore{};
9017 get_number(input_format_t::cbor, subtype_to_ignore);
9022 std::uint64_t subtype_to_ignore{};
9023 get_number(input_format_t::cbor, subtype_to_ignore);
9029 return parse_cbor_internal(
true, tag_handler);
9032 case cbor_tag_handler_t::store:
9040 std::uint8_t subtype{};
9041 get_number(input_format_t::cbor, subtype);
9042 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9047 std::uint16_t subtype{};
9048 get_number(input_format_t::cbor, subtype);
9049 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9054 std::uint32_t subtype{};
9055 get_number(input_format_t::cbor, subtype);
9056 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9061 std::uint64_t subtype{};
9062 get_number(input_format_t::cbor, subtype);
9063 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9067 return parse_cbor_internal(
true, tag_handler);
9070 return get_cbor_binary(b) && sax->binary(b);
9080 return sax->boolean(
false);
9083 return sax->boolean(
true);
9090 const auto byte1_raw = get();
9091 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
9095 const auto byte2_raw = get();
9096 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
9101 const auto byte1 =
static_cast<unsigned char>(byte1_raw);
9102 const auto byte2 =
static_cast<unsigned char>(byte2_raw);
9112 const auto half =
static_cast<unsigned int>((byte1 << 8u) + byte2);
9113 const double val = [&half]
9115 const int exp = (half >> 10u) & 0x1Fu;
9116 const unsigned int mant = half & 0x3FFu;
9117 JSON_ASSERT(0 <= exp&& exp <= 32);
9118 JSON_ASSERT(mant <= 1024);
9122 return std::ldexp(mant, -24);
9125 ? std::numeric_limits<double>::infinity()
9126 : std::numeric_limits<double>::quiet_NaN();
9128 return std::ldexp(mant + 1024, exp - 25);
9131 return sax->number_float((half & 0x8000u) != 0
9132 ?
static_cast<number_float_t
>(-val)
9133 :
static_cast<number_float_t
>(val),
"");
9139 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9145 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9150 auto last_token = get_token_string();
9151 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()));
9167 bool get_cbor_string(string_t& result)
9169 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"string")))
9202 return get_string(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
9208 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9213 std::uint16_t len{};
9214 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9219 std::uint32_t len{};
9220 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9225 std::uint64_t len{};
9226 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9231 while (get() != 0xFF)
9234 if (!get_cbor_string(chunk))
9238 result.append(chunk);
9245 auto last_token = get_token_string();
9246 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()));
9262 bool get_cbor_binary(binary_t& result)
9264 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"binary")))
9297 return get_binary(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
9303 return get_number(input_format_t::cbor, len) &&
9304 get_binary(input_format_t::cbor, len, result);
9309 std::uint16_t len{};
9310 return get_number(input_format_t::cbor, len) &&
9311 get_binary(input_format_t::cbor, len, result);
9316 std::uint32_t len{};
9317 return get_number(input_format_t::cbor, len) &&
9318 get_binary(input_format_t::cbor, len, result);
9323 std::uint64_t len{};
9324 return get_number(input_format_t::cbor, len) &&
9325 get_binary(input_format_t::cbor, len, result);
9330 while (get() != 0xFF)
9333 if (!get_cbor_binary(chunk))
9337 result.insert(result.end(), chunk.begin(), chunk.end());
9344 auto last_token = get_token_string();
9345 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()));
9356 bool get_cbor_array(
const std::size_t len,
9357 const cbor_tag_handler_t tag_handler)
9359 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9364 if (len != std::size_t(-1))
9366 for (std::size_t i = 0; i < len; ++i)
9368 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9376 while (get() != 0xFF)
9378 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
false, tag_handler)))
9385 return sax->end_array();
9394 bool get_cbor_object(
const std::size_t len,
9395 const cbor_tag_handler_t tag_handler)
9397 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9405 if (len != std::size_t(-1))
9407 for (std::size_t i = 0; i < len; ++i)
9410 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9415 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9424 while (get() != 0xFF)
9426 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9431 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9440 return sax->end_object();
9450 bool parse_msgpack_internal()
9455 case std::char_traits<char_type>::eof():
9456 return unexpect_eof(input_format_t::msgpack,
"value");
9587 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
9606 return get_msgpack_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
9625 return get_msgpack_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
9665 return get_msgpack_string(s) && sax->string(s);
9672 return sax->boolean(
false);
9675 return sax->boolean(
true);
9690 return get_msgpack_binary(b) && sax->binary(b);
9696 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9702 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9707 std::uint8_t number{};
9708 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9713 std::uint16_t number{};
9714 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9719 std::uint32_t number{};
9720 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9725 std::uint64_t number{};
9726 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9731 std::int8_t number{};
9732 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9737 std::int16_t number{};
9738 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9743 std::int32_t number{};
9744 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9749 std::int64_t number{};
9750 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9755 std::uint16_t len{};
9756 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9761 std::uint32_t len{};
9762 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9767 std::uint16_t len{};
9768 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9773 std::uint32_t len{};
9774 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9810 return sax->number_integer(
static_cast<std::int8_t
>(current));
9814 auto last_token = get_token_string();
9815 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()));
9830 bool get_msgpack_string(string_t& result)
9832 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack,
"string")))
9873 return get_string(input_format_t::msgpack,
static_cast<unsigned int>(current) & 0x1Fu, result);
9879 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9884 std::uint16_t len{};
9885 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9890 std::uint32_t len{};
9891 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9896 auto last_token = get_token_string();
9897 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()));
9912 bool get_msgpack_binary(binary_t& result)
9915 auto assign_and_return_true = [&result](std::int8_t subtype)
9917 result.set_subtype(
static_cast<std::uint8_t
>(subtype));
9926 return get_number(input_format_t::msgpack, len) &&
9927 get_binary(input_format_t::msgpack, len, result);
9932 std::uint16_t len{};
9933 return get_number(input_format_t::msgpack, len) &&
9934 get_binary(input_format_t::msgpack, len, result);
9939 std::uint32_t len{};
9940 return get_number(input_format_t::msgpack, len) &&
9941 get_binary(input_format_t::msgpack, len, result);
9947 std::int8_t subtype{};
9948 return get_number(input_format_t::msgpack, len) &&
9949 get_number(input_format_t::msgpack, subtype) &&
9950 get_binary(input_format_t::msgpack, len, result) &&
9951 assign_and_return_true(subtype);
9956 std::uint16_t len{};
9957 std::int8_t subtype{};
9958 return get_number(input_format_t::msgpack, len) &&
9959 get_number(input_format_t::msgpack, subtype) &&
9960 get_binary(input_format_t::msgpack, len, result) &&
9961 assign_and_return_true(subtype);
9966 std::uint32_t len{};
9967 std::int8_t subtype{};
9968 return get_number(input_format_t::msgpack, len) &&
9969 get_number(input_format_t::msgpack, subtype) &&
9970 get_binary(input_format_t::msgpack, len, result) &&
9971 assign_and_return_true(subtype);
9976 std::int8_t subtype{};
9977 return get_number(input_format_t::msgpack, subtype) &&
9978 get_binary(input_format_t::msgpack, 1, result) &&
9979 assign_and_return_true(subtype);
9984 std::int8_t subtype{};
9985 return get_number(input_format_t::msgpack, subtype) &&
9986 get_binary(input_format_t::msgpack, 2, result) &&
9987 assign_and_return_true(subtype);
9992 std::int8_t subtype{};
9993 return get_number(input_format_t::msgpack, subtype) &&
9994 get_binary(input_format_t::msgpack, 4, result) &&
9995 assign_and_return_true(subtype);
10000 std::int8_t subtype{};
10001 return get_number(input_format_t::msgpack, subtype) &&
10002 get_binary(input_format_t::msgpack, 8, result) &&
10003 assign_and_return_true(subtype);
10008 std::int8_t subtype{};
10009 return get_number(input_format_t::msgpack, subtype) &&
10010 get_binary(input_format_t::msgpack, 16, result) &&
10011 assign_and_return_true(subtype);
10023 bool get_msgpack_array(
const std::size_t len)
10025 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
10030 for (std::size_t i = 0; i < len; ++i)
10032 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
10038 return sax->end_array();
10045 bool get_msgpack_object(
const std::size_t len)
10047 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
10053 for (std::size_t i = 0; i < len; ++i)
10056 if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
10061 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
10068 return sax->end_object();
10082 bool parse_ubjson_internal(
const bool get_char =
true)
10084 return get_ubjson_value(get_char ? get_ignore_noop() : current);
10101 bool get_ubjson_string(string_t& result,
const bool get_char =
true)
10108 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
10117 std::uint8_t len{};
10118 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10124 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10129 std::int16_t len{};
10130 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10135 std::int32_t len{};
10136 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10141 std::int64_t len{};
10142 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10146 auto last_token = get_token_string();
10147 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()));
10155 bool get_ubjson_size_value(std::size_t& result)
10157 switch (get_ignore_noop())
10161 std::uint8_t number{};
10162 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10166 result =
static_cast<std::size_t
>(number);
10172 std::int8_t number{};
10173 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10177 result =
static_cast<std::size_t
>(number);
10183 std::int16_t number{};
10184 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10188 result =
static_cast<std::size_t
>(number);
10194 std::int32_t number{};
10195 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10199 result =
static_cast<std::size_t
>(number);
10205 std::int64_t number{};
10206 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10210 result =
static_cast<std::size_t
>(number);
10216 auto last_token = get_token_string();
10217 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()));
10232 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
10234 result.first = string_t::npos;
10239 if (current ==
'$')
10241 result.second = get();
10242 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"type")))
10248 if (JSON_HEDLEY_UNLIKELY(current !=
'#'))
10250 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
10254 auto last_token = get_token_string();
10255 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()));
10258 return get_ubjson_size_value(result.first);
10261 if (current ==
'#')
10263 return get_ubjson_size_value(result.first);
10273 bool get_ubjson_value(
const char_int_type prefix)
10277 case std::char_traits<char_type>::eof():
10278 return unexpect_eof(input_format_t::ubjson,
"value");
10281 return sax->boolean(
true);
10283 return sax->boolean(
false);
10286 return sax->null();
10290 std::uint8_t number{};
10291 return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
10296 std::int8_t number{};
10297 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10302 std::int16_t number{};
10303 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10308 std::int32_t number{};
10309 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10314 std::int64_t number{};
10315 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10321 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
10327 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
10332 return get_ubjson_high_precision_number();
10338 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"char")))
10342 if (JSON_HEDLEY_UNLIKELY(current > 127))
10344 auto last_token = get_token_string();
10345 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()));
10347 string_t s(1,
static_cast<typename string_t::value_type
>(current));
10348 return sax->string(s);
10354 return get_ubjson_string(s) && sax->string(s);
10358 return get_ubjson_array();
10361 return get_ubjson_object();
10365 auto last_token = get_token_string();
10366 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()));
10374 bool get_ubjson_array()
10376 std::pair<std::size_t, char_int_type> size_and_type;
10377 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10382 if (size_and_type.first != string_t::npos)
10384 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
10389 if (size_and_type.second != 0)
10391 if (size_and_type.second !=
'N')
10393 for (std::size_t i = 0; i < size_and_type.first; ++i)
10395 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10404 for (std::size_t i = 0; i < size_and_type.first; ++i)
10406 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10415 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10420 while (current !=
']')
10422 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(
false)))
10430 return sax->end_array();
10436 bool get_ubjson_object()
10438 std::pair<std::size_t, char_int_type> size_and_type;
10439 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10445 if (size_and_type.first != string_t::npos)
10447 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
10452 if (size_and_type.second != 0)
10454 for (std::size_t i = 0; i < size_and_type.first; ++i)
10456 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10460 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10469 for (std::size_t i = 0; i < size_and_type.first; ++i)
10471 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10475 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10485 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10490 while (current !=
'}')
10492 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key,
false) || !sax->key(key)))
10496 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10505 return sax->end_object();
10511 bool get_ubjson_high_precision_number()
10514 std::size_t size{};
10515 auto res = get_ubjson_size_value(size);
10516 if (JSON_HEDLEY_UNLIKELY(!res))
10522 std::vector<char> number_vector;
10523 for (std::size_t i = 0; i < size; ++i)
10526 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"number")))
10530 number_vector.push_back(
static_cast<char>(current));
10534 using ia_type = decltype(detail::input_adapter(number_vector));
10535 auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector),
false);
10536 const auto result_number = number_lexer.scan();
10537 const auto number_string = number_lexer.get_token_string();
10538 const auto result_remainder = number_lexer.scan();
10540 using token_type =
typename detail::lexer_base<BasicJsonType>::token_type;
10542 if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
10544 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()));
10547 switch (result_number)
10549 case token_type::value_integer:
10550 return sax->number_integer(number_lexer.get_number_integer());
10551 case token_type::value_unsigned:
10552 return sax->number_unsigned(number_lexer.get_number_unsigned());
10553 case token_type::value_float:
10554 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
10555 case token_type::uninitialized:
10556 case token_type::literal_true:
10557 case token_type::literal_false:
10558 case token_type::literal_null:
10559 case token_type::value_string:
10560 case token_type::begin_array:
10561 case token_type::begin_object:
10562 case token_type::end_array:
10563 case token_type::end_object:
10564 case token_type::name_separator:
10565 case token_type::value_separator:
10566 case token_type::parse_error:
10567 case token_type::end_of_input:
10568 case token_type::literal_or_value:
10570 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()));
10587 char_int_type get()
10590 return current = ia.get_character();
10596 char_int_type get_ignore_noop()
10602 while (current ==
'N');
10620 template<
typename NumberType,
bool InputIsLittleEndian = false>
10621 bool get_number(
const input_format_t format, NumberType& result)
10624 std::array<std::uint8_t,
sizeof(NumberType)> vec{};
10625 for (std::size_t i = 0; i <
sizeof(NumberType); ++i)
10628 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"number")))
10634 if (is_little_endian != InputIsLittleEndian)
10636 vec[
sizeof(NumberType) - i - 1] =
static_cast<std::uint8_t
>(current);
10640 vec[i] =
static_cast<std::uint8_t
>(current);
10645 std::memcpy(&result, vec.data(),
sizeof(NumberType));
10663 template<
typename NumberType>
10664 bool get_string(
const input_format_t format,
10665 const NumberType len,
10668 bool success =
true;
10669 for (NumberType i = 0; i < len; i++)
10672 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"string")))
10677 result.push_back(
static_cast<typename string_t::value_type
>(current));
10696 template<
typename NumberType>
10697 bool get_binary(
const input_format_t format,
10698 const NumberType len,
10701 bool success =
true;
10702 for (NumberType i = 0; i < len; i++)
10705 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"binary")))
10710 result.push_back(
static_cast<std::uint8_t
>(current));
10720 JSON_HEDLEY_NON_NULL(3)
10721 bool unexpect_eof(const input_format_t format, const
char* context)
const
10723 if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10725 return sax->parse_error(chars_read,
"<end of file>",
10726 parse_error::create(110, chars_read, exception_message(format,
"unexpected end of input", context), BasicJsonType()));
10734 std::string get_token_string()
const
10736 std::array<char, 3> cr{{}};
10737 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(current));
10738 return std::string{cr.data()};
10747 std::string exception_message(
const input_format_t format,
10748 const std::string& detail,
10749 const std::string& context)
const
10751 std::string error_msg =
"syntax error while parsing ";
10755 case input_format_t::cbor:
10756 error_msg +=
"CBOR";
10759 case input_format_t::msgpack:
10760 error_msg +=
"MessagePack";
10763 case input_format_t::ubjson:
10764 error_msg +=
"UBJSON";
10767 case input_format_t::bson:
10768 error_msg +=
"BSON";
10771 case input_format_t::json:
10773 JSON_ASSERT(
false);
10776 return error_msg +
" " + context +
": " + detail;
10781 InputAdapterType ia;
10784 char_int_type current = std::char_traits<char_type>::eof();
10787 std::size_t chars_read = 0;
10790 const bool is_little_endian = little_endianess();
10793 json_sax_t* sax =
nullptr;
10807 #include <functional>
10835 enum class parse_event_t : std::uint8_t
10851 template<
typename BasicJsonType>
10852 using parser_callback_t =
10853 std::function<bool(
int , parse_event_t , BasicJsonType& )>;
10860 template<
typename BasicJsonType,
typename InputAdapterType>
10863 using number_integer_t =
typename BasicJsonType::number_integer_t;
10864 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
10865 using number_float_t =
typename BasicJsonType::number_float_t;
10866 using string_t =
typename BasicJsonType::string_t;
10867 using lexer_t = lexer<BasicJsonType, InputAdapterType>;
10868 using token_type =
typename lexer_t::token_type;
10872 explicit parser(InputAdapterType&& adapter,
10873 const parser_callback_t<BasicJsonType> cb =
nullptr,
10874 const bool allow_exceptions_ =
true,
10875 const bool skip_comments =
false)
10877 , m_lexer(std::move(adapter), skip_comments)
10878 , allow_exceptions(allow_exceptions_)
10894 void parse(
const bool strict, BasicJsonType& result)
10898 json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
10899 sax_parse_internal(&sdp);
10902 if (strict && (get_token() != token_type::end_of_input))
10904 sdp.parse_error(m_lexer.get_position(),
10905 m_lexer.get_token_string(),
10906 parse_error::create(101, m_lexer.get_position(),
10907 exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
10911 if (sdp.is_errored())
10913 result = value_t::discarded;
10919 if (result.is_discarded())
10926 json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
10927 sax_parse_internal(&sdp);
10930 if (strict && (get_token() != token_type::end_of_input))
10932 sdp.parse_error(m_lexer.get_position(),
10933 m_lexer.get_token_string(),
10934 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
10938 if (sdp.is_errored())
10940 result = value_t::discarded;
10945 result.assert_invariant();
10954 bool accept(
const bool strict =
true)
10956 json_sax_acceptor<BasicJsonType> sax_acceptor;
10957 return sax_parse(&sax_acceptor, strict);
10960 template<
typename SAX>
10961 JSON_HEDLEY_NON_NULL(2)
10962 bool sax_parse(SAX* sax, const
bool strict = true)
10964 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
10965 const bool result = sax_parse_internal(sax);
10968 if (result && strict && (get_token() != token_type::end_of_input))
10970 return sax->parse_error(m_lexer.get_position(),
10971 m_lexer.get_token_string(),
10972 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
10979 template<
typename SAX>
10980 JSON_HEDLEY_NON_NULL(2)
10981 bool sax_parse_internal(SAX* sax)
10985 std::vector<bool> states;
10987 bool skip_to_state_evaluation =
false;
10991 if (!skip_to_state_evaluation)
10994 switch (last_token)
10996 case token_type::begin_object:
10998 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
11004 if (get_token() == token_type::end_object)
11006 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11014 if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
11016 return sax->parse_error(m_lexer.get_position(),
11017 m_lexer.get_token_string(),
11018 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string,
"object key"), BasicJsonType()));
11020 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11026 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11028 return sax->parse_error(m_lexer.get_position(),
11029 m_lexer.get_token_string(),
11030 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator,
"object separator"), BasicJsonType()));
11034 states.push_back(
false);
11041 case token_type::begin_array:
11043 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
11049 if (get_token() == token_type::end_array)
11051 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11059 states.push_back(
true);
11065 case token_type::value_float:
11067 const auto res = m_lexer.get_number_float();
11069 if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
11071 return sax->parse_error(m_lexer.get_position(),
11072 m_lexer.get_token_string(),
11073 out_of_range::create(406,
"number overflow parsing '" + m_lexer.get_token_string() +
"'", BasicJsonType()));
11076 if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
11084 case token_type::literal_false:
11086 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
false)))
11093 case token_type::literal_null:
11095 if (JSON_HEDLEY_UNLIKELY(!sax->null()))
11102 case token_type::literal_true:
11104 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
true)))
11111 case token_type::value_integer:
11113 if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
11120 case token_type::value_string:
11122 if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
11129 case token_type::value_unsigned:
11131 if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
11138 case token_type::parse_error:
11141 return sax->parse_error(m_lexer.get_position(),
11142 m_lexer.get_token_string(),
11143 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized,
"value"), BasicJsonType()));
11146 case token_type::uninitialized:
11147 case token_type::end_array:
11148 case token_type::end_object:
11149 case token_type::name_separator:
11150 case token_type::value_separator:
11151 case token_type::end_of_input:
11152 case token_type::literal_or_value:
11155 return sax->parse_error(m_lexer.get_position(),
11156 m_lexer.get_token_string(),
11157 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value,
"value"), BasicJsonType()));
11163 skip_to_state_evaluation =
false;
11167 if (states.empty())
11176 if (get_token() == token_type::value_separator)
11184 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
11186 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11195 JSON_ASSERT(!states.empty());
11197 skip_to_state_evaluation =
true;
11201 return sax->parse_error(m_lexer.get_position(),
11202 m_lexer.get_token_string(),
11203 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array,
"array"), BasicJsonType()));
11209 if (get_token() == token_type::value_separator)
11212 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
11214 return sax->parse_error(m_lexer.get_position(),
11215 m_lexer.get_token_string(),
11216 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string,
"object key"), BasicJsonType()));
11219 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11225 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11227 return sax->parse_error(m_lexer.get_position(),
11228 m_lexer.get_token_string(),
11229 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator,
"object separator"), BasicJsonType()));
11238 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
11240 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11249 JSON_ASSERT(!states.empty());
11251 skip_to_state_evaluation =
true;
11255 return sax->parse_error(m_lexer.get_position(),
11256 m_lexer.get_token_string(),
11257 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object,
"object"), BasicJsonType()));
11262 token_type get_token()
11264 return last_token = m_lexer.scan();
11267 std::string exception_message(
const token_type expected,
const std::string& context)
11269 std::string error_msg =
"syntax error ";
11271 if (!context.empty())
11273 error_msg +=
"while parsing " + context +
" ";
11278 if (last_token == token_type::parse_error)
11280 error_msg += std::string(m_lexer.get_error_message()) +
"; last read: '" +
11281 m_lexer.get_token_string() +
"'";
11285 error_msg +=
"unexpected " + std::string(lexer_t::token_type_name(last_token));
11288 if (expected != token_type::uninitialized)
11290 error_msg +=
"; expected " + std::string(lexer_t::token_type_name(expected));
11298 const parser_callback_t<BasicJsonType> callback =
nullptr;
11300 token_type last_token = token_type::uninitialized;
11304 const bool allow_exceptions =
true;
11335 class primitive_iterator_t
11338 using difference_type = std::ptrdiff_t;
11339 static constexpr difference_type begin_value = 0;
11340 static constexpr difference_type end_value = begin_value + 1;
11342 JSON_PRIVATE_UNLESS_TESTED:
11344 difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
11347 constexpr difference_type get_value() const noexcept
11353 void set_begin() noexcept
11355 m_it = begin_value;
11359 void set_end() noexcept
11365 constexpr
bool is_begin() const noexcept
11367 return m_it == begin_value;
11371 constexpr
bool is_end() const noexcept
11373 return m_it == end_value;
11376 friend constexpr
bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11378 return lhs.m_it == rhs.m_it;
11381 friend constexpr
bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11383 return lhs.m_it < rhs.m_it;
11386 primitive_iterator_t operator+(difference_type n) noexcept
11388 auto result = *
this;
11393 friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11395 return lhs.m_it - rhs.m_it;
11398 primitive_iterator_t& operator++() noexcept
11404 primitive_iterator_t
const operator++(
int) noexcept
11406 auto result = *
this;
11411 primitive_iterator_t& operator--() noexcept
11417 primitive_iterator_t
const operator--(
int) noexcept
11419 auto result = *
this;
11424 primitive_iterator_t& operator+=(difference_type n) noexcept
11430 primitive_iterator_t& operator-=(difference_type n) noexcept
11450 template<
typename BasicJsonType>
struct internal_iterator
11453 typename BasicJsonType::object_t::iterator object_iterator {};
11455 typename BasicJsonType::array_t::iterator array_iterator {};
11457 primitive_iterator_t primitive_iterator {};
11465 #include <iterator>
11466 #include <type_traits>
11488 template<
typename IteratorType>
class iteration_proxy;
11489 template<
typename IteratorType>
class iteration_proxy_value;
11507 template<
typename BasicJsonType>
11511 using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value,
typename std::remove_const<BasicJsonType>::type,
const BasicJsonType>::type>;
11513 friend other_iter_impl;
11514 friend BasicJsonType;
11515 friend iteration_proxy<iter_impl>;
11516 friend iteration_proxy_value<iter_impl>;
11518 using object_t =
typename BasicJsonType::object_t;
11519 using array_t =
typename BasicJsonType::array_t;
11521 static_assert(is_basic_json<
typename std::remove_const<BasicJsonType>::type>::value,
11522 "iter_impl only accepts (const) basic_json");
11531 using iterator_category = std::bidirectional_iterator_tag;
11534 using value_type =
typename BasicJsonType::value_type;
11536 using difference_type =
typename BasicJsonType::difference_type;
11538 using pointer =
typename std::conditional<std::is_const<BasicJsonType>::value,
11539 typename BasicJsonType::const_pointer,
11540 typename BasicJsonType::pointer>::type;
11543 typename std::conditional<std::is_const<BasicJsonType>::value,
11544 typename BasicJsonType::const_reference,
11545 typename BasicJsonType::reference>::type;
11547 iter_impl() =
default;
11548 ~iter_impl() =
default;
11549 iter_impl(iter_impl&&) noexcept = default;
11550 iter_impl& operator=(iter_impl&&) noexcept = default;
11558 explicit iter_impl(pointer
object) noexcept : m_object(
object)
11560 JSON_ASSERT(m_object !=
nullptr);
11562 switch (m_object->m_type)
11564 case value_t::object:
11566 m_it.object_iterator =
typename object_t::iterator();
11570 case value_t::array:
11572 m_it.array_iterator =
typename array_t::iterator();
11576 case value_t::null:
11577 case value_t::string:
11578 case value_t::boolean:
11579 case value_t::number_integer:
11580 case value_t::number_unsigned:
11581 case value_t::number_float:
11582 case value_t::binary:
11583 case value_t::discarded:
11586 m_it.primitive_iterator = primitive_iterator_t();
11608 iter_impl(
const iter_impl<const BasicJsonType>& other) noexcept
11609 : m_object(other.m_object), m_it(other.m_it)
11618 iter_impl& operator=(
const iter_impl<const BasicJsonType>& other) noexcept
11620 if (&other !=
this)
11622 m_object = other.m_object;
11633 iter_impl(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
11634 : m_object(other.m_object), m_it(other.m_it)
11643 iter_impl& operator=(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
11645 m_object = other.m_object;
11650 JSON_PRIVATE_UNLESS_TESTED:
11655 void set_begin() noexcept
11657 JSON_ASSERT(m_object !=
nullptr);
11659 switch (m_object->m_type)
11661 case value_t::object:
11663 m_it.object_iterator = m_object->m_value.object->begin();
11667 case value_t::array:
11669 m_it.array_iterator = m_object->m_value.array->begin();
11673 case value_t::null:
11676 m_it.primitive_iterator.set_end();
11680 case value_t::string:
11681 case value_t::boolean:
11682 case value_t::number_integer:
11683 case value_t::number_unsigned:
11684 case value_t::number_float:
11685 case value_t::binary:
11686 case value_t::discarded:
11689 m_it.primitive_iterator.set_begin();
11699 void set_end() noexcept
11701 JSON_ASSERT(m_object !=
nullptr);
11703 switch (m_object->m_type)
11705 case value_t::object:
11707 m_it.object_iterator = m_object->m_value.object->end();
11711 case value_t::array:
11713 m_it.array_iterator = m_object->m_value.array->end();
11717 case value_t::null:
11718 case value_t::string:
11719 case value_t::boolean:
11720 case value_t::number_integer:
11721 case value_t::number_unsigned:
11722 case value_t::number_float:
11723 case value_t::binary:
11724 case value_t::discarded:
11727 m_it.primitive_iterator.set_end();
11738 reference operator*()
const
11740 JSON_ASSERT(m_object !=
nullptr);
11742 switch (m_object->m_type)
11744 case value_t::object:
11746 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11747 return m_it.object_iterator->second;
11750 case value_t::array:
11752 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11753 return *m_it.array_iterator;
11756 case value_t::null:
11757 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11759 case value_t::string:
11760 case value_t::boolean:
11761 case value_t::number_integer:
11762 case value_t::number_unsigned:
11763 case value_t::number_float:
11764 case value_t::binary:
11765 case value_t::discarded:
11768 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11773 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11782 pointer operator->()
const
11784 JSON_ASSERT(m_object !=
nullptr);
11786 switch (m_object->m_type)
11788 case value_t::object:
11790 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11791 return &(m_it.object_iterator->second);
11794 case value_t::array:
11796 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11797 return &*m_it.array_iterator;
11800 case value_t::null:
11801 case value_t::string:
11802 case value_t::boolean:
11803 case value_t::number_integer:
11804 case value_t::number_unsigned:
11805 case value_t::number_float:
11806 case value_t::binary:
11807 case value_t::discarded:
11810 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11815 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11824 iter_impl
const operator++(
int)
11826 auto result = *
this;
11835 iter_impl& operator++()
11837 JSON_ASSERT(m_object !=
nullptr);
11839 switch (m_object->m_type)
11841 case value_t::object:
11843 std::advance(m_it.object_iterator, 1);
11847 case value_t::array:
11849 std::advance(m_it.array_iterator, 1);
11853 case value_t::null:
11854 case value_t::string:
11855 case value_t::boolean:
11856 case value_t::number_integer:
11857 case value_t::number_unsigned:
11858 case value_t::number_float:
11859 case value_t::binary:
11860 case value_t::discarded:
11863 ++m_it.primitive_iterator;
11875 iter_impl
const operator--(
int)
11877 auto result = *
this;
11886 iter_impl& operator--()
11888 JSON_ASSERT(m_object !=
nullptr);
11890 switch (m_object->m_type)
11892 case value_t::object:
11894 std::advance(m_it.object_iterator, -1);
11898 case value_t::array:
11900 std::advance(m_it.array_iterator, -1);
11904 case value_t::null:
11905 case value_t::string:
11906 case value_t::boolean:
11907 case value_t::number_integer:
11908 case value_t::number_unsigned:
11909 case value_t::number_float:
11910 case value_t::binary:
11911 case value_t::discarded:
11914 --m_it.primitive_iterator;
11926 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 >
11927 bool operator==(
const IterImpl& other)
const
11930 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11932 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers", *m_object));
11935 JSON_ASSERT(m_object !=
nullptr);
11937 switch (m_object->m_type)
11939 case value_t::object:
11940 return (m_it.object_iterator == other.m_it.object_iterator);
11942 case value_t::array:
11943 return (m_it.array_iterator == other.m_it.array_iterator);
11945 case value_t::null:
11946 case value_t::string:
11947 case value_t::boolean:
11948 case value_t::number_integer:
11949 case value_t::number_unsigned:
11950 case value_t::number_float:
11951 case value_t::binary:
11952 case value_t::discarded:
11954 return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11962 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 >
11963 bool operator!=(
const IterImpl& other)
const
11965 return !operator==(other);
11972 bool operator<(
const iter_impl& other)
const
11975 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11977 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers", *m_object));
11980 JSON_ASSERT(m_object !=
nullptr);
11982 switch (m_object->m_type)
11984 case value_t::object:
11985 JSON_THROW(invalid_iterator::create(213,
"cannot compare order of object iterators", *m_object));
11987 case value_t::array:
11988 return (m_it.array_iterator < other.m_it.array_iterator);
11990 case value_t::null:
11991 case value_t::string:
11992 case value_t::boolean:
11993 case value_t::number_integer:
11994 case value_t::number_unsigned:
11995 case value_t::number_float:
11996 case value_t::binary:
11997 case value_t::discarded:
11999 return (m_it.primitive_iterator < other.m_it.primitive_iterator);
12007 bool operator<=(
const iter_impl& other)
const
12009 return !other.operator < (*this);
12016 bool operator>(
const iter_impl& other)
const
12018 return !operator<=(other);
12025 bool operator>=(
const iter_impl& other)
const
12027 return !operator<(other);
12034 iter_impl& operator+=(difference_type i)
12036 JSON_ASSERT(m_object !=
nullptr);
12038 switch (m_object->m_type)
12040 case value_t::object:
12041 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators", *m_object));
12043 case value_t::array:
12045 std::advance(m_it.array_iterator, i);
12049 case value_t::null:
12050 case value_t::string:
12051 case value_t::boolean:
12052 case value_t::number_integer:
12053 case value_t::number_unsigned:
12054 case value_t::number_float:
12055 case value_t::binary:
12056 case value_t::discarded:
12059 m_it.primitive_iterator += i;
12071 iter_impl& operator-=(difference_type i)
12073 return operator+=(-i);
12080 iter_impl operator+(difference_type i)
const
12082 auto result = *
this;
12091 friend iter_impl operator+(difference_type i,
const iter_impl& it)
12102 iter_impl operator-(difference_type i)
const
12104 auto result = *
this;
12113 difference_type operator-(
const iter_impl& other)
const
12115 JSON_ASSERT(m_object !=
nullptr);
12117 switch (m_object->m_type)
12119 case value_t::object:
12120 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators", *m_object));
12122 case value_t::array:
12123 return m_it.array_iterator - other.m_it.array_iterator;
12125 case value_t::null:
12126 case value_t::string:
12127 case value_t::boolean:
12128 case value_t::number_integer:
12129 case value_t::number_unsigned:
12130 case value_t::number_float:
12131 case value_t::binary:
12132 case value_t::discarded:
12134 return m_it.primitive_iterator - other.m_it.primitive_iterator;
12142 reference operator[](difference_type n)
const
12144 JSON_ASSERT(m_object !=
nullptr);
12146 switch (m_object->m_type)
12148 case value_t::object:
12149 JSON_THROW(invalid_iterator::create(208,
"cannot use operator[] for object iterators", *m_object));
12151 case value_t::array:
12152 return *std::next(m_it.array_iterator, n);
12154 case value_t::null:
12155 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
12157 case value_t::string:
12158 case value_t::boolean:
12159 case value_t::number_integer:
12160 case value_t::number_unsigned:
12161 case value_t::number_float:
12162 case value_t::binary:
12163 case value_t::discarded:
12166 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
12171 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
12180 const typename object_t::key_type& key()
const
12182 JSON_ASSERT(m_object !=
nullptr);
12184 if (JSON_HEDLEY_LIKELY(m_object->is_object()))
12186 return m_it.object_iterator->first;
12189 JSON_THROW(invalid_iterator::create(207,
"cannot use key() for non-object iterators", *m_object));
12196 reference value()
const
12198 return operator*();
12201 JSON_PRIVATE_UNLESS_TESTED:
12203 pointer m_object =
nullptr;
12205 internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
12216 #include <iterator>
12245 template<
typename Base>
12246 class json_reverse_iterator :
public std::reverse_iterator<Base>
12249 using difference_type = std::ptrdiff_t;
12251 using base_iterator = std::reverse_iterator<Base>;
12253 using reference =
typename Base::reference;
12256 explicit json_reverse_iterator(
const typename base_iterator::iterator_type& it) noexcept
12257 : base_iterator(it) {}
12260 explicit json_reverse_iterator(
const base_iterator& it) noexcept : base_iterator(it) {}
12263 json_reverse_iterator
const operator++(
int)
12265 return static_cast<json_reverse_iterator
>(base_iterator::operator++(1));
12269 json_reverse_iterator& operator++()
12271 return static_cast<json_reverse_iterator&
>(base_iterator::operator++());
12275 json_reverse_iterator
const operator--(
int)
12277 return static_cast<json_reverse_iterator
>(base_iterator::operator--(1));
12281 json_reverse_iterator& operator--()
12283 return static_cast<json_reverse_iterator&
>(base_iterator::operator--());
12287 json_reverse_iterator& operator+=(difference_type i)
12289 return static_cast<json_reverse_iterator&
>(base_iterator::operator+=(i));
12293 json_reverse_iterator operator+(difference_type i)
const
12295 return static_cast<json_reverse_iterator
>(base_iterator::operator+(i));
12299 json_reverse_iterator operator-(difference_type i)
const
12301 return static_cast<json_reverse_iterator
>(base_iterator::operator-(i));
12305 difference_type operator-(
const json_reverse_iterator& other)
const
12307 return base_iterator(*
this) - base_iterator(other);
12311 reference operator[](difference_type n)
const
12313 return *(this->operator+(n));
12317 auto key() const -> decltype(std::declval<Base>().key())
12319 auto it = --this->base();
12324 reference value()
const
12326 auto it = --this->base();
12327 return it.operator * ();
12338 #include <algorithm>
12357 template<
typename BasicJsonType>
12361 NLOHMANN_BASIC_JSON_TPL_DECLARATION
12387 : reference_tokens(split(s))
12406 return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
12408 [](
const std::string & a,
const std::string & b)
12410 return a +
"/" + detail::escape(b);
12415 operator std::string()
const
12438 reference_tokens.insert(reference_tokens.end(),
12439 ptr.reference_tokens.begin(),
12440 ptr.reference_tokens.end());
12484 return *
this /= std::to_string(array_idx);
12588 if (JSON_HEDLEY_UNLIKELY(
empty()))
12590 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12593 reference_tokens.pop_back();
12612 if (JSON_HEDLEY_UNLIKELY(
empty()))
12614 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12617 return reference_tokens.back();
12634 reference_tokens.push_back(token);
12640 reference_tokens.push_back(std::move(token));
12659 return reference_tokens.empty();
12673 static typename BasicJsonType::size_type array_index(
const std::string& s)
12675 using size_type =
typename BasicJsonType::size_type;
12678 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] ==
'0'))
12680 JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + s +
"' must not begin with '0'", BasicJsonType()));
12684 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >=
'1' && s[0] <=
'9')))
12686 JSON_THROW(detail::parse_error::create(109, 0,
"array index '" + s +
"' is not a number", BasicJsonType()));
12689 std::size_t processed_chars = 0;
12690 unsigned long long res = 0;
12693 res = std::stoull(s, &processed_chars);
12695 JSON_CATCH(std::out_of_range&)
12697 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'", BasicJsonType()));
12701 if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
12703 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'", BasicJsonType()));
12708 if (res >=
static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
12710 JSON_THROW(detail::out_of_range::create(410,
"array index " + s +
" exceeds size_type", BasicJsonType()));
12713 return static_cast<size_type
>(res);
12716 JSON_PRIVATE_UNLESS_TESTED:
12719 if (JSON_HEDLEY_UNLIKELY(
empty()))
12721 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12725 result.reference_tokens = {reference_tokens[0]};
12738 BasicJsonType& get_and_create(BasicJsonType& j)
const
12744 for (
const auto& reference_token : reference_tokens)
12746 switch (result->type())
12748 case detail::value_t::null:
12750 if (reference_token ==
"0")
12753 result = &result->operator[](0);
12758 result = &result->operator[](reference_token);
12763 case detail::value_t::object:
12766 result = &result->operator[](reference_token);
12770 case detail::value_t::array:
12773 result = &result->operator[](array_index(reference_token));
12783 case detail::value_t::string:
12784 case detail::value_t::boolean:
12785 case detail::value_t::number_integer:
12786 case detail::value_t::number_unsigned:
12787 case detail::value_t::number_float:
12788 case detail::value_t::binary:
12789 case detail::value_t::discarded:
12791 JSON_THROW(detail::type_error::create(313,
"invalid value to unflatten", j));
12817 BasicJsonType& get_unchecked(BasicJsonType* ptr)
const
12819 for (
const auto& reference_token : reference_tokens)
12822 if (ptr->is_null())
12826 std::all_of(reference_token.begin(), reference_token.end(),
12827 [](
const unsigned char x)
12829 return std::isdigit(x);
12833 *ptr = (nums || reference_token ==
"-")
12834 ? detail::value_t::array
12835 : detail::value_t::object;
12838 switch (ptr->type())
12840 case detail::value_t::object:
12843 ptr = &ptr->operator[](reference_token);
12847 case detail::value_t::array:
12849 if (reference_token ==
"-")
12852 ptr = &ptr->operator[](ptr->m_value.array->size());
12857 ptr = &ptr->operator[](array_index(reference_token));
12862 case detail::value_t::null:
12863 case detail::value_t::string:
12864 case detail::value_t::boolean:
12865 case detail::value_t::number_integer:
12866 case detail::value_t::number_unsigned:
12867 case detail::value_t::number_float:
12868 case detail::value_t::binary:
12869 case detail::value_t::discarded:
12871 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12884 BasicJsonType& get_checked(BasicJsonType* ptr)
const
12886 for (
const auto& reference_token : reference_tokens)
12888 switch (ptr->type())
12890 case detail::value_t::object:
12893 ptr = &ptr->at(reference_token);
12897 case detail::value_t::array:
12899 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12902 JSON_THROW(detail::out_of_range::create(402,
12903 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12904 ") is out of range", *ptr));
12908 ptr = &ptr->at(array_index(reference_token));
12912 case detail::value_t::null:
12913 case detail::value_t::string:
12914 case detail::value_t::boolean:
12915 case detail::value_t::number_integer:
12916 case detail::value_t::number_unsigned:
12917 case detail::value_t::number_float:
12918 case detail::value_t::binary:
12919 case detail::value_t::discarded:
12921 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12941 const BasicJsonType& get_unchecked(
const BasicJsonType* ptr)
const
12943 for (
const auto& reference_token : reference_tokens)
12945 switch (ptr->type())
12947 case detail::value_t::object:
12950 ptr = &ptr->operator[](reference_token);
12954 case detail::value_t::array:
12956 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12959 JSON_THROW(detail::out_of_range::create(402,
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
") is out of range", *ptr));
12963 ptr = &ptr->operator[](array_index(reference_token));
12967 case detail::value_t::null:
12968 case detail::value_t::string:
12969 case detail::value_t::boolean:
12970 case detail::value_t::number_integer:
12971 case detail::value_t::number_unsigned:
12972 case detail::value_t::number_float:
12973 case detail::value_t::binary:
12974 case detail::value_t::discarded:
12976 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12989 const BasicJsonType& get_checked(
const BasicJsonType* ptr)
const
12991 for (
const auto& reference_token : reference_tokens)
12993 switch (ptr->type())
12995 case detail::value_t::object:
12998 ptr = &ptr->at(reference_token);
13002 case detail::value_t::array:
13004 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
13007 JSON_THROW(detail::out_of_range::create(402,
13008 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
13009 ") is out of range", *ptr));
13013 ptr = &ptr->at(array_index(reference_token));
13017 case detail::value_t::null:
13018 case detail::value_t::string:
13019 case detail::value_t::boolean:
13020 case detail::value_t::number_integer:
13021 case detail::value_t::number_unsigned:
13022 case detail::value_t::number_float:
13023 case detail::value_t::binary:
13024 case detail::value_t::discarded:
13026 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
13037 bool contains(
const BasicJsonType* ptr)
const
13039 for (
const auto& reference_token : reference_tokens)
13041 switch (ptr->type())
13043 case detail::value_t::object:
13045 if (!ptr->contains(reference_token))
13051 ptr = &ptr->operator[](reference_token);
13055 case detail::value_t::array:
13057 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
13062 if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !(
"0" <= reference_token && reference_token <=
"9")))
13067 if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
13069 if (JSON_HEDLEY_UNLIKELY(!(
'1' <= reference_token[0] && reference_token[0] <=
'9')))
13074 for (std::size_t i = 1; i < reference_token.size(); i++)
13076 if (JSON_HEDLEY_UNLIKELY(!(
'0' <= reference_token[i] && reference_token[i] <=
'9')))
13084 const auto idx = array_index(reference_token);
13085 if (idx >= ptr->size())
13091 ptr = &ptr->operator[](idx);
13095 case detail::value_t::null:
13096 case detail::value_t::string:
13097 case detail::value_t::boolean:
13098 case detail::value_t::number_integer:
13099 case detail::value_t::number_unsigned:
13100 case detail::value_t::number_float:
13101 case detail::value_t::binary:
13102 case detail::value_t::discarded:
13125 static std::vector<std::string> split(
const std::string& reference_string)
13127 std::vector<std::string> result;
13130 if (reference_string.empty())
13136 if (JSON_HEDLEY_UNLIKELY(reference_string[0] !=
'/'))
13138 JSON_THROW(detail::parse_error::create(107, 1,
"JSON pointer must be empty or begin with '/' - was: '" + reference_string +
"'", BasicJsonType()));
13146 std::size_t slash = reference_string.find_first_of(
'/', 1),
13153 start = (slash == std::string::npos) ? 0 : slash + 1,
13155 slash = reference_string.find_first_of(
'/', start))
13159 auto reference_token = reference_string.substr(start, slash - start);
13162 for (std::size_t pos = reference_token.find_first_of(
'~');
13163 pos != std::string::npos;
13164 pos = reference_token.find_first_of(
'~', pos + 1))
13166 JSON_ASSERT(reference_token[pos] ==
'~');
13169 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
13170 (reference_token[pos + 1] !=
'0' &&
13171 reference_token[pos + 1] !=
'1')))
13173 JSON_THROW(detail::parse_error::create(108, 0,
"escape character '~' must be followed with '0' or '1'", BasicJsonType()));
13178 detail::unescape(reference_token);
13179 result.push_back(reference_token);
13193 static void flatten(
const std::string& reference_string,
13194 const BasicJsonType& value,
13195 BasicJsonType& result)
13197 switch (value.type())
13199 case detail::value_t::array:
13201 if (value.m_value.array->empty())
13204 result[reference_string] =
nullptr;
13209 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
13211 flatten(reference_string +
"/" + std::to_string(i),
13212 value.m_value.array->operator[](i), result);
13218 case detail::value_t::object:
13220 if (value.m_value.object->empty())
13223 result[reference_string] =
nullptr;
13228 for (
const auto& element : *value.m_value.object)
13230 flatten(reference_string +
"/" + detail::escape(element.first), element.second, result);
13236 case detail::value_t::null:
13237 case detail::value_t::string:
13238 case detail::value_t::boolean:
13239 case detail::value_t::number_integer:
13240 case detail::value_t::number_unsigned:
13241 case detail::value_t::number_float:
13242 case detail::value_t::binary:
13243 case detail::value_t::discarded:
13247 result[reference_string] = value;
13263 static BasicJsonType
13264 unflatten(
const BasicJsonType& value)
13266 if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
13268 JSON_THROW(detail::type_error::create(314,
"only objects can be unflattened", value));
13271 BasicJsonType result;
13274 for (
const auto& element : *value.m_value.object)
13276 if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
13278 JSON_THROW(detail::type_error::create(315,
"values in object must be primitive", element.second));
13285 json_pointer(element.first).get_and_create(result) = element.second;
13305 return lhs.reference_tokens == rhs.reference_tokens;
13322 return !(lhs == rhs);
13326 std::vector<std::string> reference_tokens;
13333 #include <initializer_list>
13343 template<
typename BasicJsonType>
13347 using value_type = BasicJsonType;
13349 json_ref(value_type&& value)
13350 : owned_value(std::move(value))
13353 json_ref(
const value_type& value)
13354 : value_ref(&value)
13357 json_ref(std::initializer_list<json_ref> init)
13358 : owned_value(init)
13363 enable_if_t<std::is_constructible<value_type, Args...>::value,
int> = 0 >
13364 json_ref(Args && ... args)
13365 : owned_value(std::forward<Args>(args)...)
13369 json_ref(json_ref&&) noexcept = default;
13370 json_ref(const json_ref&) = delete;
13371 json_ref& operator=(const json_ref&) = delete;
13372 json_ref& operator=(json_ref&&) = delete;
13373 ~json_ref() = default;
13375 value_type moved_or_copied()
const
13377 if (value_ref ==
nullptr)
13379 return std::move(owned_value);
13384 value_type
const& operator*()
const
13386 return value_ref ? *value_ref : owned_value;
13389 value_type
const* operator->()
const
13395 mutable value_type owned_value =
nullptr;
13396 value_type
const* value_ref =
nullptr;
13412 #include <algorithm>
13428 #include <algorithm>
13430 #include <iterator>
13448 template<
typename CharType>
struct output_adapter_protocol
13450 virtual void write_character(CharType c) = 0;
13451 virtual void write_characters(
const CharType* s, std::size_t length) = 0;
13452 virtual ~output_adapter_protocol() =
default;
13454 output_adapter_protocol() =
default;
13455 output_adapter_protocol(
const output_adapter_protocol&) =
default;
13456 output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
13457 output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
13458 output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
13462 template<typename CharType>
13463 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
13466 template<typename CharType>
13467 class output_vector_adapter : public output_adapter_protocol<CharType>
13470 explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
13474 void write_character(CharType c)
override
13479 JSON_HEDLEY_NON_NULL(2)
13480 void write_characters(const CharType* s, std::
size_t length)
override
13482 std::copy(s, s + length, std::back_inserter(v));
13486 std::vector<CharType>& v;
13491 template<
typename CharType>
13492 class output_stream_adapter :
public output_adapter_protocol<CharType>
13495 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
13499 void write_character(CharType c)
override
13504 JSON_HEDLEY_NON_NULL(2)
13505 void write_characters(const CharType* s, std::
size_t length)
override
13507 stream.write(s,
static_cast<std::streamsize
>(length));
13511 std::basic_ostream<CharType>& stream;
13516 template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13517 class output_string_adapter :
public output_adapter_protocol<CharType>
13520 explicit output_string_adapter(StringType& s) noexcept
13524 void write_character(CharType c)
override
13529 JSON_HEDLEY_NON_NULL(2)
13530 void write_characters(const CharType* s, std::
size_t length)
override
13532 str.append(s, length);
13539 template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13540 class output_adapter
13543 output_adapter(std::vector<CharType>& vec)
13544 : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
13547 output_adapter(std::basic_ostream<CharType>& s)
13548 : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
13551 output_adapter(StringType& s)
13552 : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
13554 operator output_adapter_t<CharType>()
13560 output_adapter_t<CharType> oa =
nullptr;
13577 template<
typename BasicJsonType,
typename CharType>
13578 class binary_writer
13580 using string_t =
typename BasicJsonType::string_t;
13581 using binary_t =
typename BasicJsonType::binary_t;
13582 using number_float_t =
typename BasicJsonType::number_float_t;
13590 explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
13599 void write_bson(
const BasicJsonType& j)
13603 case value_t::object:
13605 write_bson_object(*j.m_value.object);
13609 case value_t::null:
13610 case value_t::array:
13611 case value_t::string:
13612 case value_t::boolean:
13613 case value_t::number_integer:
13614 case value_t::number_unsigned:
13615 case value_t::number_float:
13616 case value_t::binary:
13617 case value_t::discarded:
13620 JSON_THROW(type_error::create(317,
"to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));;
13628 void write_cbor(
const BasicJsonType& j)
13632 case value_t::null:
13634 oa->write_character(to_char_type(0xF6));
13638 case value_t::boolean:
13640 oa->write_character(j.m_value.boolean
13641 ? to_char_type(0xF5)
13642 : to_char_type(0xF4));
13646 case value_t::number_integer:
13648 if (j.m_value.number_integer >= 0)
13653 if (j.m_value.number_integer <= 0x17)
13655 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13657 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
13659 oa->write_character(to_char_type(0x18));
13660 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13662 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
13664 oa->write_character(to_char_type(0x19));
13665 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13667 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
13669 oa->write_character(to_char_type(0x1A));
13670 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13674 oa->write_character(to_char_type(0x1B));
13675 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13682 const auto positive_number = -1 - j.m_value.number_integer;
13683 if (j.m_value.number_integer >= -24)
13685 write_number(
static_cast<std::uint8_t
>(0x20 + positive_number));
13687 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
13689 oa->write_character(to_char_type(0x38));
13690 write_number(
static_cast<std::uint8_t
>(positive_number));
13692 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
13694 oa->write_character(to_char_type(0x39));
13695 write_number(
static_cast<std::uint16_t
>(positive_number));
13697 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
13699 oa->write_character(to_char_type(0x3A));
13700 write_number(
static_cast<std::uint32_t
>(positive_number));
13704 oa->write_character(to_char_type(0x3B));
13705 write_number(
static_cast<std::uint64_t
>(positive_number));
13711 case value_t::number_unsigned:
13713 if (j.m_value.number_unsigned <= 0x17)
13715 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13717 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13719 oa->write_character(to_char_type(0x18));
13720 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13722 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13724 oa->write_character(to_char_type(0x19));
13725 write_number(
static_cast<std::uint16_t
>(j.m_value.number_unsigned));
13727 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13729 oa->write_character(to_char_type(0x1A));
13730 write_number(
static_cast<std::uint32_t
>(j.m_value.number_unsigned));
13734 oa->write_character(to_char_type(0x1B));
13735 write_number(
static_cast<std::uint64_t
>(j.m_value.number_unsigned));
13740 case value_t::number_float:
13742 if (std::isnan(j.m_value.number_float))
13745 oa->write_character(to_char_type(0xF9));
13746 oa->write_character(to_char_type(0x7E));
13747 oa->write_character(to_char_type(0x00));
13749 else if (std::isinf(j.m_value.number_float))
13752 oa->write_character(to_char_type(0xf9));
13753 oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
13754 oa->write_character(to_char_type(0x00));
13758 write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
13763 case value_t::string:
13766 const auto N = j.m_value.string->size();
13769 write_number(
static_cast<std::uint8_t
>(0x60 + N));
13771 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13773 oa->write_character(to_char_type(0x78));
13774 write_number(
static_cast<std::uint8_t
>(N));
13776 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13778 oa->write_character(to_char_type(0x79));
13779 write_number(
static_cast<std::uint16_t
>(N));
13781 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13783 oa->write_character(to_char_type(0x7A));
13784 write_number(
static_cast<std::uint32_t
>(N));
13787 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13789 oa->write_character(to_char_type(0x7B));
13790 write_number(
static_cast<std::uint64_t
>(N));
13795 oa->write_characters(
13796 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13797 j.m_value.string->size());
13801 case value_t::array:
13804 const auto N = j.m_value.array->size();
13807 write_number(
static_cast<std::uint8_t
>(0x80 + N));
13809 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13811 oa->write_character(to_char_type(0x98));
13812 write_number(
static_cast<std::uint8_t
>(N));
13814 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13816 oa->write_character(to_char_type(0x99));
13817 write_number(
static_cast<std::uint16_t
>(N));
13819 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13821 oa->write_character(to_char_type(0x9A));
13822 write_number(
static_cast<std::uint32_t
>(N));
13825 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13827 oa->write_character(to_char_type(0x9B));
13828 write_number(
static_cast<std::uint64_t
>(N));
13833 for (
const auto& el : *j.m_value.array)
13840 case value_t::binary:
13842 if (j.m_value.binary->has_subtype())
13844 if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
13846 write_number(
static_cast<std::uint8_t
>(0xd8));
13847 write_number(
static_cast<std::uint8_t
>(j.m_value.binary->subtype()));
13849 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
13851 write_number(
static_cast<std::uint8_t
>(0xd9));
13852 write_number(
static_cast<std::uint16_t
>(j.m_value.binary->subtype()));
13854 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
13856 write_number(
static_cast<std::uint8_t
>(0xda));
13857 write_number(
static_cast<std::uint32_t
>(j.m_value.binary->subtype()));
13859 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
13861 write_number(
static_cast<std::uint8_t
>(0xdb));
13862 write_number(
static_cast<std::uint64_t
>(j.m_value.binary->subtype()));
13867 const auto N = j.m_value.binary->size();
13870 write_number(
static_cast<std::uint8_t
>(0x40 + N));
13872 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13874 oa->write_character(to_char_type(0x58));
13875 write_number(
static_cast<std::uint8_t
>(N));
13877 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13879 oa->write_character(to_char_type(0x59));
13880 write_number(
static_cast<std::uint16_t
>(N));
13882 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13884 oa->write_character(to_char_type(0x5A));
13885 write_number(
static_cast<std::uint32_t
>(N));
13888 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13890 oa->write_character(to_char_type(0x5B));
13891 write_number(
static_cast<std::uint64_t
>(N));
13896 oa->write_characters(
13897 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13903 case value_t::object:
13906 const auto N = j.m_value.object->size();
13909 write_number(
static_cast<std::uint8_t
>(0xA0 + N));
13911 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13913 oa->write_character(to_char_type(0xB8));
13914 write_number(
static_cast<std::uint8_t
>(N));
13916 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13918 oa->write_character(to_char_type(0xB9));
13919 write_number(
static_cast<std::uint16_t
>(N));
13921 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13923 oa->write_character(to_char_type(0xBA));
13924 write_number(
static_cast<std::uint32_t
>(N));
13927 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13929 oa->write_character(to_char_type(0xBB));
13930 write_number(
static_cast<std::uint64_t
>(N));
13935 for (
const auto& el : *j.m_value.object)
13937 write_cbor(el.first);
13938 write_cbor(el.second);
13943 case value_t::discarded:
13952 void write_msgpack(
const BasicJsonType& j)
13956 case value_t::null:
13958 oa->write_character(to_char_type(0xC0));
13962 case value_t::boolean:
13964 oa->write_character(j.m_value.boolean
13965 ? to_char_type(0xC3)
13966 : to_char_type(0xC2));
13970 case value_t::number_integer:
13972 if (j.m_value.number_integer >= 0)
13977 if (j.m_value.number_unsigned < 128)
13980 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13982 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13985 oa->write_character(to_char_type(0xCC));
13986 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13988 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13991 oa->write_character(to_char_type(0xCD));
13992 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13994 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13997 oa->write_character(to_char_type(0xCE));
13998 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
14000 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
14003 oa->write_character(to_char_type(0xCF));
14004 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
14009 if (j.m_value.number_integer >= -32)
14012 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
14014 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
14015 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
14018 oa->write_character(to_char_type(0xD0));
14019 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
14021 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
14022 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
14025 oa->write_character(to_char_type(0xD1));
14026 write_number(
static_cast<std::int16_t
>(j.m_value.number_integer));
14028 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
14029 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
14032 oa->write_character(to_char_type(0xD2));
14033 write_number(
static_cast<std::int32_t
>(j.m_value.number_integer));
14035 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
14036 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
14039 oa->write_character(to_char_type(0xD3));
14040 write_number(
static_cast<std::int64_t
>(j.m_value.number_integer));
14046 case value_t::number_unsigned:
14048 if (j.m_value.number_unsigned < 128)
14051 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14053 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
14056 oa->write_character(to_char_type(0xCC));
14057 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14059 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
14062 oa->write_character(to_char_type(0xCD));
14063 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
14065 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
14068 oa->write_character(to_char_type(0xCE));
14069 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
14071 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
14074 oa->write_character(to_char_type(0xCF));
14075 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
14080 case value_t::number_float:
14082 write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
14086 case value_t::string:
14089 const auto N = j.m_value.string->size();
14093 write_number(
static_cast<std::uint8_t
>(0xA0 | N));
14095 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
14098 oa->write_character(to_char_type(0xD9));
14099 write_number(
static_cast<std::uint8_t
>(N));
14101 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14104 oa->write_character(to_char_type(0xDA));
14105 write_number(
static_cast<std::uint16_t
>(N));
14107 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14110 oa->write_character(to_char_type(0xDB));
14111 write_number(
static_cast<std::uint32_t
>(N));
14115 oa->write_characters(
14116 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14117 j.m_value.string->size());
14121 case value_t::array:
14124 const auto N = j.m_value.array->size();
14128 write_number(
static_cast<std::uint8_t
>(0x90 | N));
14130 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14133 oa->write_character(to_char_type(0xDC));
14134 write_number(
static_cast<std::uint16_t
>(N));
14136 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14139 oa->write_character(to_char_type(0xDD));
14140 write_number(
static_cast<std::uint32_t
>(N));
14144 for (
const auto& el : *j.m_value.array)
14151 case value_t::binary:
14155 const bool use_ext = j.m_value.binary->has_subtype();
14158 const auto N = j.m_value.binary->size();
14159 if (N <= (std::numeric_limits<std::uint8_t>::max)())
14161 std::uint8_t output_type{};
14168 output_type = 0xD4;
14171 output_type = 0xD5;
14174 output_type = 0xD6;
14177 output_type = 0xD7;
14180 output_type = 0xD8;
14183 output_type = 0xC7;
14191 output_type = 0xC4;
14195 oa->write_character(to_char_type(output_type));
14198 write_number(
static_cast<std::uint8_t
>(N));
14201 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14203 std::uint8_t output_type = use_ext
14207 oa->write_character(to_char_type(output_type));
14208 write_number(
static_cast<std::uint16_t
>(N));
14210 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14212 std::uint8_t output_type = use_ext
14216 oa->write_character(to_char_type(output_type));
14217 write_number(
static_cast<std::uint32_t
>(N));
14223 write_number(
static_cast<std::int8_t
>(j.m_value.binary->subtype()));
14227 oa->write_characters(
14228 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14234 case value_t::object:
14237 const auto N = j.m_value.object->size();
14241 write_number(
static_cast<std::uint8_t
>(0x80 | (N & 0xF)));
14243 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14246 oa->write_character(to_char_type(0xDE));
14247 write_number(
static_cast<std::uint16_t
>(N));
14249 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14252 oa->write_character(to_char_type(0xDF));
14253 write_number(
static_cast<std::uint32_t
>(N));
14257 for (
const auto& el : *j.m_value.object)
14259 write_msgpack(el.first);
14260 write_msgpack(el.second);
14265 case value_t::discarded:
14277 void write_ubjson(
const BasicJsonType& j,
const bool use_count,
14278 const bool use_type,
const bool add_prefix =
true)
14282 case value_t::null:
14286 oa->write_character(to_char_type(
'Z'));
14291 case value_t::boolean:
14295 oa->write_character(j.m_value.boolean
14296 ? to_char_type(
'T')
14297 : to_char_type(
'F'));
14302 case value_t::number_integer:
14304 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
14308 case value_t::number_unsigned:
14310 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
14314 case value_t::number_float:
14316 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
14320 case value_t::string:
14324 oa->write_character(to_char_type(
'S'));
14326 write_number_with_ubjson_prefix(j.m_value.string->size(),
true);
14327 oa->write_characters(
14328 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14329 j.m_value.string->size());
14333 case value_t::array:
14337 oa->write_character(to_char_type(
'['));
14340 bool prefix_required =
true;
14341 if (use_type && !j.m_value.array->empty())
14343 JSON_ASSERT(use_count);
14344 const CharType first_prefix = ubjson_prefix(j.front());
14345 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
14346 [
this, first_prefix](
const BasicJsonType & v)
14348 return ubjson_prefix(v) == first_prefix;
14353 prefix_required =
false;
14354 oa->write_character(to_char_type(
'$'));
14355 oa->write_character(first_prefix);
14361 oa->write_character(to_char_type(
'#'));
14362 write_number_with_ubjson_prefix(j.m_value.array->size(),
true);
14365 for (
const auto& el : *j.m_value.array)
14367 write_ubjson(el, use_count, use_type, prefix_required);
14372 oa->write_character(to_char_type(
']'));
14378 case value_t::binary:
14382 oa->write_character(to_char_type(
'['));
14385 if (use_type && !j.m_value.binary->empty())
14387 JSON_ASSERT(use_count);
14388 oa->write_character(to_char_type(
'$'));
14389 oa->write_character(
'U');
14394 oa->write_character(to_char_type(
'#'));
14395 write_number_with_ubjson_prefix(j.m_value.binary->size(),
true);
14400 oa->write_characters(
14401 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14402 j.m_value.binary->size());
14406 for (
size_t i = 0; i < j.m_value.binary->size(); ++i)
14408 oa->write_character(to_char_type(
'U'));
14409 oa->write_character(j.m_value.binary->data()[i]);
14415 oa->write_character(to_char_type(
']'));
14421 case value_t::object:
14425 oa->write_character(to_char_type(
'{'));
14428 bool prefix_required =
true;
14429 if (use_type && !j.m_value.object->empty())
14431 JSON_ASSERT(use_count);
14432 const CharType first_prefix = ubjson_prefix(j.front());
14433 const bool same_prefix = std::all_of(j.begin(), j.end(),
14434 [
this, first_prefix](
const BasicJsonType & v)
14436 return ubjson_prefix(v) == first_prefix;
14441 prefix_required =
false;
14442 oa->write_character(to_char_type(
'$'));
14443 oa->write_character(first_prefix);
14449 oa->write_character(to_char_type(
'#'));
14450 write_number_with_ubjson_prefix(j.m_value.object->size(),
true);
14453 for (
const auto& el : *j.m_value.object)
14455 write_number_with_ubjson_prefix(el.first.size(),
true);
14456 oa->write_characters(
14457 reinterpret_cast<const CharType*
>(el.first.c_str()),
14459 write_ubjson(el.second, use_count, use_type, prefix_required);
14464 oa->write_character(to_char_type(
'}'));
14470 case value_t::discarded:
14485 static std::size_t calc_bson_entry_header_size(
const string_t& name,
const BasicJsonType& j)
14487 const auto it = name.find(
static_cast<typename string_t::value_type
>(0));
14488 if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
14490 JSON_THROW(out_of_range::create(409,
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) +
")", j));
14491 static_cast<void>(j);
14494 return 1ul + name.size() + 1u;
14500 void write_bson_entry_header(
const string_t& name,
14501 const std::uint8_t element_type)
14503 oa->write_character(to_char_type(element_type));
14504 oa->write_characters(
14505 reinterpret_cast<const CharType*
>(name.c_str()),
14512 void write_bson_boolean(
const string_t& name,
14515 write_bson_entry_header(name, 0x08);
14516 oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
14522 void write_bson_double(
const string_t& name,
14523 const double value)
14525 write_bson_entry_header(name, 0x01);
14526 write_number<double, true>(value);
14532 static std::size_t calc_bson_string_size(
const string_t& value)
14534 return sizeof(std::int32_t) + value.size() + 1ul;
14540 void write_bson_string(
const string_t& name,
14541 const string_t& value)
14543 write_bson_entry_header(name, 0x02);
14545 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size() + 1ul));
14546 oa->write_characters(
14547 reinterpret_cast<const CharType*
>(value.c_str()),
14554 void write_bson_null(
const string_t& name)
14556 write_bson_entry_header(name, 0x0A);
14562 static std::size_t calc_bson_integer_size(
const std::int64_t value)
14564 return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
14565 ?
sizeof(std::int32_t)
14566 :
sizeof(std::int64_t);
14572 void write_bson_integer(
const string_t& name,
14573 const std::int64_t value)
14575 if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
14577 write_bson_entry_header(name, 0x10);
14578 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value));
14582 write_bson_entry_header(name, 0x12);
14583 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(value));
14590 static constexpr std::size_t calc_bson_unsigned_size(
const std::uint64_t value) noexcept
14592 return (value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14593 ?
sizeof(std::int32_t)
14594 :
sizeof(std::int64_t);
14600 void write_bson_unsigned(
const string_t& name,
14601 const BasicJsonType& j)
14603 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14605 write_bson_entry_header(name, 0x10 );
14606 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(j.m_value.number_unsigned));
14608 else if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14610 write_bson_entry_header(name, 0x12 );
14611 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(j.m_value.number_unsigned));
14615 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));
14622 void write_bson_object_entry(
const string_t& name,
14623 const typename BasicJsonType::object_t& value)
14625 write_bson_entry_header(name, 0x03);
14626 write_bson_object(value);
14632 static std::size_t calc_bson_array_size(
const typename BasicJsonType::array_t& value)
14634 std::size_t array_index = 0ul;
14636 const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), std::size_t(0), [&array_index](std::size_t result,
const typename BasicJsonType::array_t::value_type & el)
14638 return result + calc_bson_element_size(std::to_string(array_index++), el);
14641 return sizeof(std::int32_t) + embedded_document_size + 1ul;
14647 static std::size_t calc_bson_binary_size(
const typename BasicJsonType::binary_t& value)
14649 return sizeof(std::int32_t) + value.size() + 1ul;
14655 void write_bson_array(
const string_t& name,
14656 const typename BasicJsonType::array_t& value)
14658 write_bson_entry_header(name, 0x04);
14659 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_array_size(value)));
14661 std::size_t array_index = 0ul;
14663 for (
const auto& el : value)
14665 write_bson_element(std::to_string(array_index++), el);
14668 oa->write_character(to_char_type(0x00));
14674 void write_bson_binary(
const string_t& name,
14675 const binary_t& value)
14677 write_bson_entry_header(name, 0x05);
14679 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size()));
14680 write_number(value.has_subtype() ?
static_cast<std::uint8_t
>(value.subtype()) : std::uint8_t(0x00));
14682 oa->write_characters(
reinterpret_cast<const CharType*
>(value.data()), value.size());
14689 static std::size_t calc_bson_element_size(
const string_t& name,
14690 const BasicJsonType& j)
14692 const auto header_size = calc_bson_entry_header_size(name, j);
14695 case value_t::object:
14696 return header_size + calc_bson_object_size(*j.m_value.object);
14698 case value_t::array:
14699 return header_size + calc_bson_array_size(*j.m_value.array);
14701 case value_t::binary:
14702 return header_size + calc_bson_binary_size(*j.m_value.binary);
14704 case value_t::boolean:
14705 return header_size + 1ul;
14707 case value_t::number_float:
14708 return header_size + 8ul;
14710 case value_t::number_integer:
14711 return header_size + calc_bson_integer_size(j.m_value.number_integer);
14713 case value_t::number_unsigned:
14714 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
14716 case value_t::string:
14717 return header_size + calc_bson_string_size(*j.m_value.string);
14719 case value_t::null:
14720 return header_size + 0ul;
14723 case value_t::discarded:
14725 JSON_ASSERT(
false);
14737 void write_bson_element(
const string_t& name,
14738 const BasicJsonType& j)
14742 case value_t::object:
14743 return write_bson_object_entry(name, *j.m_value.object);
14745 case value_t::array:
14746 return write_bson_array(name, *j.m_value.array);
14748 case value_t::binary:
14749 return write_bson_binary(name, *j.m_value.binary);
14751 case value_t::boolean:
14752 return write_bson_boolean(name, j.m_value.boolean);
14754 case value_t::number_float:
14755 return write_bson_double(name, j.m_value.number_float);
14757 case value_t::number_integer:
14758 return write_bson_integer(name, j.m_value.number_integer);
14760 case value_t::number_unsigned:
14761 return write_bson_unsigned(name, j);
14763 case value_t::string:
14764 return write_bson_string(name, *j.m_value.string);
14766 case value_t::null:
14767 return write_bson_null(name);
14770 case value_t::discarded:
14772 JSON_ASSERT(
false);
14784 static std::size_t calc_bson_object_size(
const typename BasicJsonType::object_t& value)
14786 std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
14787 [](
size_t result,
const typename BasicJsonType::object_t::value_type & el)
14789 return result += calc_bson_element_size(el.first, el.second);
14792 return sizeof(std::int32_t) + document_size + 1ul;
14799 void write_bson_object(
const typename BasicJsonType::object_t& value)
14801 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_object_size(value)));
14803 for (
const auto& el : value)
14805 write_bson_element(el.first, el.second);
14808 oa->write_character(to_char_type(0x00));
14815 static constexpr CharType get_cbor_float_prefix(
float )
14817 return to_char_type(0xFA);
14820 static constexpr CharType get_cbor_float_prefix(
double )
14822 return to_char_type(0xFB);
14829 static constexpr CharType get_msgpack_float_prefix(
float )
14831 return to_char_type(0xCA);
14834 static constexpr CharType get_msgpack_float_prefix(
double )
14836 return to_char_type(0xCB);
14844 template<
typename NumberType,
typename std::enable_if<
14845 std::is_floating_point<NumberType>::value,
int>::type = 0>
14846 void write_number_with_ubjson_prefix(
const NumberType n,
14847 const bool add_prefix)
14851 oa->write_character(get_ubjson_float_prefix(n));
14857 template<
typename NumberType,
typename std::enable_if<
14858 std::is_unsigned<NumberType>::value,
int>::type = 0>
14859 void write_number_with_ubjson_prefix(
const NumberType n,
14860 const bool add_prefix)
14862 if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14866 oa->write_character(to_char_type(
'i'));
14868 write_number(
static_cast<std::uint8_t
>(n));
14870 else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14874 oa->write_character(to_char_type(
'U'));
14876 write_number(
static_cast<std::uint8_t
>(n));
14878 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14882 oa->write_character(to_char_type(
'I'));
14884 write_number(
static_cast<std::int16_t
>(n));
14886 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14890 oa->write_character(to_char_type(
'l'));
14892 write_number(
static_cast<std::int32_t
>(n));
14894 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14898 oa->write_character(to_char_type(
'L'));
14900 write_number(
static_cast<std::int64_t
>(n));
14906 oa->write_character(to_char_type(
'H'));
14909 const auto number = BasicJsonType(n).dump();
14910 write_number_with_ubjson_prefix(number.size(),
true);
14911 for (std::size_t i = 0; i < number.size(); ++i)
14913 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14919 template <
typename NumberType,
typename std::enable_if <
14920 std::is_signed<NumberType>::value&&
14921 !std::is_floating_point<NumberType>::value,
int >::type = 0 >
14922 void write_number_with_ubjson_prefix(
const NumberType n,
14923 const bool add_prefix)
14925 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14929 oa->write_character(to_char_type(
'i'));
14931 write_number(
static_cast<std::int8_t
>(n));
14933 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)()))
14937 oa->write_character(to_char_type(
'U'));
14939 write_number(
static_cast<std::uint8_t
>(n));
14941 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14945 oa->write_character(to_char_type(
'I'));
14947 write_number(
static_cast<std::int16_t
>(n));
14949 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14953 oa->write_character(to_char_type(
'l'));
14955 write_number(
static_cast<std::int32_t
>(n));
14957 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14961 oa->write_character(to_char_type(
'L'));
14963 write_number(
static_cast<std::int64_t
>(n));
14970 oa->write_character(to_char_type(
'H'));
14973 const auto number = BasicJsonType(n).dump();
14974 write_number_with_ubjson_prefix(number.size(),
true);
14975 for (std::size_t i = 0; i < number.size(); ++i)
14977 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14986 CharType ubjson_prefix(
const BasicJsonType& j)
const noexcept
14990 case value_t::null:
14993 case value_t::boolean:
14994 return j.m_value.boolean ?
'T' :
'F';
14996 case value_t::number_integer:
14998 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)())
15002 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)())
15006 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)())
15010 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)())
15014 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)())
15022 case value_t::number_unsigned:
15024 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
15028 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::uint8_t>::max)()))
15032 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
15036 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
15040 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
15048 case value_t::number_float:
15049 return get_ubjson_float_prefix(j.m_value.number_float);
15051 case value_t::string:
15054 case value_t::array:
15055 case value_t::binary:
15058 case value_t::object:
15061 case value_t::discarded:
15067 static constexpr CharType get_ubjson_float_prefix(
float )
15072 static constexpr CharType get_ubjson_float_prefix(
double )
15092 template<
typename NumberType,
bool OutputIsLittleEndian = false>
15093 void write_number(
const NumberType n)
15096 std::array<CharType,
sizeof(NumberType)> vec{};
15097 std::memcpy(vec.data(), &n,
sizeof(NumberType));
15100 if (is_little_endian != OutputIsLittleEndian)
15103 std::reverse(vec.begin(), vec.end());
15106 oa->write_characters(vec.data(),
sizeof(NumberType));
15109 void write_compact_float(
const number_float_t n, detail::input_format_t format)
15112 #pragma GCC diagnostic push
15113 #pragma GCC diagnostic ignored "-Wfloat-equal"
15115 if (
static_cast<double>(n) >=
static_cast<double>(std::numeric_limits<float>::lowest()) &&
15116 static_cast<double>(n) <=
static_cast<double>((std::numeric_limits<float>::max)()) &&
15117 static_cast<double>(
static_cast<float>(n)) ==
static_cast<double>(n))
15119 oa->write_character(format == detail::input_format_t::cbor
15120 ? get_cbor_float_prefix(
static_cast<float>(n))
15121 : get_msgpack_float_prefix(
static_cast<float>(n)));
15122 write_number(
static_cast<float>(n));
15126 oa->write_character(format == detail::input_format_t::cbor
15127 ? get_cbor_float_prefix(n)
15128 : get_msgpack_float_prefix(n));
15132 #pragma GCC diagnostic pop
15141 template <
typename C = CharType,
15142 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * =
nullptr >
15143 static constexpr CharType to_char_type(std::uint8_t x) noexcept
15145 return *
reinterpret_cast<char*
>(&x);
15148 template <
typename C = CharType,
15149 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * =
nullptr >
15150 static CharType to_char_type(std::uint8_t x) noexcept
15152 static_assert(
sizeof(std::uint8_t) ==
sizeof(CharType),
"size of CharType must be equal to std::uint8_t");
15153 static_assert(std::is_trivial<CharType>::value,
"CharType must be trivial");
15155 std::memcpy(&result, &x,
sizeof(x));
15159 template<
typename C = CharType,
15160 enable_if_t<std::is_unsigned<C>::value>* =
nullptr>
15161 static constexpr CharType to_char_type(std::uint8_t x) noexcept
15166 template <
typename InputCharType,
typename C = CharType,
15168 std::is_signed<C>::value &&
15169 std::is_signed<char>::value &&
15170 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
15172 static constexpr CharType to_char_type(InputCharType x) noexcept
15179 const bool is_little_endian = little_endianess();
15182 output_adapter_t<CharType> oa =
nullptr;
15192 #include <algorithm>
15201 #include <type_traits>
15212 #include <type_traits>
15241 namespace dtoa_impl
15244 template<
typename Target,
typename Source>
15245 Target reinterpret_bits(
const Source source)
15247 static_assert(
sizeof(Target) ==
sizeof(Source),
"size mismatch");
15250 std::memcpy(&target, &source,
sizeof(Source));
15256 static constexpr
int kPrecision = 64;
15258 std::uint64_t f = 0;
15261 constexpr diyfp(std::uint64_t f_,
int e_) noexcept : f(f_), e(e_) {}
15267 static diyfp sub(
const diyfp& x,
const diyfp& y) noexcept
15269 JSON_ASSERT(x.e == y.e);
15270 JSON_ASSERT(x.f >= y.f);
15272 return {x.f - y.f, x.e};
15279 static diyfp mul(
const diyfp& x,
const diyfp& y) noexcept
15281 static_assert(kPrecision == 64,
"internal error");
15306 const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
15307 const std::uint64_t u_hi = x.f >> 32u;
15308 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
15309 const std::uint64_t v_hi = y.f >> 32u;
15311 const std::uint64_t p0 = u_lo * v_lo;
15312 const std::uint64_t p1 = u_lo * v_hi;
15313 const std::uint64_t p2 = u_hi * v_lo;
15314 const std::uint64_t p3 = u_hi * v_hi;
15316 const std::uint64_t p0_hi = p0 >> 32u;
15317 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
15318 const std::uint64_t p1_hi = p1 >> 32u;
15319 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
15320 const std::uint64_t p2_hi = p2 >> 32u;
15322 std::uint64_t Q = p0_hi + p1_lo + p2_lo;
15333 Q += std::uint64_t{1} << (64u - 32u - 1u);
15335 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
15337 return {h, x.e + y.e + 64};
15344 static diyfp normalize(diyfp x) noexcept
15346 JSON_ASSERT(x.f != 0);
15348 while ((x.f >> 63u) == 0)
15361 static diyfp normalize_to(
const diyfp& x,
const int target_exponent) noexcept
15363 const int delta = x.e - target_exponent;
15365 JSON_ASSERT(delta >= 0);
15366 JSON_ASSERT(((x.f << delta) >> delta) == x.f);
15368 return {x.f << delta, target_exponent};
15385 template<
typename FloatType>
15386 boundaries compute_boundaries(FloatType value)
15388 JSON_ASSERT(std::isfinite(value));
15389 JSON_ASSERT(value > 0);
15398 static_assert(std::numeric_limits<FloatType>::is_iec559,
15399 "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
15401 constexpr
int kPrecision = std::numeric_limits<FloatType>::digits;
15402 constexpr
int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
15403 constexpr
int kMinExp = 1 - kBias;
15404 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1);
15406 using bits_type =
typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
15408 const auto bits =
static_cast<std::uint64_t
>(reinterpret_bits<bits_type>(value));
15409 const std::uint64_t E = bits >> (kPrecision - 1);
15410 const std::uint64_t F = bits & (kHiddenBit - 1);
15412 const bool is_denormal = E == 0;
15413 const diyfp v = is_denormal
15414 ? diyfp(F, kMinExp)
15415 : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
15438 const bool lower_boundary_is_closer = F == 0 && E > 1;
15439 const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
15440 const diyfp m_minus = lower_boundary_is_closer
15441 ? diyfp(4 * v.f - 1, v.e - 2)
15442 : diyfp(2 * v.f - 1, v.e - 1);
15445 const diyfp w_plus = diyfp::normalize(m_plus);
15448 const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
15450 return {diyfp::normalize(v), w_minus, w_plus};
15508 constexpr
int kAlpha = -60;
15509 constexpr
int kGamma = -32;
15511 struct cached_power
15525 inline cached_power get_cached_power_for_binary_exponent(
int e)
15577 constexpr
int kCachedPowersMinDecExp = -300;
15578 constexpr
int kCachedPowersDecStep = 8;
15580 static constexpr std::array<cached_power, 79> kCachedPowers =
15583 { 0xAB70FE17C79AC6CA, -1060, -300 },
15584 { 0xFF77B1FCBEBCDC4F, -1034, -292 },
15585 { 0xBE5691EF416BD60C, -1007, -284 },
15586 { 0x8DD01FAD907FFC3C, -980, -276 },
15587 { 0xD3515C2831559A83, -954, -268 },
15588 { 0x9D71AC8FADA6C9B5, -927, -260 },
15589 { 0xEA9C227723EE8BCB, -901, -252 },
15590 { 0xAECC49914078536D, -874, -244 },
15591 { 0x823C12795DB6CE57, -847, -236 },
15592 { 0xC21094364DFB5637, -821, -228 },
15593 { 0x9096EA6F3848984F, -794, -220 },
15594 { 0xD77485CB25823AC7, -768, -212 },
15595 { 0xA086CFCD97BF97F4, -741, -204 },
15596 { 0xEF340A98172AACE5, -715, -196 },
15597 { 0xB23867FB2A35B28E, -688, -188 },
15598 { 0x84C8D4DFD2C63F3B, -661, -180 },
15599 { 0xC5DD44271AD3CDBA, -635, -172 },
15600 { 0x936B9FCEBB25C996, -608, -164 },
15601 { 0xDBAC6C247D62A584, -582, -156 },
15602 { 0xA3AB66580D5FDAF6, -555, -148 },
15603 { 0xF3E2F893DEC3F126, -529, -140 },
15604 { 0xB5B5ADA8AAFF80B8, -502, -132 },
15605 { 0x87625F056C7C4A8B, -475, -124 },
15606 { 0xC9BCFF6034C13053, -449, -116 },
15607 { 0x964E858C91BA2655, -422, -108 },
15608 { 0xDFF9772470297EBD, -396, -100 },
15609 { 0xA6DFBD9FB8E5B88F, -369, -92 },
15610 { 0xF8A95FCF88747D94, -343, -84 },
15611 { 0xB94470938FA89BCF, -316, -76 },
15612 { 0x8A08F0F8BF0F156B, -289, -68 },
15613 { 0xCDB02555653131B6, -263, -60 },
15614 { 0x993FE2C6D07B7FAC, -236, -52 },
15615 { 0xE45C10C42A2B3B06, -210, -44 },
15616 { 0xAA242499697392D3, -183, -36 },
15617 { 0xFD87B5F28300CA0E, -157, -28 },
15618 { 0xBCE5086492111AEB, -130, -20 },
15619 { 0x8CBCCC096F5088CC, -103, -12 },
15620 { 0xD1B71758E219652C, -77, -4 },
15621 { 0x9C40000000000000, -50, 4 },
15622 { 0xE8D4A51000000000, -24, 12 },
15623 { 0xAD78EBC5AC620000, 3, 20 },
15624 { 0x813F3978F8940984, 30, 28 },
15625 { 0xC097CE7BC90715B3, 56, 36 },
15626 { 0x8F7E32CE7BEA5C70, 83, 44 },
15627 { 0xD5D238A4ABE98068, 109, 52 },
15628 { 0x9F4F2726179A2245, 136, 60 },
15629 { 0xED63A231D4C4FB27, 162, 68 },
15630 { 0xB0DE65388CC8ADA8, 189, 76 },
15631 { 0x83C7088E1AAB65DB, 216, 84 },
15632 { 0xC45D1DF942711D9A, 242, 92 },
15633 { 0x924D692CA61BE758, 269, 100 },
15634 { 0xDA01EE641A708DEA, 295, 108 },
15635 { 0xA26DA3999AEF774A, 322, 116 },
15636 { 0xF209787BB47D6B85, 348, 124 },
15637 { 0xB454E4A179DD1877, 375, 132 },
15638 { 0x865B86925B9BC5C2, 402, 140 },
15639 { 0xC83553C5C8965D3D, 428, 148 },
15640 { 0x952AB45CFA97A0B3, 455, 156 },
15641 { 0xDE469FBD99A05FE3, 481, 164 },
15642 { 0xA59BC234DB398C25, 508, 172 },
15643 { 0xF6C69A72A3989F5C, 534, 180 },
15644 { 0xB7DCBF5354E9BECE, 561, 188 },
15645 { 0x88FCF317F22241E2, 588, 196 },
15646 { 0xCC20CE9BD35C78A5, 614, 204 },
15647 { 0x98165AF37B2153DF, 641, 212 },
15648 { 0xE2A0B5DC971F303A, 667, 220 },
15649 { 0xA8D9D1535CE3B396, 694, 228 },
15650 { 0xFB9B7CD9A4A7443C, 720, 236 },
15651 { 0xBB764C4CA7A44410, 747, 244 },
15652 { 0x8BAB8EEFB6409C1A, 774, 252 },
15653 { 0xD01FEF10A657842C, 800, 260 },
15654 { 0x9B10A4E5E9913129, 827, 268 },
15655 { 0xE7109BFBA19C0C9D, 853, 276 },
15656 { 0xAC2820D9623BF429, 880, 284 },
15657 { 0x80444B5E7AA7CF85, 907, 292 },
15658 { 0xBF21E44003ACDD2D, 933, 300 },
15659 { 0x8E679C2F5E44FF8F, 960, 308 },
15660 { 0xD433179D9C8CB841, 986, 316 },
15661 { 0x9E19DB92B4E31BA9, 1013, 324 },
15669 JSON_ASSERT(e >= -1500);
15670 JSON_ASSERT(e <= 1500);
15671 const int f = kAlpha - e - 1;
15672 const int k = (f * 78913) / (1 << 18) +
static_cast<int>(f > 0);
15674 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
15675 JSON_ASSERT(index >= 0);
15676 JSON_ASSERT(
static_cast<std::size_t
>(index) < kCachedPowers.size());
15678 const cached_power cached = kCachedPowers[
static_cast<std::size_t
>(index)];
15679 JSON_ASSERT(kAlpha <= cached.e + e + 64);
15680 JSON_ASSERT(kGamma >= cached.e + e + 64);
15689 inline int find_largest_pow10(
const std::uint32_t n, std::uint32_t& pow10)
15692 if (n >= 1000000000)
15694 pow10 = 1000000000;
15698 if (n >= 100000000)
15743 inline void grisu2_round(
char* buf,
int len, std::uint64_t dist, std::uint64_t delta,
15744 std::uint64_t rest, std::uint64_t ten_k)
15746 JSON_ASSERT(len >= 1);
15747 JSON_ASSERT(dist <= delta);
15748 JSON_ASSERT(rest <= delta);
15749 JSON_ASSERT(ten_k > 0);
15771 && delta - rest >= ten_k
15772 && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
15774 JSON_ASSERT(buf[len - 1] !=
'0');
15784 inline void grisu2_digit_gen(
char* buffer,
int& length,
int& decimal_exponent,
15785 diyfp M_minus, diyfp w, diyfp M_plus)
15787 static_assert(kAlpha >= -60,
"internal error");
15788 static_assert(kGamma <= -32,
"internal error");
15802 JSON_ASSERT(M_plus.e >= kAlpha);
15803 JSON_ASSERT(M_plus.e <= kGamma);
15805 std::uint64_t delta = diyfp::sub(M_plus, M_minus).f;
15806 std::uint64_t dist = diyfp::sub(M_plus, w ).f;
15815 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
15817 auto p1 =
static_cast<std::uint32_t
>(M_plus.f >> -one.e);
15818 std::uint64_t p2 = M_plus.f & (one.f - 1);
15824 JSON_ASSERT(p1 > 0);
15826 std::uint32_t pow10{};
15827 const int k = find_largest_pow10(p1, pow10);
15854 const std::uint32_t d = p1 / pow10;
15855 const std::uint32_t r = p1 % pow10;
15860 JSON_ASSERT(d <= 9);
15861 buffer[length++] =
static_cast<char>(
'0' + d);
15880 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15885 decimal_exponent += n;
15896 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15897 grisu2_round(buffer, length, dist, delta, rest, ten_n);
15947 JSON_ASSERT(p2 > delta);
15958 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15960 const std::uint64_t d = p2 >> -one.e;
15961 const std::uint64_t r = p2 & (one.f - 1);
15967 JSON_ASSERT(d <= 9);
15968 buffer[length++] =
static_cast<char>(
'0' + d);
15993 decimal_exponent -= m;
16001 const std::uint64_t ten_m = one.f;
16002 grisu2_round(buffer, length, dist, delta, p2, ten_m);
16024 JSON_HEDLEY_NON_NULL(1)
16025 inline
void grisu2(
char* buf,
int& len,
int& decimal_exponent,
16026 diyfp m_minus, diyfp v, diyfp m_plus)
16028 JSON_ASSERT(m_plus.e == m_minus.e);
16029 JSON_ASSERT(m_plus.e == v.e);
16040 const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
16042 const diyfp c_minus_k(cached.f, cached.e);
16045 const diyfp w = diyfp::mul(v, c_minus_k);
16046 const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
16047 const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
16070 const diyfp M_minus(w_minus.f + 1, w_minus.e);
16071 const diyfp M_plus (w_plus.f - 1, w_plus.e );
16073 decimal_exponent = -cached.k;
16075 grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
16083 template<
typename FloatType>
16084 JSON_HEDLEY_NON_NULL(1)
16085 void grisu2(
char* buf,
int& len,
int& decimal_exponent, FloatType value)
16087 static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
16088 "internal error: not enough precision");
16090 JSON_ASSERT(std::isfinite(value));
16091 JSON_ASSERT(value > 0);
16110 const boundaries w = compute_boundaries(
static_cast<double>(value));
16112 const boundaries w = compute_boundaries(value);
16115 grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
16123 JSON_HEDLEY_NON_NULL(1)
16125 inline
char* append_exponent(
char* buf,
int e)
16127 JSON_ASSERT(e > -1000);
16128 JSON_ASSERT(e < 1000);
16140 auto k =
static_cast<std::uint32_t
>(e);
16146 *buf++ =
static_cast<char>(
'0' + k);
16150 *buf++ =
static_cast<char>(
'0' + k / 10);
16152 *buf++ =
static_cast<char>(
'0' + k);
16156 *buf++ =
static_cast<char>(
'0' + k / 100);
16158 *buf++ =
static_cast<char>(
'0' + k / 10);
16160 *buf++ =
static_cast<char>(
'0' + k);
16175 JSON_HEDLEY_NON_NULL(1)
16177 inline
char* format_buffer(
char* buf,
int len,
int decimal_exponent,
16178 int min_exp,
int max_exp)
16180 JSON_ASSERT(min_exp < 0);
16181 JSON_ASSERT(max_exp > 0);
16184 const int n = len + decimal_exponent;
16190 if (k <= n && n <= max_exp)
16195 std::memset(buf + k,
'0',
static_cast<size_t>(n) -
static_cast<size_t>(k));
16199 return buf + (
static_cast<size_t>(n) + 2);
16202 if (0 < n && n <= max_exp)
16207 JSON_ASSERT(k > n);
16209 std::memmove(buf + (
static_cast<size_t>(n) + 1), buf + n,
static_cast<size_t>(k) -
static_cast<size_t>(n));
16211 return buf + (
static_cast<size_t>(k) + 1U);
16214 if (min_exp < n && n <= 0)
16219 std::memmove(buf + (2 +
static_cast<size_t>(-n)), buf,
static_cast<size_t>(k));
16222 std::memset(buf + 2,
'0',
static_cast<size_t>(-n));
16223 return buf + (2U +
static_cast<size_t>(-n) +
static_cast<size_t>(k));
16238 std::memmove(buf + 2, buf + 1,
static_cast<size_t>(k) - 1);
16240 buf += 1 +
static_cast<size_t>(k);
16244 return append_exponent(buf, n - 1);
16259 template<
typename FloatType>
16260 JSON_HEDLEY_NON_NULL(1, 2)
16262 char* to_chars(
char* first, const
char* last, FloatType value)
16264 static_cast<void>(last);
16265 JSON_ASSERT(std::isfinite(value));
16268 if (std::signbit(value))
16275 #pragma GCC diagnostic push
16276 #pragma GCC diagnostic ignored "-Wfloat-equal"
16287 #pragma GCC diagnostic pop
16290 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
16297 int decimal_exponent = 0;
16298 dtoa_impl::grisu2(first, len, decimal_exponent, value);
16300 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
16303 constexpr
int kMinExp = -4;
16305 constexpr
int kMaxExp = std::numeric_limits<FloatType>::digits10;
16307 JSON_ASSERT(last - first >= kMaxExp + 2);
16308 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
16309 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
16311 return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
16339 enum class error_handler_t
16346 template<
typename BasicJsonType>
16349 using string_t =
typename BasicJsonType::string_t;
16350 using number_float_t =
typename BasicJsonType::number_float_t;
16351 using number_integer_t =
typename BasicJsonType::number_integer_t;
16352 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
16353 using binary_char_t =
typename BasicJsonType::binary_t::value_type;
16354 static constexpr std::uint8_t UTF8_ACCEPT = 0;
16355 static constexpr std::uint8_t UTF8_REJECT = 1;
16363 serializer(output_adapter_t<char> s,
const char ichar,
16364 error_handler_t error_handler_ = error_handler_t::strict)
16366 , loc(std::localeconv())
16367 , thousands_sep(loc->thousands_sep == nullptr ?
'\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
16368 , decimal_point(loc->decimal_point == nullptr ?
'\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
16369 , indent_char(ichar)
16370 , indent_string(512, indent_char)
16371 , error_handler(error_handler_)
16375 serializer(
const serializer&) =
delete;
16376 serializer& operator=(
const serializer&) =
delete;
16377 serializer(serializer&&) =
delete;
16378 serializer& operator=(serializer&&) =
delete;
16379 ~serializer() =
default;
16403 void dump(
const BasicJsonType& val,
16404 const bool pretty_print,
16405 const bool ensure_ascii,
16406 const unsigned int indent_step,
16407 const unsigned int current_indent = 0)
16409 switch (val.m_type)
16411 case value_t::object:
16413 if (val.m_value.object->empty())
16415 o->write_characters(
"{}", 2);
16421 o->write_characters(
"{\n", 2);
16424 const auto new_indent = current_indent + indent_step;
16425 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16427 indent_string.resize(indent_string.size() * 2,
' ');
16431 auto i = val.m_value.object->cbegin();
16432 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16434 o->write_characters(indent_string.c_str(), new_indent);
16435 o->write_character(
'\"');
16436 dump_escaped(i->first, ensure_ascii);
16437 o->write_characters(
"\": ", 3);
16438 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
16439 o->write_characters(
",\n", 2);
16443 JSON_ASSERT(i != val.m_value.object->cend());
16444 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16445 o->write_characters(indent_string.c_str(), new_indent);
16446 o->write_character(
'\"');
16447 dump_escaped(i->first, ensure_ascii);
16448 o->write_characters(
"\": ", 3);
16449 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
16451 o->write_character(
'\n');
16452 o->write_characters(indent_string.c_str(), current_indent);
16453 o->write_character(
'}');
16457 o->write_character(
'{');
16460 auto i = val.m_value.object->cbegin();
16461 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16463 o->write_character(
'\"');
16464 dump_escaped(i->first, ensure_ascii);
16465 o->write_characters(
"\":", 2);
16466 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
16467 o->write_character(
',');
16471 JSON_ASSERT(i != val.m_value.object->cend());
16472 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16473 o->write_character(
'\"');
16474 dump_escaped(i->first, ensure_ascii);
16475 o->write_characters(
"\":", 2);
16476 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
16478 o->write_character(
'}');
16484 case value_t::array:
16486 if (val.m_value.array->empty())
16488 o->write_characters(
"[]", 2);
16494 o->write_characters(
"[\n", 2);
16497 const auto new_indent = current_indent + indent_step;
16498 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16500 indent_string.resize(indent_string.size() * 2,
' ');
16504 for (
auto i = val.m_value.array->cbegin();
16505 i != val.m_value.array->cend() - 1; ++i)
16507 o->write_characters(indent_string.c_str(), new_indent);
16508 dump(*i,
true, ensure_ascii, indent_step, new_indent);
16509 o->write_characters(
",\n", 2);
16513 JSON_ASSERT(!val.m_value.array->empty());
16514 o->write_characters(indent_string.c_str(), new_indent);
16515 dump(val.m_value.array->back(),
true, ensure_ascii, indent_step, new_indent);
16517 o->write_character(
'\n');
16518 o->write_characters(indent_string.c_str(), current_indent);
16519 o->write_character(
']');
16523 o->write_character(
'[');
16526 for (
auto i = val.m_value.array->cbegin();
16527 i != val.m_value.array->cend() - 1; ++i)
16529 dump(*i,
false, ensure_ascii, indent_step, current_indent);
16530 o->write_character(
',');
16534 JSON_ASSERT(!val.m_value.array->empty());
16535 dump(val.m_value.array->back(),
false, ensure_ascii, indent_step, current_indent);
16537 o->write_character(
']');
16543 case value_t::string:
16545 o->write_character(
'\"');
16546 dump_escaped(*val.m_value.string, ensure_ascii);
16547 o->write_character(
'\"');
16551 case value_t::binary:
16555 o->write_characters(
"{\n", 2);
16558 const auto new_indent = current_indent + indent_step;
16559 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16561 indent_string.resize(indent_string.size() * 2,
' ');
16564 o->write_characters(indent_string.c_str(), new_indent);
16566 o->write_characters(
"\"bytes\": [", 10);
16568 if (!val.m_value.binary->empty())
16570 for (
auto i = val.m_value.binary->cbegin();
16571 i != val.m_value.binary->cend() - 1; ++i)
16574 o->write_characters(
", ", 2);
16576 dump_integer(val.m_value.binary->back());
16579 o->write_characters(
"],\n", 3);
16580 o->write_characters(indent_string.c_str(), new_indent);
16582 o->write_characters(
"\"subtype\": ", 11);
16583 if (val.m_value.binary->has_subtype())
16585 dump_integer(val.m_value.binary->subtype());
16589 o->write_characters(
"null", 4);
16591 o->write_character(
'\n');
16592 o->write_characters(indent_string.c_str(), current_indent);
16593 o->write_character(
'}');
16597 o->write_characters(
"{\"bytes\":[", 10);
16599 if (!val.m_value.binary->empty())
16601 for (
auto i = val.m_value.binary->cbegin();
16602 i != val.m_value.binary->cend() - 1; ++i)
16605 o->write_character(
',');
16607 dump_integer(val.m_value.binary->back());
16610 o->write_characters(
"],\"subtype\":", 12);
16611 if (val.m_value.binary->has_subtype())
16613 dump_integer(val.m_value.binary->subtype());
16614 o->write_character(
'}');
16618 o->write_characters(
"null}", 5);
16624 case value_t::boolean:
16626 if (val.m_value.boolean)
16628 o->write_characters(
"true", 4);
16632 o->write_characters(
"false", 5);
16637 case value_t::number_integer:
16639 dump_integer(val.m_value.number_integer);
16643 case value_t::number_unsigned:
16645 dump_integer(val.m_value.number_unsigned);
16649 case value_t::number_float:
16651 dump_float(val.m_value.number_float);
16655 case value_t::discarded:
16657 o->write_characters(
"<discarded>", 11);
16661 case value_t::null:
16663 o->write_characters(
"null", 4);
16668 JSON_ASSERT(
false);
16672 JSON_PRIVATE_UNLESS_TESTED:
16687 void dump_escaped(
const string_t& s,
const bool ensure_ascii)
16689 std::uint32_t codepoint{};
16690 std::uint8_t state = UTF8_ACCEPT;
16691 std::size_t bytes = 0;
16694 std::size_t bytes_after_last_accept = 0;
16695 std::size_t undumped_chars = 0;
16697 for (std::size_t i = 0; i < s.size(); ++i)
16699 const auto byte =
static_cast<std::uint8_t
>(s[i]);
16701 switch (decode(state, codepoint,
byte))
16709 string_buffer[bytes++] =
'\\';
16710 string_buffer[bytes++] =
'b';
16716 string_buffer[bytes++] =
'\\';
16717 string_buffer[bytes++] =
't';
16723 string_buffer[bytes++] =
'\\';
16724 string_buffer[bytes++] =
'n';
16730 string_buffer[bytes++] =
'\\';
16731 string_buffer[bytes++] =
'f';
16737 string_buffer[bytes++] =
'\\';
16738 string_buffer[bytes++] =
'r';
16744 string_buffer[bytes++] =
'\\';
16745 string_buffer[bytes++] =
'\"';
16751 string_buffer[bytes++] =
'\\';
16752 string_buffer[bytes++] =
'\\';
16760 if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
16762 if (codepoint <= 0xFFFF)
16765 (std::snprintf)(string_buffer.data() + bytes, 7,
"\\u%04x",
16766 static_cast<std::uint16_t
>(codepoint));
16772 (std::snprintf)(string_buffer.data() + bytes, 13,
"\\u%04x\\u%04x",
16773 static_cast<std::uint16_t
>(0xD7C0u + (codepoint >> 10u)),
16774 static_cast<std::uint16_t
>(0xDC00u + (codepoint & 0x3FFu)));
16782 string_buffer[bytes++] = s[i];
16791 if (string_buffer.size() - bytes < 13)
16793 o->write_characters(string_buffer.data(), bytes);
16798 bytes_after_last_accept = bytes;
16799 undumped_chars = 0;
16805 switch (error_handler)
16807 case error_handler_t::strict:
16809 std::string sn(9,
'\0');
16811 (std::snprintf)(&sn[0], sn.size(),
"%.2X", byte);
16812 JSON_THROW(type_error::create(316,
"invalid UTF-8 byte at index " + std::to_string(i) +
": 0x" + sn, BasicJsonType()));
16815 case error_handler_t::ignore:
16816 case error_handler_t::replace:
16822 if (undumped_chars > 0)
16829 bytes = bytes_after_last_accept;
16831 if (error_handler == error_handler_t::replace)
16836 string_buffer[bytes++] =
'\\';
16837 string_buffer[bytes++] =
'u';
16838 string_buffer[bytes++] =
'f';
16839 string_buffer[bytes++] =
'f';
16840 string_buffer[bytes++] =
'f';
16841 string_buffer[bytes++] =
'd';
16845 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xEF');
16846 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBF');
16847 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBD');
16853 if (string_buffer.size() - bytes < 13)
16855 o->write_characters(string_buffer.data(), bytes);
16859 bytes_after_last_accept = bytes;
16862 undumped_chars = 0;
16865 state = UTF8_ACCEPT;
16870 JSON_ASSERT(
false);
16880 string_buffer[bytes++] = s[i];
16889 if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16894 o->write_characters(string_buffer.data(), bytes);
16900 switch (error_handler)
16902 case error_handler_t::strict:
16904 std::string sn(9,
'\0');
16906 (std::snprintf)(&sn[0], sn.size(),
"%.2X",
static_cast<std::uint8_t
>(s.back()));
16907 JSON_THROW(type_error::create(316,
"incomplete UTF-8 string; last byte: 0x" + sn, BasicJsonType()));
16910 case error_handler_t::ignore:
16913 o->write_characters(string_buffer.data(), bytes_after_last_accept);
16917 case error_handler_t::replace:
16920 o->write_characters(string_buffer.data(), bytes_after_last_accept);
16924 o->write_characters(
"\\ufffd", 6);
16928 o->write_characters(
"\xEF\xBF\xBD", 3);
16934 JSON_ASSERT(
false);
16948 inline unsigned int count_digits(number_unsigned_t x) noexcept
16950 unsigned int n_digits = 1;
16959 return n_digits + 1;
16963 return n_digits + 2;
16967 return n_digits + 3;
16983 template <
typename NumberType, detail::enable_if_t <
16984 std::is_integral<NumberType>::value ||
16985 std::is_same<NumberType, number_unsigned_t>::value ||
16986 std::is_same<NumberType, number_integer_t>::value ||
16987 std::is_same<NumberType, binary_char_t>::value,
16989 void dump_integer(NumberType x)
16991 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16994 {{
'0',
'0'}}, {{
'0',
'1'}}, {{
'0',
'2'}}, {{
'0',
'3'}}, {{
'0',
'4'}}, {{
'0',
'5'}}, {{
'0',
'6'}}, {{
'0',
'7'}}, {{
'0',
'8'}}, {{
'0',
'9'}},
16995 {{
'1',
'0'}}, {{
'1',
'1'}}, {{
'1',
'2'}}, {{
'1',
'3'}}, {{
'1',
'4'}}, {{
'1',
'5'}}, {{
'1',
'6'}}, {{
'1',
'7'}}, {{
'1',
'8'}}, {{
'1',
'9'}},
16996 {{
'2',
'0'}}, {{
'2',
'1'}}, {{
'2',
'2'}}, {{
'2',
'3'}}, {{
'2',
'4'}}, {{
'2',
'5'}}, {{
'2',
'6'}}, {{
'2',
'7'}}, {{
'2',
'8'}}, {{
'2',
'9'}},
16997 {{
'3',
'0'}}, {{
'3',
'1'}}, {{
'3',
'2'}}, {{
'3',
'3'}}, {{
'3',
'4'}}, {{
'3',
'5'}}, {{
'3',
'6'}}, {{
'3',
'7'}}, {{
'3',
'8'}}, {{
'3',
'9'}},
16998 {{
'4',
'0'}}, {{
'4',
'1'}}, {{
'4',
'2'}}, {{
'4',
'3'}}, {{
'4',
'4'}}, {{
'4',
'5'}}, {{
'4',
'6'}}, {{
'4',
'7'}}, {{
'4',
'8'}}, {{
'4',
'9'}},
16999 {{
'5',
'0'}}, {{
'5',
'1'}}, {{
'5',
'2'}}, {{
'5',
'3'}}, {{
'5',
'4'}}, {{
'5',
'5'}}, {{
'5',
'6'}}, {{
'5',
'7'}}, {{
'5',
'8'}}, {{
'5',
'9'}},
17000 {{
'6',
'0'}}, {{
'6',
'1'}}, {{
'6',
'2'}}, {{
'6',
'3'}}, {{
'6',
'4'}}, {{
'6',
'5'}}, {{
'6',
'6'}}, {{
'6',
'7'}}, {{
'6',
'8'}}, {{
'6',
'9'}},
17001 {{
'7',
'0'}}, {{
'7',
'1'}}, {{
'7',
'2'}}, {{
'7',
'3'}}, {{
'7',
'4'}}, {{
'7',
'5'}}, {{
'7',
'6'}}, {{
'7',
'7'}}, {{
'7',
'8'}}, {{
'7',
'9'}},
17002 {{
'8',
'0'}}, {{
'8',
'1'}}, {{
'8',
'2'}}, {{
'8',
'3'}}, {{
'8',
'4'}}, {{
'8',
'5'}}, {{
'8',
'6'}}, {{
'8',
'7'}}, {{
'8',
'8'}}, {{
'8',
'9'}},
17003 {{
'9',
'0'}}, {{
'9',
'1'}}, {{
'9',
'2'}}, {{
'9',
'3'}}, {{
'9',
'4'}}, {{
'9',
'5'}}, {{
'9',
'6'}}, {{
'9',
'7'}}, {{
'9',
'8'}}, {{
'9',
'9'}},
17010 o->write_character(
'0');
17015 auto buffer_ptr = number_buffer.begin();
17017 const bool is_negative = std::is_signed<NumberType>::value && !(x >= 0);
17018 number_unsigned_t abs_value;
17020 unsigned int n_chars{};
17025 abs_value = remove_sign(
static_cast<number_integer_t
>(x));
17028 n_chars = 1 + count_digits(abs_value);
17032 abs_value =
static_cast<number_unsigned_t
>(x);
17033 n_chars = count_digits(abs_value);
17037 JSON_ASSERT(n_chars < number_buffer.size() - 1);
17041 buffer_ptr += n_chars;
17045 while (abs_value >= 100)
17047 const auto digits_index =
static_cast<unsigned>((abs_value % 100));
17049 *(--buffer_ptr) = digits_to_99[digits_index][1];
17050 *(--buffer_ptr) = digits_to_99[digits_index][0];
17053 if (abs_value >= 10)
17055 const auto digits_index =
static_cast<unsigned>(abs_value);
17056 *(--buffer_ptr) = digits_to_99[digits_index][1];
17057 *(--buffer_ptr) = digits_to_99[digits_index][0];
17061 *(--buffer_ptr) =
static_cast<char>(
'0' + abs_value);
17064 o->write_characters(number_buffer.data(), n_chars);
17075 void dump_float(number_float_t x)
17078 if (!std::isfinite(x))
17080 o->write_characters(
"null", 4);
17089 static constexpr
bool is_ieee_single_or_double
17090 = (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) ||
17091 (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);
17093 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
17096 void dump_float(number_float_t x, std::true_type )
17098 auto* begin = number_buffer.data();
17099 auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
17101 o->write_characters(begin,
static_cast<size_t>(end - begin));
17104 void dump_float(number_float_t x, std::false_type )
17107 static constexpr
auto d = std::numeric_limits<number_float_t>::max_digits10;
17111 std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(),
"%.*g", d, x);
17114 JSON_ASSERT(len > 0);
17116 JSON_ASSERT(
static_cast<std::size_t
>(len) < number_buffer.size());
17119 if (thousands_sep !=
'\0')
17121 auto*
const end = std::remove(number_buffer.begin(),
17122 number_buffer.begin() + len, thousands_sep);
17123 std::fill(end, number_buffer.end(),
'\0');
17124 JSON_ASSERT((end - number_buffer.begin()) <= len);
17125 len = (end - number_buffer.begin());
17129 if (decimal_point !=
'\0' && decimal_point !=
'.')
17131 auto*
const dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
17132 if (dec_pos != number_buffer.end())
17138 o->write_characters(number_buffer.data(),
static_cast<std::size_t
>(len));
17141 const bool value_is_int_like =
17142 std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
17145 return c ==
'.' || c ==
'e';
17148 if (value_is_int_like)
17150 o->write_characters(
".0", 2);
17175 static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep,
const std::uint8_t
byte) noexcept
17177 static const std::array<std::uint8_t, 400> utf8d =
17180 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,
17181 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,
17182 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,
17183 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,
17184 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,
17185 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,
17186 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,
17187 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3,
17188 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
17189 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1,
17190 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,
17191 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,
17192 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,
17193 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
17197 JSON_ASSERT(
byte < utf8d.size());
17198 const std::uint8_t type = utf8d[byte];
17200 codep = (state != UTF8_ACCEPT)
17201 ? (
byte & 0x3fu) | (codep << 6u)
17202 : (0xFFu >> type) & (byte);
17204 std::size_t index = 256u +
static_cast<size_t>(state) * 16u +
static_cast<size_t>(type);
17205 JSON_ASSERT(index < 400);
17206 state = utf8d[index];
17215 number_unsigned_t remove_sign(number_unsigned_t x)
17217 JSON_ASSERT(
false);
17230 inline number_unsigned_t remove_sign(number_integer_t x) noexcept
17232 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
17233 return static_cast<number_unsigned_t
>(-(x + 1)) + 1;
17238 output_adapter_t<char> o =
nullptr;
17241 std::array<char, 64> number_buffer{{}};
17244 const std::lconv* loc =
nullptr;
17246 const char thousands_sep =
'\0';
17248 const char decimal_point =
'\0';
17251 std::array<char, 512> string_buffer{{}};
17254 const char indent_char;
17256 string_t indent_string;
17259 const error_handler_t error_handler;
17271 #include <functional>
17272 #include <initializer_list>
17273 #include <iterator>
17275 #include <stdexcept>
17276 #include <type_traits>
17288 template <
class Key,
class T,
class IgnoredLess = std::less<Key>,
17289 class Allocator = std::allocator<std::pair<const Key, T>>>
17294 using Container = std::vector<std::pair<const Key, T>, Allocator>;
17295 using typename Container::iterator;
17296 using typename Container::const_iterator;
17297 using typename Container::size_type;
17298 using typename Container::value_type;
17303 template <
class It>
17306 ordered_map(std::initializer_list<T> init,
const Allocator& alloc = Allocator() )
17311 for (
auto it = this->begin(); it != this->end(); ++it)
17313 if (it->first == key)
17315 return {it,
false};
17318 Container::emplace_back(key, t);
17319 return {--this->end(),
true};
17324 return emplace(key, T{}).first->second;
17334 for (
auto it = this->begin(); it != this->end(); ++it)
17336 if (it->first == key)
17342 JSON_THROW(std::out_of_range(
"key not found"));
17345 const T&
at(
const Key& key)
const
17347 for (
auto it = this->begin(); it != this->end(); ++it)
17349 if (it->first == key)
17355 JSON_THROW(std::out_of_range(
"key not found"));
17360 for (
auto it = this->begin(); it != this->end(); ++it)
17362 if (it->first == key)
17365 for (
auto next = it; ++next != this->end(); ++it)
17368 new (&*it) value_type{std::move(*next)};
17370 Container::pop_back();
17382 for (
auto next = it; ++next != this->end(); ++it)
17385 new (&*it) value_type{std::move(*next)};
17387 Container::pop_back();
17393 for (
auto it = this->begin(); it != this->end(); ++it)
17395 if (it->first == key)
17405 for (
auto it = this->begin(); it != this->end(); ++it)
17407 if (it->first == key)
17412 return Container::end();
17415 const_iterator
find(
const Key& key)
const
17417 for (
auto it = this->begin(); it != this->end(); ++it)
17419 if (it->first == key)
17424 return Container::end();
17427 std::pair<iterator, bool>
insert( value_type&& value )
17429 return emplace(value.first, std::move(value.second));
17432 std::pair<iterator, bool>
insert(
const value_type& value )
17434 for (
auto it = this->begin(); it != this->end(); ++it)
17436 if (it->first == value.first)
17438 return {it,
false};
17441 Container::push_back(value);
17442 return {--this->end(),
true};
17445 template<
typename InputIt>
17446 using require_input_iter =
typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
17447 std::input_iterator_tag>::value>::type;
17449 template<
typename InputIt,
typename = require_input_iter<InputIt>>
17452 for (
auto it = first; it != last; ++it)
17462 #if defined(JSON_HAS_CPP_17)
17463 #include <string_view>
17558 NLOHMANN_BASIC_JSON_TPL_DECLARATION
17563 friend ::nlohmann::json_pointer<basic_json>;
17565 template<
typename BasicJsonType,
typename InputType>
17566 friend class ::nlohmann::detail::parser;
17567 friend ::nlohmann::detail::serializer<basic_json>;
17568 template<
typename BasicJsonType>
17569 friend class ::nlohmann::detail::iter_impl;
17570 template<
typename BasicJsonType,
typename CharType>
17571 friend class ::nlohmann::detail::binary_writer;
17572 template<
typename BasicJsonType,
typename InputType,
typename SAX>
17573 friend class ::nlohmann::detail::binary_reader;
17574 template<
typename BasicJsonType>
17575 friend class ::nlohmann::detail::json_sax_dom_parser;
17576 template<
typename BasicJsonType>
17577 friend class ::nlohmann::detail::json_sax_dom_callback_parser;
17578 friend class ::nlohmann::detail::exception;
17581 using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
17583 JSON_PRIVATE_UNLESS_TESTED:
17585 using lexer = ::nlohmann::detail::lexer_base<basic_json>;
17587 template<
typename InputAdapterType>
17588 static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
17589 InputAdapterType adapter,
17590 detail::parser_callback_t<basic_json>cb =
nullptr,
17591 const bool allow_exceptions =
true,
17592 const bool ignore_comments =
false
17595 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
17596 std::move(cb), allow_exceptions, ignore_comments);
17600 using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
17601 template<
typename BasicJsonType>
17602 using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
17603 template<
typename BasicJsonType>
17604 using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
17605 template<
typename Iterator>
17606 using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
17607 template<
typename Base>
using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
17609 template<
typename CharType>
17610 using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
17612 template<
typename InputType>
17613 using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
17614 template<
typename CharType>
using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
17616 JSON_PRIVATE_UNLESS_TESTED:
17617 using serializer = ::nlohmann::detail::serializer<basic_json>;
17620 using value_t = detail::value_t;
17623 template<
typename T,
typename SFINAE>
17626 using error_handler_t = detail::error_handler_t;
17628 using cbor_tag_handler_t = detail::cbor_tag_handler_t;
17632 using input_format_t = detail::input_format_t;
17686 using pointer =
typename std::allocator_traits<allocator_type>::pointer;
17688 using const_pointer =
typename std::allocator_traits<allocator_type>::const_pointer;
17741 result[
"copyright"] =
"(C) 2013-2021 Niels Lohmann";
17742 result[
"name"] =
"JSON for Modern C++";
17743 result[
"url"] =
"https://github.com/nlohmann/json";
17744 result[
"version"][
"string"] =
17745 std::to_string(NLOHMANN_JSON_VERSION_MAJOR) +
"." +
17746 std::to_string(NLOHMANN_JSON_VERSION_MINOR) +
"." +
17747 std::to_string(NLOHMANN_JSON_VERSION_PATCH);
17748 result[
"version"][
"major"] = NLOHMANN_JSON_VERSION_MAJOR;
17749 result[
"version"][
"minor"] = NLOHMANN_JSON_VERSION_MINOR;
17750 result[
"version"][
"patch"] = NLOHMANN_JSON_VERSION_PATCH;
17753 result[
"platform"] =
"win32";
17754 #elif defined __linux__
17755 result[
"platform"] =
"linux";
17756 #elif defined __APPLE__
17757 result[
"platform"] =
"apple";
17758 #elif defined __unix__
17759 result[
"platform"] =
"unix";
17761 result[
"platform"] =
"unknown";
17764 #if defined(__ICC) || defined(__INTEL_COMPILER)
17765 result[
"compiler"] = {{
"family",
"icc"}, {
"version", __INTEL_COMPILER}};
17766 #elif defined(__clang__)
17767 result[
"compiler"] = {{
"family",
"clang"}, {
"version", __clang_version__}};
17768 #elif defined(__GNUC__) || defined(__GNUG__)
17769 result[
"compiler"] = {{
"family",
"gcc"}, {
"version", std::to_string(__GNUC__) +
"." + std::to_string(__GNUC_MINOR__) +
"." + std::to_string(__GNUC_PATCHLEVEL__)}};
17770 #elif defined(__HP_cc) || defined(__HP_aCC)
17771 result[
"compiler"] =
"hp"
17772 #elif defined(__IBMCPP__)
17773 result[
"compiler"] = {{
"family",
"ilecpp"}, {
"version", __IBMCPP__}};
17774 #elif defined(_MSC_VER)
17775 result[
"compiler"] = {{
"family",
"msvc"}, {
"version", _MSC_VER}};
17776 #elif defined(__PGI)
17777 result[
"compiler"] = {{
"family",
"pgcpp"}, {
"version", __PGI}};
17778 #elif defined(__SUNPRO_CC)
17779 result[
"compiler"] = {{
"family",
"sunpro"}, {
"version", __SUNPRO_CC}};
17781 result[
"compiler"] = {{
"family",
"unknown"}, {
"version",
"unknown"}};
17785 result[
"compiler"][
"c++"] = std::to_string(__cplusplus);
17787 result[
"compiler"][
"c++"] =
"unknown";
17802 #if defined(JSON_HAS_CPP_14)
17896 AllocatorType<std::pair<
const StringType,
17943 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
18310 template<
typename T,
typename... Args>
18312 static T* create(Args&& ... args)
18314 AllocatorType<T> alloc;
18315 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
18317 auto deleter = [&](T * obj)
18319 AllocatorTraits::deallocate(alloc, obj, 1);
18321 std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
18322 AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
18323 JSON_ASSERT(obj !=
nullptr);
18324 return obj.release();
18331 JSON_PRIVATE_UNLESS_TESTED:
18377 json_value() =
default;
18379 json_value(
boolean_t v) noexcept : boolean(v) {}
18391 case value_t::object:
18393 object = create<object_t>();
18397 case value_t::array:
18399 array = create<array_t>();
18403 case value_t::string:
18405 string = create<string_t>(
"");
18409 case value_t::binary:
18411 binary = create<binary_t>();
18415 case value_t::boolean:
18421 case value_t::number_integer:
18427 case value_t::number_unsigned:
18433 case value_t::number_float:
18439 case value_t::null:
18445 case value_t::discarded:
18449 if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
18451 JSON_THROW(other_error::create(500,
"961c151d2e87f2686a955a9be24d316f1362bf21 3.10.0",
basic_json()));
18461 string = create<string_t>(
value);
18467 string = create<string_t>(std::move(
value));
18473 object = create<object_t>(
value);
18479 object = create<object_t>(std::move(
value));
18485 array = create<array_t>(
value);
18491 array = create<array_t>(std::move(
value));
18497 binary = create<binary_t>(
value);
18503 binary = create<binary_t>(std::move(
value));
18509 binary = create<binary_t>(
value);
18515 binary = create<binary_t>(std::move(
value));
18520 if (t == value_t::array || t == value_t::object)
18523 std::vector<basic_json> stack;
18526 if (t == value_t::array)
18528 stack.reserve(array->size());
18529 std::move(array->begin(), array->end(), std::back_inserter(stack));
18534 for (
auto&& it : *
object)
18536 stack.push_back(std::move(it.second));
18540 while (!stack.empty())
18543 basic_json current_item(std::move(stack.back()));
18548 if (current_item.is_array())
18550 std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
18552 current_item.m_value.array->clear();
18554 else if (current_item.is_object())
18556 for (
auto&& it : *current_item.m_value.object)
18558 stack.push_back(std::move(it.second));
18561 current_item.m_value.object->clear();
18571 case value_t::object:
18573 AllocatorType<object_t> alloc;
18574 std::allocator_traits<decltype(alloc)>::destroy(alloc,
object);
18575 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
object, 1);
18579 case value_t::array:
18581 AllocatorType<array_t> alloc;
18582 std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
18583 std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
18587 case value_t::string:
18589 AllocatorType<string_t> alloc;
18590 std::allocator_traits<decltype(alloc)>::destroy(alloc,
string);
18591 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
string, 1);
18595 case value_t::binary:
18597 AllocatorType<binary_t> alloc;
18598 std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
18599 std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
18603 case value_t::null:
18604 case value_t::boolean:
18605 case value_t::number_integer:
18606 case value_t::number_unsigned:
18607 case value_t::number_float:
18608 case value_t::discarded:
18636 void assert_invariant(
bool check_parents =
true) const noexcept
18638 JSON_ASSERT(m_type != value_t::object ||
m_value.object !=
nullptr);
18639 JSON_ASSERT(m_type != value_t::array ||
m_value.array !=
nullptr);
18640 JSON_ASSERT(m_type != value_t::string ||
m_value.string !=
nullptr);
18641 JSON_ASSERT(m_type != value_t::binary ||
m_value.binary !=
nullptr);
18643 #if JSON_DIAGNOSTICS
18649 return j.m_parent ==
this;
18654 static_cast<void>(check_parents);
18659 #if JSON_DIAGNOSTICS
18662 case value_t::array:
18664 for (
auto& element : *
m_value.array)
18666 element.m_parent =
this;
18671 case value_t::object:
18673 for (
auto& element : *
m_value.object)
18675 element.second.m_parent =
this;
18680 case value_t::null:
18681 case value_t::string:
18682 case value_t::boolean:
18683 case value_t::number_integer:
18684 case value_t::number_unsigned:
18685 case value_t::number_float:
18686 case value_t::binary:
18687 case value_t::discarded:
18696 #if JSON_DIAGNOSTICS
18697 for (
typename iterator::difference_type i = 0; i <
count; ++i)
18699 (it + i)->m_parent =
this;
18702 static_cast<void>(
count);
18709 #if JSON_DIAGNOSTICS
18710 if (old_capacity != std::size_t(-1))
18713 JSON_ASSERT(
type() == value_t::array);
18714 if (JSON_HEDLEY_UNLIKELY(
m_value.array->capacity() != old_capacity))
18724 static_cast<void>(j);
18725 static_cast<void>(old_capacity);
18750 using parse_event_t = detail::parse_event_t;
18845 assert_invariant();
18869 assert_invariant();
18934 template <
typename CompatibleType,
18935 typename U = detail::uncvref_t<CompatibleType>,
18936 detail::enable_if_t <
18937 !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value,
int > = 0 >
18939 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
18940 std::forward<CompatibleType>(val))))
18942 JSONSerializer<U>::to_json(*
this, std::forward<CompatibleType>(val));
18944 assert_invariant();
18973 template <
typename BasicJsonType,
18974 detail::enable_if_t <
18975 detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value,
int > = 0 >
18978 using other_boolean_t =
typename BasicJsonType::boolean_t;
18979 using other_number_float_t =
typename BasicJsonType::number_float_t;
18980 using other_number_integer_t =
typename BasicJsonType::number_integer_t;
18981 using other_number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
18982 using other_string_t =
typename BasicJsonType::string_t;
18983 using other_object_t =
typename BasicJsonType::object_t;
18984 using other_array_t =
typename BasicJsonType::array_t;
18985 using other_binary_t =
typename BasicJsonType::binary_t;
18987 switch (val.type())
18989 case value_t::boolean:
18990 JSONSerializer<other_boolean_t>::to_json(*
this, val.template get<other_boolean_t>());
18992 case value_t::number_float:
18993 JSONSerializer<other_number_float_t>::to_json(*
this, val.template get<other_number_float_t>());
18995 case value_t::number_integer:
18996 JSONSerializer<other_number_integer_t>::to_json(*
this, val.template get<other_number_integer_t>());
18998 case value_t::number_unsigned:
18999 JSONSerializer<other_number_unsigned_t>::to_json(*
this, val.template get<other_number_unsigned_t>());
19001 case value_t::string:
19002 JSONSerializer<other_string_t>::to_json(*
this, val.template get_ref<const other_string_t&>());
19004 case value_t::object:
19005 JSONSerializer<other_object_t>::to_json(*
this, val.template get_ref<const other_object_t&>());
19007 case value_t::array:
19008 JSONSerializer<other_array_t>::to_json(*
this, val.template get_ref<const other_array_t&>());
19010 case value_t::binary:
19011 JSONSerializer<other_binary_t>::to_json(*
this, val.template get_ref<const other_binary_t&>());
19013 case value_t::null:
19016 case value_t::discarded:
19017 m_type = value_t::discarded;
19020 JSON_ASSERT(
false);
19023 assert_invariant();
19101 bool type_deduction =
true,
19102 value_t manual_type = value_t::array)
19106 bool is_an_object = std::all_of(init.begin(), init.end(),
19107 [](
const detail::json_ref<basic_json>& element_ref)
19109 return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
19113 if (!type_deduction)
19116 if (manual_type == value_t::array)
19118 is_an_object =
false;
19122 if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
19124 JSON_THROW(type_error::create(301,
"cannot create object from initializer list",
basic_json()));
19131 m_type = value_t::object;
19134 for (
auto& element_ref : init)
19136 auto element = element_ref.moved_or_copied();
19138 std::move(*((*element.m_value.array)[0].m_value.string)),
19139 std::move((*element.m_value.array)[1]));
19145 m_type = value_t::array;
19146 m_value.array = create<array_t>(init.begin(), init.end());
19150 assert_invariant();
19184 res.m_type = value_t::binary;
19185 res.m_value = init;
19221 res.m_type = value_t::binary;
19222 res.m_value =
binary_t(init, subtype);
19231 res.m_type = value_t::binary;
19232 res.m_value = std::move(init);
19241 res.m_type = value_t::binary;
19242 res.m_value =
binary_t(std::move(init), subtype);
19286 return basic_json(init,
false, value_t::array);
19330 return basic_json(init,
false, value_t::object);
19356 : m_type(value_t::array)
19358 m_value.array = create<array_t>(cnt, val);
19360 assert_invariant();
19418 template <
class InputIT,
typename std::enable_if <
19419 std::is_same<InputIT, typename basic_json_t::iterator>::value ||
19420 std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
int >
::type = 0 >
19423 JSON_ASSERT(first.m_object !=
nullptr);
19424 JSON_ASSERT(last.m_object !=
nullptr);
19427 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
19429 JSON_THROW(invalid_iterator::create(201,
"iterators are not compatible",
basic_json()));
19433 m_type = first.m_object->m_type;
19438 case value_t::boolean:
19439 case value_t::number_float:
19440 case value_t::number_integer:
19441 case value_t::number_unsigned:
19442 case value_t::string:
19444 if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
19445 || !last.m_it.primitive_iterator.is_end()))
19447 JSON_THROW(invalid_iterator::create(204,
"iterators out of range", *first.m_object));
19452 case value_t::null:
19453 case value_t::object:
19454 case value_t::array:
19455 case value_t::binary:
19456 case value_t::discarded:
19463 case value_t::number_integer:
19465 m_value.number_integer = first.m_object->m_value.number_integer;
19469 case value_t::number_unsigned:
19471 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
19475 case value_t::number_float:
19477 m_value.number_float = first.m_object->m_value.number_float;
19481 case value_t::boolean:
19483 m_value.boolean = first.m_object->m_value.boolean;
19487 case value_t::string:
19489 m_value = *first.m_object->m_value.string;
19493 case value_t::object:
19495 m_value.object = create<object_t>(first.m_it.object_iterator,
19496 last.m_it.object_iterator);
19500 case value_t::array:
19502 m_value.array = create<array_t>(first.m_it.array_iterator,
19503 last.m_it.array_iterator);
19507 case value_t::binary:
19509 m_value = *first.m_object->m_value.binary;
19513 case value_t::null:
19514 case value_t::discarded:
19516 JSON_THROW(invalid_iterator::create(206,
"cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
19520 assert_invariant();
19528 template<
typename JsonRef,
19529 detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
19530 std::is_same<typename JsonRef::value_type, basic_json>>
::value,
int> = 0 >
19559 : m_type(other.m_type)
19562 other.assert_invariant();
19566 case value_t::object:
19572 case value_t::array:
19578 case value_t::string:
19584 case value_t::boolean:
19590 case value_t::number_integer:
19596 case value_t::number_unsigned:
19602 case value_t::number_float:
19608 case value_t::binary:
19614 case value_t::null:
19615 case value_t::discarded:
19621 assert_invariant();
19651 : m_type(std::move(other.m_type)),
19652 m_value(std::move(other.m_value))
19655 other.assert_invariant(
false);
19658 other.m_type = value_t::null;
19659 other.m_value = {};
19662 assert_invariant();
19689 std::is_nothrow_move_constructible<value_t>::value&&
19690 std::is_nothrow_move_assignable<value_t>::value&&
19691 std::is_nothrow_move_constructible<json_value>::value&&
19692 std::is_nothrow_move_assignable<json_value>::value
19696 other.assert_invariant();
19699 swap(m_type, other.m_type);
19703 assert_invariant();
19724 assert_invariant(
false);
19787 const char indent_char =
' ',
19788 const bool ensure_ascii =
false,
19789 const error_handler_t error_handler = error_handler_t::strict)
const
19792 serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
19796 s.dump(*
this,
true, ensure_ascii,
static_cast<unsigned int>(indent));
19800 s.dump(*
this,
false, ensure_ascii, 0);
19839 constexpr value_t
type() const noexcept
19921 return m_type == value_t::null;
19943 return m_type == value_t::boolean;
20002 return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
20030 return m_type == value_t::number_unsigned;
20058 return m_type == value_t::number_float;
20080 return m_type == value_t::object;
20102 return m_type == value_t::array;
20124 return m_type == value_t::string;
20146 return m_type == value_t::binary;
20173 return m_type == value_t::discarded;
20217 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(
type_name()), *
this));
20239 constexpr
const array_t* get_impl_ptr(
const array_t* )
const noexcept
20327 template<
typename ReferenceType,
typename ThisType>
20328 static ReferenceType get_ref_impl(ThisType& obj)
20331 auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
20333 if (JSON_HEDLEY_LIKELY(ptr !=
nullptr))
20338 JSON_THROW(type_error::create(303,
"incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
20372 template<
typename PointerType,
typename std::enable_if<
20373 std::is_pointer<PointerType>::value,
int>
::type = 0>
20374 auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20377 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20384 template <
typename PointerType,
typename std::enable_if <
20385 std::is_pointer<PointerType>::value&&
20386 std::is_const<typename std::remove_pointer<PointerType>::type>
::value,
int >
::type = 0 >
20387 constexpr
auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20390 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20432 template <
typename ValueType,
20433 detail::enable_if_t <
20434 detail::is_default_constructible<ValueType>::value&&
20435 detail::has_from_json<basic_json_t, ValueType>::value,
20437 ValueType get_impl(detail::priority_tag<0> )
const noexcept(noexcept(
20438 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20441 JSONSerializer<ValueType>::from_json(*
this, ret);
20475 template <
typename ValueType,
20476 detail::enable_if_t <
20477 detail::has_non_default_from_json<basic_json_t, ValueType>::value,
20479 ValueType get_impl(detail::priority_tag<1> )
const noexcept(noexcept(
20480 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20482 return JSONSerializer<ValueType>::from_json(*
this);
20500 template <
typename BasicJsonType,
20501 detail::enable_if_t <
20502 detail::is_basic_json<BasicJsonType>::value,
20504 BasicJsonType get_impl(detail::priority_tag<2> )
const
20523 template<
typename BasicJsonType,
20524 detail::enable_if_t<
20525 std::is_same<BasicJsonType, basic_json_t>::value,
20527 basic_json get_impl(detail::priority_tag<3> )
const
20536 template<
typename PointerType,
20537 detail::enable_if_t<
20538 std::is_pointer<PointerType>::value,
20540 constexpr
auto get_impl(detail::priority_tag<4> )
const noexcept
20541 -> decltype(std::declval<const basic_json_t&>().
template get_ptr<PointerType>())
20544 return get_ptr<PointerType>();
20571 template <
typename ValueTypeCV,
typename ValueType = detail::uncvref_t<ValueTypeCV>>
20572 #if defined(JSON_HAS_CPP_14)
20576 noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
20577 -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
20582 static_assert(!std::is_reference<ValueTypeCV>::value,
20583 "get() cannot be used with reference types, you might want to use get_ref()");
20584 return get_impl<ValueType>(detail::priority_tag<4> {});
20614 template<
typename PointerType,
typename std::enable_if<
20615 std::is_pointer<PointerType>::value,
int>
::type = 0>
20616 auto get() noexcept -> decltype(std::declval<basic_json_t&>().template
get_ptr<PointerType>())
20619 return get_ptr<PointerType>();
20655 template <
typename ValueType,
20656 detail::enable_if_t <
20657 !detail::is_basic_json<ValueType>::value&&
20658 detail::has_from_json<basic_json_t, ValueType>::value,
20660 ValueType &
get_to(ValueType& v)
const noexcept(noexcept(
20661 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
20663 JSONSerializer<ValueType>::from_json(*
this, v);
20669 template<
typename ValueType,
20670 detail::enable_if_t <
20671 detail::is_basic_json<ValueType>::value,
20680 typename T, std::size_t N,
20681 typename Array = T (&)[N],
20682 detail::enable_if_t <
20683 detail::has_from_json<basic_json_t, Array>::value,
int > = 0 >
20685 noexcept(noexcept(JSONSerializer<Array>::from_json(
20686 std::declval<const basic_json_t&>(), v)))
20688 JSONSerializer<Array>::from_json(*
this, v);
20718 template<
typename ReferenceType,
typename std::enable_if<
20719 std::is_reference<ReferenceType>::value,
int>
::type = 0>
20723 return get_ref_impl<ReferenceType>(*
this);
20730 template <
typename ReferenceType,
typename std::enable_if <
20731 std::is_reference<ReferenceType>::value&&
20732 std::is_const<typename std::remove_reference<ReferenceType>::type>
::value,
int >
::type = 0 >
20736 return get_ref_impl<ReferenceType>(*
this);
20768 template <
typename ValueType,
typename std::enable_if <
20769 detail::conjunction <
20770 detail::negation<std::is_pointer<ValueType>>,
20771 detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
20772 detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
20773 detail::negation<detail::is_basic_json<ValueType>>,
20774 detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
20776 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
20777 detail::negation<std::is_same<ValueType, std::string_view>>,
20779 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
20781 JSON_EXPLICIT
operator ValueType()
const
20784 return get<ValueType>();
20800 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name()), *
this));
20803 return *get_ptr<binary_t*>();
20811 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name()), *
this));
20814 return *get_ptr<const binary_t*>();
20857 if (JSON_HEDLEY_LIKELY(
is_array()))
20861 return set_parent(
m_value.array->at(idx));
20863 JSON_CATCH (std::out_of_range&)
20866 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
20871 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
20904 if (JSON_HEDLEY_LIKELY(
is_array()))
20908 return m_value.array->at(idx);
20910 JSON_CATCH (std::out_of_range&)
20913 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
20918 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
20952 reference at(
const typename object_t::key_type& key)
20959 return set_parent(
m_value.object->at(key));
20961 JSON_CATCH (std::out_of_range&)
20964 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found", *
this));
20969 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
21010 return m_value.object->at(key);
21012 JSON_CATCH (std::out_of_range&)
21015 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found", *
this));
21020 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
21054 m_type = value_t::array;
21055 m_value.array = create<array_t>();
21056 assert_invariant();
21060 if (JSON_HEDLEY_LIKELY(
is_array()))
21063 if (idx >=
m_value.array->size())
21065 #if JSON_DIAGNOSTICS
21067 const auto previous_size =
m_value.array->size();
21069 m_value.array->resize(idx + 1);
21071 #if JSON_DIAGNOSTICS
21073 set_parents(
begin() +
static_cast<typename iterator::difference_type
>(previous_size),
static_cast<typename iterator::difference_type
>(idx + 1 - previous_size));
21077 return m_value.array->operator[](idx);
21080 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name()), *
this));
21105 if (JSON_HEDLEY_LIKELY(
is_array()))
21107 return m_value.array->operator[](idx);
21110 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name()), *
this));
21145 m_type = value_t::object;
21146 m_value.object = create<object_t>();
21147 assert_invariant();
21153 return set_parent(
m_value.object->operator[](key));
21156 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21194 JSON_ASSERT(
m_value.object->find(key) !=
m_value.object->end());
21195 return m_value.object->find(key)->second;
21198 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21228 template<
typename T>
21229 JSON_HEDLEY_NON_NULL(2)
21235 m_type = value_t::object;
21237 assert_invariant();
21243 return set_parent(
m_value.object->operator[](key));
21246 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21279 template<
typename T>
21280 JSON_HEDLEY_NON_NULL(2)
21286 JSON_ASSERT(
m_value.object->find(key) !=
m_value.object->end());
21287 return m_value.object->find(key)->second;
21290 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21344 template <
class ValueType,
typename std::enable_if <
21345 detail::is_getable<basic_json_t, ValueType>::value
21346 && !std::is_same<value_t, ValueType>::value,
int >
::type = 0 >
21347 ValueType
value(
const typename object_t::key_type& key,
const ValueType& default_value)
const
21353 const auto it =
find(key);
21356 return it->template get<ValueType>();
21359 return default_value;
21362 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name()), *
this));
21369 string_t value(
const typename object_t::key_type& key,
const char* default_value)
const
21417 template<
class ValueType,
typename std::enable_if<
21418 detail::is_getable<basic_json_t, ValueType>::value,
int>
::type = 0>
21427 return ptr.get_checked(
this).template get<ValueType>();
21431 return default_value;
21435 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name()), *
this));
21442 JSON_HEDLEY_NON_NULL(3)
21580 template <
class IteratorType,
typename std::enable_if <
21581 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21582 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21584 IteratorType
erase(IteratorType pos)
21587 if (JSON_HEDLEY_UNLIKELY(
this != pos.m_object))
21589 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
21592 IteratorType result =
end();
21596 case value_t::boolean:
21597 case value_t::number_float:
21598 case value_t::number_integer:
21599 case value_t::number_unsigned:
21600 case value_t::string:
21601 case value_t::binary:
21603 if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
21605 JSON_THROW(invalid_iterator::create(205,
"iterator out of range", *
this));
21610 AllocatorType<string_t> alloc;
21611 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.string);
21612 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21617 AllocatorType<binary_t> alloc;
21618 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.binary);
21619 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21623 m_type = value_t::null;
21624 assert_invariant();
21628 case value_t::object:
21630 result.m_it.object_iterator =
m_value.object->erase(pos.m_it.object_iterator);
21634 case value_t::array:
21636 result.m_it.array_iterator =
m_value.array->erase(pos.m_it.array_iterator);
21640 case value_t::null:
21641 case value_t::discarded:
21643 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21695 template <
class IteratorType,
typename std::enable_if <
21696 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21697 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21699 IteratorType
erase(IteratorType first, IteratorType last)
21702 if (JSON_HEDLEY_UNLIKELY(
this != first.m_object ||
this != last.m_object))
21704 JSON_THROW(invalid_iterator::create(203,
"iterators do not fit current value", *
this));
21707 IteratorType result =
end();
21711 case value_t::boolean:
21712 case value_t::number_float:
21713 case value_t::number_integer:
21714 case value_t::number_unsigned:
21715 case value_t::string:
21716 case value_t::binary:
21718 if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
21719 || !last.m_it.primitive_iterator.is_end()))
21721 JSON_THROW(invalid_iterator::create(204,
"iterators out of range", *
this));
21726 AllocatorType<string_t> alloc;
21727 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.string);
21728 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21733 AllocatorType<binary_t> alloc;
21734 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.binary);
21735 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21739 m_type = value_t::null;
21740 assert_invariant();
21744 case value_t::object:
21746 result.m_it.object_iterator =
m_value.object->erase(first.m_it.object_iterator,
21747 last.m_it.object_iterator);
21751 case value_t::array:
21753 result.m_it.array_iterator =
m_value.array->erase(first.m_it.array_iterator,
21754 last.m_it.array_iterator);
21758 case value_t::null:
21759 case value_t::discarded:
21761 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21801 return m_value.object->erase(key);
21804 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21834 if (JSON_HEDLEY_LIKELY(
is_array()))
21836 if (JSON_HEDLEY_UNLIKELY(idx >=
size()))
21838 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
21845 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21883 template<
typename KeyT>
21886 auto result =
end();
21890 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
21900 template<
typename KeyT>
21903 auto result =
cend();
21907 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
21934 template<
typename KeyT>
21966 template <
typename KeyT,
typename std::enable_if <
22001 return ptr.contains(
this);
22041 result.set_begin();
22081 result.set_begin();
22345 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
22348 return ref.items();
22354 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
22357 return ref.items();
22428 iteration_proxy<iterator>
items() noexcept
22430 return iteration_proxy<iterator>(*
this);
22436 iteration_proxy<const_iterator>
items() const noexcept
22438 return iteration_proxy<const_iterator>(*
this);
22493 bool empty() const noexcept
22497 case value_t::null:
22503 case value_t::array:
22506 return m_value.array->empty();
22509 case value_t::object:
22512 return m_value.object->empty();
22515 case value_t::string:
22516 case value_t::boolean:
22517 case value_t::number_integer:
22518 case value_t::number_unsigned:
22519 case value_t::number_float:
22520 case value_t::binary:
22521 case value_t::discarded:
22577 case value_t::null:
22583 case value_t::array:
22586 return m_value.array->size();
22589 case value_t::object:
22592 return m_value.object->size();
22595 case value_t::string:
22596 case value_t::boolean:
22597 case value_t::number_integer:
22598 case value_t::number_unsigned:
22599 case value_t::number_float:
22600 case value_t::binary:
22601 case value_t::discarded:
22655 case value_t::array:
22658 return m_value.array->max_size();
22661 case value_t::object:
22664 return m_value.object->max_size();
22667 case value_t::null:
22668 case value_t::string:
22669 case value_t::boolean:
22670 case value_t::number_integer:
22671 case value_t::number_unsigned:
22672 case value_t::number_float:
22673 case value_t::binary:
22674 case value_t::discarded:
22730 void clear() noexcept
22734 case value_t::number_integer:
22740 case value_t::number_unsigned:
22746 case value_t::number_float:
22752 case value_t::boolean:
22758 case value_t::string:
22764 case value_t::binary:
22770 case value_t::array:
22776 case value_t::object:
22782 case value_t::null:
22783 case value_t::discarded:
22814 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22820 m_type = value_t::array;
22822 assert_invariant();
22826 const auto old_capacity =
m_value.array->capacity();
22827 m_value.array->push_back(std::move(val));
22828 set_parent(
m_value.array->back(), old_capacity);
22851 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22857 m_type = value_t::array;
22859 assert_invariant();
22863 const auto old_capacity =
m_value.array->capacity();
22864 m_value.array->push_back(val);
22865 set_parent(
m_value.array->back(), old_capacity);
22898 void push_back(
const typename object_t::value_type& val)
22903 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22909 m_type = value_t::object;
22911 assert_invariant();
22915 auto res =
m_value.object->insert(val);
22916 set_parent(res.first->second);
22956 if (
is_object() && init.size() == 2 && (*init.begin())->is_string())
22958 basic_json&& key = init.begin()->moved_or_copied();
22959 push_back(
typename object_t::value_type(
22960 std::move(key.get_ref<
string_t&>()), (init.begin() + 1)->moved_or_copied()));
23001 template<
class... Args>
23007 JSON_THROW(type_error::create(311,
"cannot use emplace_back() with " + std::string(
type_name()), *
this));
23013 m_type = value_t::array;
23015 assert_invariant();
23019 const auto old_capacity =
m_value.array->capacity();
23020 m_value.array->emplace_back(std::forward<Args>(args)...);
23021 return set_parent(
m_value.array->back(), old_capacity);
23051 template<
class... Args>
23052 std::pair<iterator, bool>
emplace(Args&& ... args)
23057 JSON_THROW(type_error::create(311,
"cannot use emplace() with " + std::string(
type_name()), *
this));
23063 m_type = value_t::object;
23065 assert_invariant();
23069 auto res =
m_value.object->emplace(std::forward<Args>(args)...);
23070 set_parent(res.first->second);
23074 it.m_it.object_iterator = res.first;
23077 return {it, res.second};
23083 template<
typename... Args>
23087 JSON_ASSERT(
m_value.array !=
nullptr);
23089 auto insert_pos = std::distance(
m_value.array->begin(), pos.m_it.array_iterator);
23090 m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
23091 result.m_it.array_iterator =
m_value.array->begin() + insert_pos;
23126 if (JSON_HEDLEY_LIKELY(
is_array()))
23129 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23131 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23138 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23147 return insert(pos, val);
23177 if (JSON_HEDLEY_LIKELY(
is_array()))
23180 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23182 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23189 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23225 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
23227 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23231 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23233 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23237 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23239 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23242 if (JSON_HEDLEY_UNLIKELY(first.m_object ==
this))
23244 JSON_THROW(invalid_iterator::create(211,
"passed iterators may not belong to container", *
this));
23248 return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
23278 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
23280 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23284 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23286 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23319 if (JSON_HEDLEY_UNLIKELY(!
is_object()))
23321 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23325 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23327 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23331 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
23333 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects", *
this));
23336 m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
23363 m_type = value_t::object;
23364 m_value.object = create<object_t>();
23365 assert_invariant();
23370 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name()), *
this));
23372 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
23374 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(j.type_name()), *
this));
23377 for (
auto it = j.cbegin(); it != j.cend(); ++it)
23379 m_value.object->operator[](it.key()) = it.value();
23414 m_type = value_t::object;
23415 m_value.object = create<object_t>();
23416 assert_invariant();
23421 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name()), *
this));
23425 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23427 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23431 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
23432 || !last.m_object->is_object()))
23434 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects", *
this));
23437 for (
auto it = first; it != last; ++it)
23439 m_value.object->operator[](it.key()) = it.value();
23461 std::is_nothrow_move_constructible<value_t>::value&&
23462 std::is_nothrow_move_assignable<value_t>::value&&
23463 std::is_nothrow_move_constructible<json_value>::value&&
23464 std::is_nothrow_move_assignable<json_value>::value
23467 std::swap(m_type, other.m_type);
23468 std::swap(
m_value, other.m_value);
23471 other.set_parents();
23472 assert_invariant();
23494 std::is_nothrow_move_constructible<value_t>::value&&
23495 std::is_nothrow_move_assignable<value_t>::value&&
23496 std::is_nothrow_move_constructible<json_value>::value&&
23497 std::is_nothrow_move_assignable<json_value>::value
23526 if (JSON_HEDLEY_LIKELY(
is_array()))
23528 std::swap(*(
m_value.array), other);
23532 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23561 std::swap(*(
m_value.object), other);
23565 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23594 std::swap(*(
m_value.string), other);
23598 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23627 std::swap(*(
m_value.binary), other);
23631 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23641 std::swap(*(
m_value.binary), other);
23645 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23717 #pragma GCC diagnostic push
23718 #pragma GCC diagnostic ignored "-Wfloat-equal"
23720 const auto lhs_type = lhs.type();
23721 const auto rhs_type = rhs.type();
23723 if (lhs_type == rhs_type)
23727 case value_t::array:
23728 return *lhs.m_value.array == *rhs.m_value.array;
23730 case value_t::object:
23731 return *lhs.m_value.object == *rhs.m_value.object;
23733 case value_t::null:
23736 case value_t::string:
23737 return *lhs.m_value.string == *rhs.m_value.string;
23739 case value_t::boolean:
23740 return lhs.m_value.boolean == rhs.m_value.boolean;
23742 case value_t::number_integer:
23743 return lhs.m_value.number_integer == rhs.m_value.number_integer;
23745 case value_t::number_unsigned:
23746 return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
23748 case value_t::number_float:
23749 return lhs.m_value.number_float == rhs.m_value.number_float;
23751 case value_t::binary:
23752 return *lhs.m_value.binary == *rhs.m_value.binary;
23754 case value_t::discarded:
23759 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23761 return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
23763 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23765 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_integer);
23767 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23769 return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
23771 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23773 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23775 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23777 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
23779 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23781 return lhs.m_value.number_integer ==
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23786 #pragma GCC diagnostic pop
23794 template<
typename ScalarType,
typename std::enable_if<
23795 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23805 template<
typename ScalarType,
typename std::enable_if<
23806 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23832 return !(lhs == rhs);
23839 template<
typename ScalarType,
typename std::enable_if<
23840 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23850 template<
typename ScalarType,
typename std::enable_if<
23851 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23885 const auto lhs_type = lhs.type();
23886 const auto rhs_type = rhs.type();
23888 if (lhs_type == rhs_type)
23892 case value_t::array:
23895 return (*lhs.m_value.array) < (*rhs.m_value.array);
23897 case value_t::object:
23898 return (*lhs.m_value.object) < (*rhs.m_value.object);
23900 case value_t::null:
23903 case value_t::string:
23904 return (*lhs.m_value.string) < (*rhs.m_value.string);
23906 case value_t::boolean:
23907 return (lhs.m_value.boolean) < (rhs.m_value.boolean);
23909 case value_t::number_integer:
23910 return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
23912 case value_t::number_unsigned:
23913 return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
23915 case value_t::number_float:
23916 return (lhs.m_value.number_float) < (rhs.m_value.number_float);
23918 case value_t::binary:
23919 return (*lhs.m_value.binary) < (*rhs.m_value.binary);
23921 case value_t::discarded:
23926 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23928 return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
23930 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23932 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_integer);
23934 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23936 return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
23938 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23940 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23942 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23944 return lhs.m_value.number_integer <
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23946 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23948 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
23961 template<
typename ScalarType,
typename std::enable_if<
23962 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23972 template<
typename ScalarType,
typename std::enable_if<
23973 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24000 return !(rhs < lhs);
24007 template<
typename ScalarType,
typename std::enable_if<
24008 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24018 template<
typename ScalarType,
typename std::enable_if<
24019 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24046 return !(lhs <= rhs);
24053 template<
typename ScalarType,
typename std::enable_if<
24054 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24064 template<
typename ScalarType,
typename std::enable_if<
24065 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24092 return !(lhs < rhs);
24099 template<
typename ScalarType,
typename std::enable_if<
24100 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24110 template<
typename ScalarType,
typename std::enable_if<
24111 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24160 const bool pretty_print = o.width() > 0;
24161 const auto indentation = pretty_print ? o.width() : 0;
24167 serializer s(detail::output_adapter<char>(o), o.fill());
24168 s.dump(j, pretty_print,
false,
static_cast<unsigned int>(indentation));
24180 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator<<(std::ostream&,
const basic_json&))
24247 template<
typename InputType>
24251 const bool allow_exceptions =
true,
24252 const bool ignore_comments =
false)
24255 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(
true, result);
24285 template<
typename IteratorType>
24290 const bool allow_exceptions =
true,
24291 const bool ignore_comments =
false)
24294 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(
true, result);
24299 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
parse(ptr, ptr + len))
24302 const bool allow_exceptions =
true,
24303 const bool ignore_comments =
false)
24306 parser(i.get(), cb, allow_exceptions, ignore_comments).parse(
true, result);
24340 template<
typename InputType>
24341 static bool accept(InputType&& i,
24342 const bool ignore_comments =
false)
24344 return parser(detail::input_adapter(std::forward<InputType>(i)),
nullptr,
false, ignore_comments).accept(
true);
24347 template<
typename IteratorType>
24348 static bool accept(IteratorType first, IteratorType last,
24349 const bool ignore_comments =
false)
24351 return parser(detail::input_adapter(std::move(first), std::move(last)),
nullptr,
false, ignore_comments).accept(
true);
24355 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
accept(ptr, ptr + len))
24356 static bool accept(detail::span_input_adapter&& i,
24357 const bool ignore_comments =
false)
24359 return parser(i.get(),
nullptr,
false, ignore_comments).accept(
true);
24402 template <
typename InputType,
typename SAX>
24403 JSON_HEDLEY_NON_NULL(2)
24404 static
bool sax_parse(InputType&& i, SAX* sax,
24406 const
bool strict = true,
24407 const
bool ignore_comments = false)
24409 auto ia = detail::input_adapter(std::forward<InputType>(i));
24410 return format == input_format_t::json
24411 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24412 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24415 template<
class IteratorType,
class SAX>
24416 JSON_HEDLEY_NON_NULL(3)
24417 static
bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
24418 input_format_t format = input_format_t::
json,
24419 const
bool strict = true,
24420 const
bool ignore_comments = false)
24422 auto ia = detail::input_adapter(std::move(first), std::move(last));
24423 return format == input_format_t::json
24424 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24425 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24428 template <
typename SAX>
24429 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
sax_parse(ptr, ptr + len, ...))
24430 JSON_HEDLEY_NON_NULL(2)
24431 static
bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
24432 input_format_t format = input_format_t::
json,
24433 const
bool strict = true,
24434 const
bool ignore_comments = false)
24437 return format == input_format_t::json
24439 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24441 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24452 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator>>(std::istream&,
basic_json&))
24485 parser(detail::input_adapter(i)).parse(
false, j);
24532 case value_t::null:
24534 case value_t::object:
24536 case value_t::array:
24538 case value_t::string:
24540 case value_t::boolean:
24542 case value_t::binary:
24544 case value_t::discarded:
24545 return "discarded";
24546 case value_t::number_integer:
24547 case value_t::number_unsigned:
24548 case value_t::number_float:
24556 JSON_PRIVATE_UNLESS_TESTED:
24562 value_t m_type = value_t::null;
24567 #if JSON_DIAGNOSTICS
24680 std::vector<std::uint8_t> result;
24685 static void to_cbor(
const basic_json& j, detail::output_adapter<std::uint8_t> o)
24687 binary_writer<std::uint8_t>(o).write_cbor(j);
24692 binary_writer<char>(o).write_cbor(j);
24775 std::vector<std::uint8_t> result;
24782 binary_writer<std::uint8_t>(o).write_msgpack(j);
24787 binary_writer<char>(o).write_msgpack(j);
24877 const bool use_size =
false,
24878 const bool use_type =
false)
24880 std::vector<std::uint8_t> result;
24881 to_ubjson(j, result, use_size, use_type);
24886 const bool use_size =
false,
const bool use_type =
false)
24888 binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
24892 const bool use_size =
false,
const bool use_type =
false)
24894 binary_writer<char>(o).write_ubjson(j, use_size, use_type);
24956 std::vector<std::uint8_t> result;
24969 static void to_bson(
const basic_json& j, detail::output_adapter<std::uint8_t> o)
24971 binary_writer<std::uint8_t>(o).write_bson(j);
24979 binary_writer<char>(o).write_bson(j);
25085 template<
typename InputType>
25088 const bool strict =
true,
25089 const bool allow_exceptions =
true,
25093 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25094 auto ia = detail::input_adapter(std::forward<InputType>(i));
25095 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
25096 return res ? result :
basic_json(value_t::discarded);
25102 template<
typename IteratorType>
25105 const bool strict =
true,
25106 const bool allow_exceptions =
true,
25110 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25111 auto ia = detail::input_adapter(std::move(first), std::move(last));
25112 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
25113 return res ? result :
basic_json(value_t::discarded);
25116 template<
typename T>
25118 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_cbor(ptr, ptr + len))
25120 const bool strict =
true,
25121 const bool allow_exceptions =
true,
25124 return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
25131 const bool strict =
true,
25132 const bool allow_exceptions =
true,
25133 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
25136 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25139 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
25229 template<
typename InputType>
25232 const bool strict =
true,
25233 const bool allow_exceptions =
true)
25236 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25237 auto ia = detail::input_adapter(std::forward<InputType>(i));
25238 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
25239 return res ? result :
basic_json(value_t::discarded);
25245 template<
typename IteratorType>
25248 const bool strict =
true,
25249 const bool allow_exceptions =
true)
25252 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25253 auto ia = detail::input_adapter(std::move(first), std::move(last));
25254 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
25255 return res ? result :
basic_json(value_t::discarded);
25259 template<
typename T>
25261 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
25263 const bool strict =
true,
25264 const bool allow_exceptions =
true)
25266 return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
25270 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
25272 const bool strict =
true,
25273 const bool allow_exceptions =
true)
25276 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25279 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
25280 return res ? result :
basic_json(value_t::discarded);
25346 template<
typename InputType>
25349 const bool strict =
true,
25350 const bool allow_exceptions =
true)
25353 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25354 auto ia = detail::input_adapter(std::forward<InputType>(i));
25355 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25356 return res ? result :
basic_json(value_t::discarded);
25362 template<
typename IteratorType>
25365 const bool strict =
true,
25366 const bool allow_exceptions =
true)
25369 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25370 auto ia = detail::input_adapter(std::move(first), std::move(last));
25371 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25372 return res ? result :
basic_json(value_t::discarded);
25375 template<
typename T>
25377 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
25379 const bool strict =
true,
25380 const bool allow_exceptions =
true)
25382 return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
25386 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
25388 const bool strict =
true,
25389 const bool allow_exceptions =
true)
25392 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25395 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25396 return res ? result :
basic_json(value_t::discarded);
25460 template<
typename InputType>
25463 const bool strict =
true,
25464 const bool allow_exceptions =
true)
25467 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25468 auto ia = detail::input_adapter(std::forward<InputType>(i));
25469 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25470 return res ? result :
basic_json(value_t::discarded);
25476 template<
typename IteratorType>
25479 const bool strict =
true,
25480 const bool allow_exceptions =
true)
25483 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25484 auto ia = detail::input_adapter(std::move(first), std::move(last));
25485 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25486 return res ? result :
basic_json(value_t::discarded);
25489 template<
typename T>
25491 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
25493 const bool strict =
true,
25494 const bool allow_exceptions =
true)
25496 return from_bson(ptr, ptr + len, strict, allow_exceptions);
25500 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
25502 const bool strict =
true,
25503 const bool allow_exceptions =
true)
25506 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25509 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25510 return res ? result :
basic_json(value_t::discarded);
25556 return ptr.get_unchecked(
this);
25584 return ptr.get_unchecked(
this);
25627 return ptr.get_checked(
this);
25670 return ptr.get_checked(
this);
25698 json_pointer::flatten(
"", *
this, result);
25734 return json_pointer::unflatten(*
this);
25799 enum class patch_operations {add, remove, replace, move, copy, test, invalid};
25801 const auto get_op = [](
const std::string & op)
25805 return patch_operations::add;
25807 if (op ==
"remove")
25809 return patch_operations::remove;
25811 if (op ==
"replace")
25813 return patch_operations::replace;
25817 return patch_operations::move;
25821 return patch_operations::copy;
25825 return patch_operations::test;
25828 return patch_operations::invalid;
25843 if (top_pointer != ptr)
25845 result.
at(top_pointer);
25849 const auto last_path = ptr.
back();
25853 switch (parent.m_type)
25855 case value_t::null:
25856 case value_t::object:
25859 parent[last_path] = val;
25863 case value_t::array:
25865 if (last_path ==
"-")
25872 const auto idx = json_pointer::array_index(last_path);
25873 if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
25876 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", parent));
25880 parent.insert(parent.begin() +
static_cast<difference_type>(idx), val);
25886 case value_t::string:
25887 case value_t::boolean:
25888 case value_t::number_integer:
25889 case value_t::number_unsigned:
25890 case value_t::number_float:
25891 case value_t::binary:
25892 case value_t::discarded:
25894 JSON_ASSERT(
false);
25899 const auto operation_remove = [
this, &result](
json_pointer & ptr)
25902 const auto last_path = ptr.back();
25907 if (parent.is_object())
25910 auto it = parent.
find(last_path);
25911 if (JSON_HEDLEY_LIKELY(it != parent.end()))
25917 JSON_THROW(out_of_range::create(403,
"key '" + last_path +
"' not found", *
this));
25920 else if (parent.is_array())
25923 parent.erase(json_pointer::array_index(last_path));
25928 if (JSON_HEDLEY_UNLIKELY(!json_patch.
is_array()))
25930 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects", json_patch));
25934 for (
const auto& val : json_patch)
25937 const auto get_value = [&val](
const std::string & op,
25938 const std::string & member,
25942 auto it = val.m_value.object->find(member);
25945 const auto error_msg = (op ==
"op") ?
"operation" :
"operation '" + op +
"'";
25948 if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
25951 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have member '" + member +
"'", val));
25955 if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
25958 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have string member '" + member +
"'", val));
25966 if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
25968 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects", val));
25972 const auto op = get_value(
"op",
"op",
true).template get<std::string>();
25973 const auto path = get_value(op,
"path",
true).template get<std::string>();
25976 switch (get_op(op))
25978 case patch_operations::add:
25980 operation_add(ptr, get_value(
"add",
"value",
false));
25984 case patch_operations::remove:
25986 operation_remove(ptr);
25990 case patch_operations::replace:
25993 result.
at(ptr) = get_value(
"replace",
"value",
false);
25997 case patch_operations::move:
25999 const auto from_path = get_value(
"move",
"from",
true).template get<std::string>();
26009 operation_remove(from_ptr);
26010 operation_add(ptr, v);
26014 case patch_operations::copy:
26016 const auto from_path = get_value(
"copy",
"from",
true).template get<std::string>();
26025 operation_add(ptr, v);
26029 case patch_operations::test:
26031 bool success =
false;
26036 success = (result.
at(ptr) == get_value(
"test",
"value",
false));
26044 if (JSON_HEDLEY_UNLIKELY(!success))
26046 JSON_THROW(other_error::create(501,
"unsuccessful: " + val.dump(), val));
26052 case patch_operations::invalid:
26057 JSON_THROW(parse_error::create(105, 0,
"operation value '" + op +
"' is invalid", val));
26100 const std::string& path =
"")
26106 if (source == target)
26111 if (source.type() != target.type())
26116 {
"op",
"replace"}, {
"path", path}, {
"value", target}
26121 switch (source.type())
26123 case value_t::array:
26127 while (i < source.size() && i < target.size())
26130 auto temp_diff =
diff(source[i], target[i], path +
"/" + std::to_string(i));
26131 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
26140 while (i < source.size())
26147 {
"path", path +
"/" + std::to_string(i)}
26153 while (i < target.size())
26158 {
"path", path +
"/-"},
26159 {
"value", target[i]}
26167 case value_t::object:
26170 for (
auto it = source.cbegin(); it != source.cend(); ++it)
26173 const auto path_key = path +
"/" + detail::escape(it.key());
26175 if (target.find(it.key()) != target.end())
26178 auto temp_diff =
diff(it.value(), target[it.key()], path_key);
26179 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
26186 {
"op",
"remove"}, {
"path", path_key}
26192 for (
auto it = target.cbegin(); it != target.cend(); ++it)
26194 if (source.find(it.key()) == source.end())
26197 const auto path_key = path +
"/" + detail::escape(it.key());
26200 {
"op",
"add"}, {
"path", path_key},
26201 {
"value", it.value()}
26209 case value_t::null:
26210 case value_t::string:
26211 case value_t::boolean:
26212 case value_t::number_integer:
26213 case value_t::number_unsigned:
26214 case value_t::number_float:
26215 case value_t::binary:
26216 case value_t::discarded:
26222 {
"op",
"replace"}, {
"path", path}, {
"value", target}
26284 if (apply_patch.is_object())
26290 for (
auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
26292 if (it.value().is_null())
26304 *
this = apply_patch;
26320 NLOHMANN_BASIC_JSON_TPL_DECLARATION
26321 std::string
to_string(
const NLOHMANN_BASIC_JSON_TPL& j)
26346 return nlohmann::detail::hash(j);
26354 struct less<::nlohmann::detail::value_t>
26360 bool operator()(nlohmann::detail::value_t lhs,
26361 nlohmann::detail::value_t rhs)
const noexcept
26363 return nlohmann::detail::operator<(lhs, rhs);
26368 #ifndef JSON_HAS_CPP_20
26377 is_nothrow_move_constructible<nlohmann::json>::value&&
26378 is_nothrow_move_assignable<nlohmann::json>::value
26401 JSON_HEDLEY_NON_NULL(1)
26402 inline
nlohmann::json operator "" _json(const
char* s, std::
size_t n)
26420 JSON_HEDLEY_NON_NULL(1)
26421 inline
nlohmann::json::json_pointer operator "" _json_pointer(const
char* s, std::
size_t n)
26430 #if defined(__clang__)
26431 #pragma clang diagnostic pop
26436 #undef JSON_INTERNAL_CATCH
26440 #undef JSON_PRIVATE_UNLESS_TESTED
26441 #undef JSON_HAS_CPP_11
26442 #undef JSON_HAS_CPP_14
26443 #undef JSON_HAS_CPP_17
26444 #undef JSON_HAS_CPP_20
26445 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
26446 #undef NLOHMANN_BASIC_JSON_TPL
26447 #undef JSON_EXPLICIT
26452 #undef JSON_HEDLEY_ALWAYS_INLINE
26453 #undef JSON_HEDLEY_ARM_VERSION
26454 #undef JSON_HEDLEY_ARM_VERSION_CHECK
26455 #undef JSON_HEDLEY_ARRAY_PARAM
26456 #undef JSON_HEDLEY_ASSUME
26457 #undef JSON_HEDLEY_BEGIN_C_DECLS
26458 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
26459 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
26460 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
26461 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
26462 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
26463 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
26464 #undef JSON_HEDLEY_CLANG_HAS_WARNING
26465 #undef JSON_HEDLEY_COMPCERT_VERSION
26466 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
26467 #undef JSON_HEDLEY_CONCAT
26468 #undef JSON_HEDLEY_CONCAT3
26469 #undef JSON_HEDLEY_CONCAT3_EX
26470 #undef JSON_HEDLEY_CONCAT_EX
26471 #undef JSON_HEDLEY_CONST
26472 #undef JSON_HEDLEY_CONSTEXPR
26473 #undef JSON_HEDLEY_CONST_CAST
26474 #undef JSON_HEDLEY_CPP_CAST
26475 #undef JSON_HEDLEY_CRAY_VERSION
26476 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
26477 #undef JSON_HEDLEY_C_DECL
26478 #undef JSON_HEDLEY_DEPRECATED
26479 #undef JSON_HEDLEY_DEPRECATED_FOR
26480 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
26481 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
26482 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
26483 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
26484 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
26485 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
26486 #undef JSON_HEDLEY_DIAGNOSTIC_POP
26487 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
26488 #undef JSON_HEDLEY_DMC_VERSION
26489 #undef JSON_HEDLEY_DMC_VERSION_CHECK
26490 #undef JSON_HEDLEY_EMPTY_BASES
26491 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
26492 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
26493 #undef JSON_HEDLEY_END_C_DECLS
26494 #undef JSON_HEDLEY_FLAGS
26495 #undef JSON_HEDLEY_FLAGS_CAST
26496 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
26497 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
26498 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
26499 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
26500 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
26501 #undef JSON_HEDLEY_GCC_HAS_FEATURE
26502 #undef JSON_HEDLEY_GCC_HAS_WARNING
26503 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
26504 #undef JSON_HEDLEY_GCC_VERSION
26505 #undef JSON_HEDLEY_GCC_VERSION_CHECK
26506 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
26507 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
26508 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
26509 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
26510 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
26511 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
26512 #undef JSON_HEDLEY_GNUC_HAS_WARNING
26513 #undef JSON_HEDLEY_GNUC_VERSION
26514 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
26515 #undef JSON_HEDLEY_HAS_ATTRIBUTE
26516 #undef JSON_HEDLEY_HAS_BUILTIN
26517 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
26518 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
26519 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
26520 #undef JSON_HEDLEY_HAS_EXTENSION
26521 #undef JSON_HEDLEY_HAS_FEATURE
26522 #undef JSON_HEDLEY_HAS_WARNING
26523 #undef JSON_HEDLEY_IAR_VERSION
26524 #undef JSON_HEDLEY_IAR_VERSION_CHECK
26525 #undef JSON_HEDLEY_IBM_VERSION
26526 #undef JSON_HEDLEY_IBM_VERSION_CHECK
26527 #undef JSON_HEDLEY_IMPORT
26528 #undef JSON_HEDLEY_INLINE
26529 #undef JSON_HEDLEY_INTEL_CL_VERSION
26530 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
26531 #undef JSON_HEDLEY_INTEL_VERSION
26532 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
26533 #undef JSON_HEDLEY_IS_CONSTANT
26534 #undef JSON_HEDLEY_IS_CONSTEXPR_
26535 #undef JSON_HEDLEY_LIKELY
26536 #undef JSON_HEDLEY_MALLOC
26537 #undef JSON_HEDLEY_MCST_LCC_VERSION
26538 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
26539 #undef JSON_HEDLEY_MESSAGE
26540 #undef JSON_HEDLEY_MSVC_VERSION
26541 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
26542 #undef JSON_HEDLEY_NEVER_INLINE
26543 #undef JSON_HEDLEY_NON_NULL
26544 #undef JSON_HEDLEY_NO_ESCAPE
26545 #undef JSON_HEDLEY_NO_RETURN
26546 #undef JSON_HEDLEY_NO_THROW
26547 #undef JSON_HEDLEY_NULL
26548 #undef JSON_HEDLEY_PELLES_VERSION
26549 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
26550 #undef JSON_HEDLEY_PGI_VERSION
26551 #undef JSON_HEDLEY_PGI_VERSION_CHECK
26552 #undef JSON_HEDLEY_PREDICT
26553 #undef JSON_HEDLEY_PRINTF_FORMAT
26554 #undef JSON_HEDLEY_PRIVATE
26555 #undef JSON_HEDLEY_PUBLIC
26556 #undef JSON_HEDLEY_PURE
26557 #undef JSON_HEDLEY_REINTERPRET_CAST
26558 #undef JSON_HEDLEY_REQUIRE
26559 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
26560 #undef JSON_HEDLEY_REQUIRE_MSG
26561 #undef JSON_HEDLEY_RESTRICT
26563 #undef JSON_HEDLEY_SENTINEL
26564 #undef JSON_HEDLEY_STATIC_ASSERT
26565 #undef JSON_HEDLEY_STATIC_CAST
26566 #undef JSON_HEDLEY_STRINGIFY
26567 #undef JSON_HEDLEY_STRINGIFY_EX
26568 #undef JSON_HEDLEY_SUNPRO_VERSION
26569 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
26570 #undef JSON_HEDLEY_TINYC_VERSION
26571 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
26572 #undef JSON_HEDLEY_TI_ARMCL_VERSION
26573 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
26574 #undef JSON_HEDLEY_TI_CL2000_VERSION
26575 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
26576 #undef JSON_HEDLEY_TI_CL430_VERSION
26577 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
26578 #undef JSON_HEDLEY_TI_CL6X_VERSION
26579 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
26580 #undef JSON_HEDLEY_TI_CL7X_VERSION
26581 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
26582 #undef JSON_HEDLEY_TI_CLPRU_VERSION
26583 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
26584 #undef JSON_HEDLEY_TI_VERSION
26585 #undef JSON_HEDLEY_TI_VERSION_CHECK
26586 #undef JSON_HEDLEY_UNAVAILABLE
26587 #undef JSON_HEDLEY_UNLIKELY
26588 #undef JSON_HEDLEY_UNPREDICTABLE
26589 #undef JSON_HEDLEY_UNREACHABLE
26590 #undef JSON_HEDLEY_UNREACHABLE_RETURN
26591 #undef JSON_HEDLEY_VERSION
26592 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
26593 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
26594 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
26595 #undef JSON_HEDLEY_VERSION_ENCODE
26596 #undef JSON_HEDLEY_WARNING
26599 #undef JSON_HEDLEY_FALL_THROUGH
detail::parser_callback_t< basic_json > parser_callback_t
per-element parser callback type
bool contains(KeyT &&key) const
check the existence of an element in a JSON object
const_reverse_iterator crbegin() const noexcept
returns a const reverse iterator to the last element
ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const
access specified object element with default value
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
NumberIntegerType number_integer_t
a type for a number (integer)
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
comparison: equal
static bool sax_parse(InputType &&i, SAX *sax, input_format_t format=input_format_t::json, const bool strict=true, const bool ignore_comments=false)
generate SAX events
detail::exception exception
general exception of the basic_json class
ReferenceType get_ref()
get a reference value (implicit)
static basic_json parse(InputType &&i, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a compatible input
reference emplace_back(Args &&... args)
add an object to an array
static basic_json from_cbor(const T *ptr, std::size_t len, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
basic_json(const value_t v)
create an empty value with a given type
basic_json & operator=(basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
copy assignment
size_type max_size() const noexcept
returns the maximum possible number of elements
static basic_json diff(const basic_json &source, const basic_json &target, const std::string &path="")
creates a diff as a JSON patch
detail::input_format_t input_format_t
value_type & reference
the type of an element reference
const_reverse_iterator crend() const noexcept
returns a const reverse iterator to one before the first
detail::out_of_range out_of_range
exception indicating access out of the defined range
static iteration_proxy< iterator > iterator_wrapper(reference ref) noexcept
wrapper to access iterator member functions in range-based for
iterator begin() noexcept
returns an iterator to the first element
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
basic_json(const JsonRef &ref)
static std::vector< std::uint8_t > to_ubjson(const basic_json &j, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
static basic_json array(initializer_list_t init={})
explicitly create an array from an initializer list
const_iterator cend() const noexcept
returns a const iterator to one past the last element
reference back()
access the last element
static bool accept(InputType &&i, const bool ignore_comments=false)
check if the input is valid JSON
StringType string_t
a type for a string
size_type size() const noexcept
returns the number of elements
friend std::ostream & operator>>(const basic_json &j, std::ostream &o)
serialize to stream
static basic_json meta()
returns version information on the library
void update(const_reference j)
updates a JSON object from another object, overwriting existing keys
std::size_t size_type
a type to represent container sizes
std::ptrdiff_t difference_type
a type to represent differences between iterators
static basic_json binary(const typename binary_t::container_type &init)
explicitly create a binary array (without subtype)
reference operator+=(basic_json &&val)
add an object to an array
basic_json(const BasicJsonType &val)
create a JSON value from an existing one
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
static basic_json from_cbor(InputType &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
create a JSON value from an input in CBOR format
BooleanType boolean_t
a type for a boolean
void push_back(initializer_list_t init)
add an object to an object
const char * type_name() const noexcept
return the type as string
string_t dump(const int indent=-1, const char indent_char=' ', const bool ensure_ascii=false, const error_handler_t error_handler=error_handler_t::strict) const
serialization
IteratorType erase(IteratorType pos)
remove element given an iterator
static basic_json from_bson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
Create a JSON value from an input in BSON format.
constexpr bool is_structured() const noexcept
return whether type is structured
reference at(size_type idx)
access specified array element with bounds checking
static basic_json binary(typename binary_t::container_type &&init, typename binary_t::subtype_type subtype)
explicitly create a binary array (with subtype)
reference front()
access the first element
constexpr bool is_primitive() const noexcept
return whether type is primitive
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
detail::cbor_tag_handler_t cbor_tag_handler_t
how to treat CBOR tags
detail::parse_error parse_error
exception indicating a parse error
constexpr bool is_object() const noexcept
return whether value is an object
static std::vector< std::uint8_t > to_bson(const basic_json &j)
Serializes the given JSON object j to BSON and returns a vector containing the corresponding BSON-rep...
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
NumberFloatType number_float_t
a type for a number (floating-point)
json_reverse_iterator< typename basic_json::iterator > reverse_iterator
a reverse iterator for a basic_json container
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
comparison: less than or equal
bool empty() const noexcept
checks whether the container is empty.
friend std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
basic_json(const basic_json &other)
copy constructor
~basic_json() noexcept
destructor
friend struct detail::external_constructor
basic_json(basic_json &&other) noexcept
move constructor
detail::invalid_iterator invalid_iterator
exception indicating errors with iterators
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
comparison: not equal
detail::other_error other_error
exception indicating other library errors
json_value m_value
the value of the current element
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
comparison: greater than or equal
reverse_iterator rend() noexcept
returns an iterator to the reverse-end
static basic_json binary(const typename binary_t::container_type &init, typename binary_t::subtype_type subtype)
explicitly create a binary array (with subtype)
static std::vector< std::uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
ReferenceType get_ref() const
get a reference value (implicit)
auto get() noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
void merge_patch(const basic_json &apply_patch)
applies a JSON Merge Patch
auto get_ptr() noexcept -> decltype(std::declval< basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
ArrayType< basic_json, AllocatorType< basic_json > > array_t
a type for an array
Array get_to(T(&v)[N]) const noexcept(noexcept(JSONSerializer< Array >::from_json(std::declval< const basic_json_t & >(), v)))
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
comparison: greater than
constexpr bool is_boolean() const noexcept
return whether value is a boolean
iteration_proxy< iterator > items() noexcept
helper to access iterator member functions in range-based for
iterator end() noexcept
returns an iterator to one past the last element
void swap(reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
void clear() noexcept
clears the contents
constexpr bool is_binary() const noexcept
return whether value is a binary array
static basic_json object(initializer_list_t init={})
explicitly create an object from an initializer list
reference operator[](size_type idx)
access specified array element
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
iter_impl< basic_json > iterator
an iterator for a basic_json container
json_reverse_iterator< typename basic_json::const_iterator > const_reverse_iterator
a const reverse iterator for a basic_json container
static basic_json from_ubjson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in UBJSON format
::nlohmann::json_pointer< basic_json > json_pointer
JSON Pointer, see nlohmann::json_pointer.
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
comparison: less than
static basic_json binary(typename binary_t::container_type &&init)
explicitly create a binary array (without subtype)
constexpr bool is_string() const noexcept
return whether value is a string
constexpr bool is_array() const noexcept
return whether value is an array
iterator insert_iterator(const_iterator pos, Args &&... args)
basic_json flatten() const
return flattened JSON value
const value_type & const_reference
the type of an element const reference
void push_back(basic_json &&val)
add an object to an array
size_type count(KeyT &&key) const
returns the number of occurrences of a key in a JSON object
const binary_t & get_binary() const
constexpr bool is_number() const noexcept
return whether value is a number
std::less< StringType > object_comparator_t
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
std::initializer_list< detail::json_ref< basic_json > > initializer_list_t
helper type for initializer lists of basic_json values
ValueType & get_to(ValueType &v) const
iterator find(KeyT &&key)
find an element in a JSON object
detail::type_error type_error
exception indicating executing a member function with a wrong type
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
AllocatorType< basic_json > allocator_type
the allocator type
nlohmann::byte_container_with_subtype< BinaryType > binary_t
a type for a packed binary type
JSONSerializer< T, SFINAE > json_serializer
static basic_json from_msgpack(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in MessagePack format
basic_json patch(const basic_json &json_patch) const
applies a JSON patch
basic_json(CompatibleType &&val) noexcept(noexcept(//NOLINT(bugprone-forwarding-reference-overload, bugprone-exception-escape) JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
create a JSON value
basic_json unflatten() const
unflatten a previously flattened JSON value
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
static std::vector< std::uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
const_iterator cbegin() const noexcept
returns a const iterator to the first element
basic_json(initializer_list_t init, bool type_deduction=true, value_t manual_type=value_t::array)
create a container (array or object) from an initializer list
iterator insert(const_iterator pos, const basic_json &val)
inserts element
iter_impl< const basic_json > const_iterator
a const iterator for a basic_json container
constexpr bool is_discarded() const noexcept
return whether value is discarded
constexpr bool is_null() const noexcept
return whether value is null
ObjectType< StringType, basic_json, object_comparator_t, AllocatorType< std::pair< const StringType, basic_json > >> object_t
a type for an object
auto get() const noexcept(noexcept(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))) -> decltype(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))
get a (pointer) value (explicit)
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
static allocator_type get_allocator()
returns the allocator associated with the container
constexpr auto get_ptr() const noexcept -> decltype(std::declval< const basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
reverse_iterator rbegin() noexcept
returns an iterator to the reverse-beginning
a class to store JSON values
byte_container_with_subtype(const container_type &b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
BinaryType container_type
the type of the underlying container
byte_container_with_subtype(const container_type &b) noexcept(noexcept(container_type(b)))
byte_container_with_subtype(container_type &&b) noexcept(noexcept(container_type(std::move(b))))
bool operator!=(const byte_container_with_subtype &rhs) const
void clear_subtype() noexcept
clears the binary subtype
byte_container_with_subtype() noexcept(noexcept(container_type()))
byte_container_with_subtype(container_type &&b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
constexpr bool has_subtype() const noexcept
return whether the value has a subtype
void set_subtype(subtype_type subtype_) noexcept
sets the binary subtype
constexpr subtype_type subtype() const noexcept
return the binary subtype
std::uint64_t subtype_type
the type of the subtype
bool operator==(const byte_container_with_subtype &rhs) const
an internal type for a backed binary type
const std::string & back() const
return last reference token
std::string to_string() const
return a string representation of the JSON pointer
friend bool operator==(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for equality
void pop_back()
remove last reference token
bool empty() const noexcept
return whether pointer points to the root document
friend bool operator!=(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for inequality
void push_back(const std::string &token)
append an unescaped token at the end of the reference pointer
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON pointer
json_pointer(const std::string &s="")
create JSON pointer
friend json_pointer operator/(const json_pointer &lhs, const json_pointer &rhs)
create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
friend json_pointer operator/(const json_pointer &ptr, std::string token)
create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
json_pointer & operator/=(std::string token)
append an unescaped reference token at the end of this JSON pointer
void push_back(std::string &&token)
append an unescaped token at the end of the reference pointer
friend json_pointer operator/(const json_pointer &ptr, std::size_t array_idx)
create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
json_pointer parent_pointer() const
returns the parent of this JSON pointer
constexpr const auto & to_json
constexpr const auto & from_json
basic_json<> json
default JSON class
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
namespace for Niels Lohmann
static auto from_json(BasicJsonType &&j, TargetType &val) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), val))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), val), void())
convert a JSON value to any value type
static auto from_json(BasicJsonType &&j) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), detail::identity_tag< TargetType > {}))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), detail::identity_tag< TargetType > {}))
convert a JSON value to any value type
static auto to_json(BasicJsonType &j, TargetType &&val) noexcept(noexcept(::nlohmann::to_json(j, std::forward< TargetType >(val)))) -> decltype(::nlohmann::to_json(j, std::forward< TargetType >(val)), void())
convert any value type to a JSON value
default JSONSerializer template argument
virtual bool start_object(std::size_t elements)=0
the beginning of an object was read
virtual bool string(string_t &val)=0
a string was read
typename BasicJsonType::number_integer_t number_integer_t
typename BasicJsonType::binary_t binary_t
json_sax & operator=(const json_sax &)=default
virtual bool end_array()=0
the end of an array was read
virtual bool key(string_t &val)=0
an object key was read
typename BasicJsonType::number_unsigned_t number_unsigned_t
virtual bool binary(binary_t &val)=0
a binary string was read
typename BasicJsonType::number_float_t number_float_t
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
json_sax(json_sax &&) noexcept=default
virtual bool boolean(bool val)=0
a boolean value was read
json_sax(const json_sax &)=default
virtual bool end_object()=0
the end of an object was read
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
typename BasicJsonType::string_t string_t
virtual bool number_float(number_float_t val, const string_t &s)=0
an floating-point number was read
virtual bool number_integer(number_integer_t val)=0
an integer number was read
std::pair< iterator, bool > insert(const value_type &value)
ordered_map(std::initializer_list< T > init, const Allocator &alloc=Allocator())
std::vector< std::pair< const Key, T >, Allocator > Container
iterator find(const Key &key)
iterator erase(iterator pos)
void insert(InputIt first, InputIt last)
std::pair< iterator, bool > emplace(const key_type &key, T &&t)
const_iterator find(const Key &key) const
std::pair< iterator, bool > insert(value_type &&value)
size_type erase(const Key &key)
const T & operator[](const Key &key) const
ordered_map(const Allocator &alloc=Allocator())
typename std::enable_if< std::is_convertible< typename std::iterator_traits< InputIt >::iterator_category, std::input_iterator_tag >::value >::type require_input_iter
const T & at(const Key &key) const
ordered_map(It first, It last, const Allocator &alloc=Allocator())
T & operator[](const Key &key)
size_type count(const Key &key) const