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 4
40#include <initializer_list>
62#include <forward_list>
68#include <unordered_map>
120enum class value_t : std::uint8_t
147inline 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
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)
1434JSON_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(...)
1460JSON_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)
2220#include <type_traits>
2229template<
typename ...Ts>
struct make_void
2233template<
typename ...Ts>
using void_t =
typename make_void<Ts...>::type;
2245 nonesuch() =
delete;
2246 ~nonesuch() =
delete;
2247 nonesuch(nonesuch
const&) =
delete;
2248 nonesuch(nonesuch
const&&) =
delete;
2249 void operator=(nonesuch
const&) =
delete;
2250 void operator=(nonesuch&&) =
delete;
2253template<
class Default,
2255 template<
class...>
class Op,
2259 using value_t = std::false_type;
2260 using type = Default;
2263template<
class Default,
template<
class...>
class Op,
class... Args>
2264struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2266 using value_t = std::true_type;
2267 using type = Op<Args...>;
2270template<
template<
class...>
class Op,
class... Args>
2271using is_detected =
typename detector<nonesuch, void, Op, Args...>::value_t;
2273template<
template<
class...>
class Op,
class... Args>
2274struct is_detected_lazy : is_detected<Op, Args...> { };
2276template<
template<
class...>
class Op,
class... Args>
2277using detected_t =
typename detector<nonesuch, void, Op, Args...>::type;
2279template<
class Default,
template<
class...>
class Op,
class... Args>
2280using detected_or = detector<Default, void, Op, Args...>;
2282template<
class Default,
template<
class...>
class Op,
class... Args>
2283using detected_or_t =
typename detected_or<Default, Op, Args...>::type;
2285template<
class Expected,
template<
class...>
class Op,
class... Args>
2286using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2288template<
class To,
template<
class...>
class Op,
class... Args>
2289using is_detected_convertible =
2290 std::is_convertible<detected_t<Op, Args...>, To>;
2299#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2300 #if defined(__clang__)
2301 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2302 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2304 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2305 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2306 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2313#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2314 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2315 #define JSON_HAS_CPP_20
2316 #define JSON_HAS_CPP_17
2317 #define JSON_HAS_CPP_14
2318 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
2319 #define JSON_HAS_CPP_17
2320 #define JSON_HAS_CPP_14
2321 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2322 #define JSON_HAS_CPP_14
2325 #define JSON_HAS_CPP_11
2329#if defined(__clang__)
2330 #pragma clang diagnostic push
2331 #pragma clang diagnostic ignored "-Wdocumentation"
2332 #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2336#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2337 #define JSON_THROW(exception) throw exception
2338 #define JSON_TRY try
2339 #define JSON_CATCH(exception) catch(exception)
2340 #define JSON_INTERNAL_CATCH(exception) catch(exception)
2343 #define JSON_THROW(exception) std::abort()
2344 #define JSON_TRY if(true)
2345 #define JSON_CATCH(exception) if(false)
2346 #define JSON_INTERNAL_CATCH(exception) if(false)
2350#if defined(JSON_THROW_USER)
2352 #define JSON_THROW JSON_THROW_USER
2354#if defined(JSON_TRY_USER)
2356 #define JSON_TRY JSON_TRY_USER
2358#if defined(JSON_CATCH_USER)
2360 #define JSON_CATCH JSON_CATCH_USER
2361 #undef JSON_INTERNAL_CATCH
2362 #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2364#if defined(JSON_INTERNAL_CATCH_USER)
2365 #undef JSON_INTERNAL_CATCH
2366 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2370#if !defined(JSON_ASSERT)
2372 #define JSON_ASSERT(x) assert(x)
2376#if defined(JSON_TESTS_PRIVATE)
2377 #define JSON_PRIVATE_UNLESS_TESTED public
2379 #define JSON_PRIVATE_UNLESS_TESTED private
2387#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2388 template<typename BasicJsonType> \
2389 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2391 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2392 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2393 auto it = std::find_if(std::begin(m), std::end(m), \
2394 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2396 return ej_pair.first == e; \
2398 j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2400 template<typename BasicJsonType> \
2401 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2403 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2404 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2405 auto it = std::find_if(std::begin(m), std::end(m), \
2406 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2408 return ej_pair.second == j; \
2410 e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2416#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2417 template<template<typename, typename, typename...> class ObjectType, \
2418 template<typename, typename...> class ArrayType, \
2419 class StringType, class BooleanType, class NumberIntegerType, \
2420 class NumberUnsignedType, class NumberFloatType, \
2421 template<typename> class AllocatorType, \
2422 template<typename, typename = void> class JSONSerializer, \
2425#define NLOHMANN_BASIC_JSON_TPL \
2426 basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2427 NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2428 AllocatorType, JSONSerializer, BinaryType>
2432#define NLOHMANN_JSON_EXPAND( x ) x
2433#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
2434#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2435 NLOHMANN_JSON_PASTE64, \
2436 NLOHMANN_JSON_PASTE63, \
2437 NLOHMANN_JSON_PASTE62, \
2438 NLOHMANN_JSON_PASTE61, \
2439 NLOHMANN_JSON_PASTE60, \
2440 NLOHMANN_JSON_PASTE59, \
2441 NLOHMANN_JSON_PASTE58, \
2442 NLOHMANN_JSON_PASTE57, \
2443 NLOHMANN_JSON_PASTE56, \
2444 NLOHMANN_JSON_PASTE55, \
2445 NLOHMANN_JSON_PASTE54, \
2446 NLOHMANN_JSON_PASTE53, \
2447 NLOHMANN_JSON_PASTE52, \
2448 NLOHMANN_JSON_PASTE51, \
2449 NLOHMANN_JSON_PASTE50, \
2450 NLOHMANN_JSON_PASTE49, \
2451 NLOHMANN_JSON_PASTE48, \
2452 NLOHMANN_JSON_PASTE47, \
2453 NLOHMANN_JSON_PASTE46, \
2454 NLOHMANN_JSON_PASTE45, \
2455 NLOHMANN_JSON_PASTE44, \
2456 NLOHMANN_JSON_PASTE43, \
2457 NLOHMANN_JSON_PASTE42, \
2458 NLOHMANN_JSON_PASTE41, \
2459 NLOHMANN_JSON_PASTE40, \
2460 NLOHMANN_JSON_PASTE39, \
2461 NLOHMANN_JSON_PASTE38, \
2462 NLOHMANN_JSON_PASTE37, \
2463 NLOHMANN_JSON_PASTE36, \
2464 NLOHMANN_JSON_PASTE35, \
2465 NLOHMANN_JSON_PASTE34, \
2466 NLOHMANN_JSON_PASTE33, \
2467 NLOHMANN_JSON_PASTE32, \
2468 NLOHMANN_JSON_PASTE31, \
2469 NLOHMANN_JSON_PASTE30, \
2470 NLOHMANN_JSON_PASTE29, \
2471 NLOHMANN_JSON_PASTE28, \
2472 NLOHMANN_JSON_PASTE27, \
2473 NLOHMANN_JSON_PASTE26, \
2474 NLOHMANN_JSON_PASTE25, \
2475 NLOHMANN_JSON_PASTE24, \
2476 NLOHMANN_JSON_PASTE23, \
2477 NLOHMANN_JSON_PASTE22, \
2478 NLOHMANN_JSON_PASTE21, \
2479 NLOHMANN_JSON_PASTE20, \
2480 NLOHMANN_JSON_PASTE19, \
2481 NLOHMANN_JSON_PASTE18, \
2482 NLOHMANN_JSON_PASTE17, \
2483 NLOHMANN_JSON_PASTE16, \
2484 NLOHMANN_JSON_PASTE15, \
2485 NLOHMANN_JSON_PASTE14, \
2486 NLOHMANN_JSON_PASTE13, \
2487 NLOHMANN_JSON_PASTE12, \
2488 NLOHMANN_JSON_PASTE11, \
2489 NLOHMANN_JSON_PASTE10, \
2490 NLOHMANN_JSON_PASTE9, \
2491 NLOHMANN_JSON_PASTE8, \
2492 NLOHMANN_JSON_PASTE7, \
2493 NLOHMANN_JSON_PASTE6, \
2494 NLOHMANN_JSON_PASTE5, \
2495 NLOHMANN_JSON_PASTE4, \
2496 NLOHMANN_JSON_PASTE3, \
2497 NLOHMANN_JSON_PASTE2, \
2498 NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2499#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2500#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2501#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2502#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2503#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2504#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)
2505#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)
2506#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)
2507#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)
2508#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)
2509#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)
2510#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)
2511#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)
2512#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)
2513#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)
2514#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)
2515#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)
2516#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)
2517#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)
2518#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)
2519#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)
2520#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)
2521#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)
2522#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)
2523#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)
2524#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)
2525#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)
2526#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)
2527#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)
2528#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)
2529#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)
2530#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)
2531#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)
2532#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)
2533#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)
2534#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)
2535#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)
2536#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)
2537#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)
2538#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)
2539#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)
2540#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)
2541#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)
2542#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)
2543#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)
2544#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)
2545#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)
2546#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)
2547#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)
2548#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)
2549#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)
2550#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)
2551#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)
2552#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)
2553#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)
2554#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)
2555#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)
2556#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)
2557#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)
2558#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)
2559#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)
2560#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)
2561#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)
2563#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2564#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2571#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2572 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__)) } \
2573 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__)) }
2580#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2581 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__)) } \
2582 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__)) }
2591#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \
2592 namespace detail { \
2593 using std::std_name; \
2595 template<typename... T> \
2596 using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
2599 namespace detail2 { \
2600 struct std_name##_tag \
2604 template<typename... T> \
2605 std_name##_tag std_name(T&&...); \
2607 template<typename... T> \
2608 using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
2610 template<typename... T> \
2611 struct would_call_std_##std_name \
2613 static constexpr auto const value = ::nlohmann::detail:: \
2614 is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
2618 template<typename... T> \
2619 struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...> \
2623#ifndef JSON_USE_IMPLICIT_CONVERSIONS
2624 #define JSON_USE_IMPLICIT_CONVERSIONS 1
2627#if JSON_USE_IMPLICIT_CONVERSIONS
2628 #define JSON_EXPLICIT
2630 #define JSON_EXPLICIT explicit
2633#ifndef JSON_DIAGNOSTICS
2634 #define JSON_DIAGNOSTICS 0
2656inline void replace_substring(std::string& s,
const std::string& f,
2657 const std::string& t)
2659 JSON_ASSERT(!f.empty());
2660 for (
auto pos = s.find(f);
2661 pos != std::string::npos;
2662 s.replace(pos, f.size(), t),
2663 pos = s.find(f, pos + t.size()))
2674inline std::string escape(std::string s)
2676 replace_substring(s,
"~",
"~0");
2677 replace_substring(s,
"/",
"~1");
2688static void unescape(std::string& s)
2690 replace_substring(s,
"~1",
"/");
2691 replace_substring(s,
"~0",
"~");
2710 std::size_t chars_read_total = 0;
2712 std::size_t chars_read_current_line = 0;
2714 std::size_t lines_read = 0;
2717 constexpr operator size_t()
const
2719 return chars_read_total;
2765class exception :
public std::exception
2769 const char* what() const noexcept
override
2778 JSON_HEDLEY_NON_NULL(3)
2779 exception(
int id_, const
char* what_arg) :
id(id_), m(what_arg) {}
2781 static std::string name(
const std::string& ename,
int id_)
2783 return "[json.exception." + ename +
"." + std::to_string(id_) +
"] ";
2786 template<
typename BasicJsonType>
2787 static std::string diagnostics(
const BasicJsonType& leaf_element)
2790 std::vector<std::string> tokens;
2791 for (
const auto* current = &leaf_element; current->m_parent !=
nullptr; current = current->m_parent)
2793 switch (current->m_parent->type())
2795 case value_t::array:
2797 for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
2799 if (¤t->m_parent->m_value.array->operator[](i) == current)
2801 tokens.emplace_back(std::to_string(i));
2808 case value_t::object:
2810 for (
const auto& element : *current->m_parent->m_value.object)
2812 if (&element.second == current)
2814 tokens.emplace_back(element.first.c_str());
2822 case value_t::string:
2823 case value_t::boolean:
2824 case value_t::number_integer:
2825 case value_t::number_unsigned:
2826 case value_t::number_float:
2827 case value_t::binary:
2828 case value_t::discarded:
2839 return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
2840 [](
const std::string & a,
const std::string & b)
2842 return a +
"/" + detail::escape(b);
2845 static_cast<void>(leaf_element);
2852 std::runtime_error m;
2900class parse_error :
public exception
2912 template<
typename BasicJsonType>
2913 static parse_error create(
int id_,
const position_t& pos,
const std::string& what_arg,
const BasicJsonType& context)
2915 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2916 position_string(pos) +
": " + exception::diagnostics(context) + what_arg;
2917 return parse_error(id_, pos.chars_read_total, w.c_str());
2920 template<
typename BasicJsonType>
2921 static parse_error create(
int id_, std::size_t byte_,
const std::string& what_arg,
const BasicJsonType& context)
2923 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2924 (byte_ != 0 ? (
" at byte " + std::to_string(byte_)) :
"") +
2925 ": " + exception::diagnostics(context) + what_arg;
2926 return parse_error(id_, byte_, w.c_str());
2938 const std::size_t byte;
2941 parse_error(
int id_, std::size_t byte_,
const char* what_arg)
2942 : exception(id_, what_arg), byte(byte_) {}
2944 static std::string position_string(
const position_t& pos)
2946 return " at line " + std::to_string(pos.lines_read + 1) +
2947 ", column " + std::to_string(pos.chars_read_current_line);
2988class invalid_iterator :
public exception
2991 template<
typename BasicJsonType>
2992 static invalid_iterator create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2994 std::string w = exception::name(
"invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
2995 return invalid_iterator(id_, w.c_str());
2999 JSON_HEDLEY_NON_NULL(3)
3000 invalid_iterator(
int id_, const
char* what_arg)
3001 : exception(id_, what_arg) {}
3043class type_error :
public exception
3046 template<
typename BasicJsonType>
3047 static type_error create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
3049 std::string w = exception::name(
"type_error", id_) + exception::diagnostics(context) + what_arg;
3050 return type_error(id_, w.c_str());
3054 JSON_HEDLEY_NON_NULL(3)
3055 type_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3091class out_of_range :
public exception
3094 template<
typename BasicJsonType>
3095 static out_of_range create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
3097 std::string w = exception::name(
"out_of_range", id_) + exception::diagnostics(context) + what_arg;
3098 return out_of_range(id_, w.c_str());
3102 JSON_HEDLEY_NON_NULL(3)
3103 out_of_range(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3130class other_error :
public exception
3133 template<
typename BasicJsonType>
3134 static other_error create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
3136 std::string w = exception::name(
"other_error", id_) + exception::diagnostics(context) + what_arg;
3137 return other_error(id_, w.c_str());
3141 JSON_HEDLEY_NON_NULL(3)
3142 other_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3153#include <type_traits>
3165using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3167#ifdef JSON_HAS_CPP_14
3170using std::enable_if_t;
3171using std::index_sequence;
3172using std::make_index_sequence;
3173using std::index_sequence_for;
3178template<
bool B,
typename T =
void>
3179using enable_if_t =
typename std::enable_if<B, T>::type;
3205template <
typename T, T... Ints>
3206struct integer_sequence
3208 using value_type = T;
3209 static constexpr std::size_t size() noexcept
3211 return sizeof...(Ints);
3220template <
size_t... Ints>
3221using index_sequence = integer_sequence<size_t, Ints...>;
3223namespace utility_internal
3226template <
typename Seq,
size_t SeqSize,
size_t Rem>
3230template <
typename T, T... Ints,
size_t SeqSize>
3231struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3233 using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3236template <
typename T, T... Ints,
size_t SeqSize>
3237struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3239 using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3244template <
typename T,
size_t N>
3248 typename Extend <
typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3251template <
typename T>
3254 using type = integer_sequence<T>;
3266template <
typename T, T N>
3267using make_integer_sequence =
typename utility_internal::Gen<T, N>::type;
3275using make_index_sequence = make_integer_sequence<size_t, N>;
3282template <
typename... Ts>
3283using index_sequence_for = make_index_sequence<
sizeof...(Ts)>;
3290template<
unsigned N>
struct priority_tag : priority_tag < N - 1 > {};
3291template<>
struct priority_tag<0> {};
3297 static constexpr T value{};
3301constexpr T static_const<T>::value;
3314template <
class T>
struct identity_tag {};
3322#include <type_traits>
3343template<
typename It,
typename =
void>
3344struct iterator_types {};
3346template<
typename It>
3347struct iterator_types <
3349 void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3350 typename It::reference, typename It::iterator_category >>
3352 using difference_type =
typename It::difference_type;
3353 using value_type =
typename It::value_type;
3354 using pointer =
typename It::pointer;
3355 using reference =
typename It::reference;
3356 using iterator_category =
typename It::iterator_category;
3361template<
typename T,
typename =
void>
3362struct iterator_traits
3367struct iterator_traits < T, enable_if_t < !
std::is_pointer<T>::value >>
3373struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3375 using iterator_category = std::random_access_iterator_tag;
3376 using value_type = T;
3377 using difference_type = ptrdiff_t;
3379 using reference = T&;
3411#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3412#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3434template<
typename T =
void,
typename SFINAE =
void>
3435struct adl_serializer;
3437template<
template<
typename U,
typename V,
typename... Args>
class ObjectType =
3439 template<
typename U,
typename... Args>
class ArrayType = std::vector,
3440 class StringType = std::string,
class BooleanType = bool,
3441 class NumberIntegerType = std::int64_t,
3442 class NumberUnsignedType = std::uint64_t,
3443 class NumberFloatType = double,
3444 template<
typename U>
class AllocatorType = std::allocator,
3445 template<
typename T,
typename SFINAE =
void>
class JSONSerializer =
3447 class BinaryType = std::vector<std::uint8_t>>
3461template<
typename BasicJsonType>
3474template<
class Key,
class T,
class IgnoredLess,
class Allocator>
3516template<
typename>
struct is_basic_json : std::false_type {};
3518NLOHMANN_BASIC_JSON_TPL_DECLARATION
3519struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3529struct is_json_ref : std::false_type {};
3532struct is_json_ref<json_ref<T>> : std::true_type {};
3539using mapped_type_t =
typename T::mapped_type;
3542using key_type_t =
typename T::key_type;
3545using value_type_t =
typename T::value_type;
3548using difference_type_t =
typename T::difference_type;
3551using pointer_t =
typename T::pointer;
3554using reference_t =
typename T::reference;
3557using iterator_category_t =
typename T::iterator_category;
3559template<
typename T,
typename... Args>
3560using to_json_function =
decltype(T::to_json(std::declval<Args>()...));
3562template<
typename T,
typename... Args>
3563using from_json_function =
decltype(T::from_json(std::declval<Args>()...));
3565template<
typename T,
typename U>
3566using get_template_function =
decltype(std::declval<T>().template get<U>());
3569template<
typename BasicJsonType,
typename T,
typename =
void>
3570struct has_from_json : std::false_type {};
3576template <
typename BasicJsonType,
typename T>
3579 static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3582template<
typename BasicJsonType,
typename T>
3583struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3585 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3587 static constexpr bool value =
3588 is_detected_exact<void, from_json_function, serializer,
3589 const BasicJsonType&, T&>::value;
3594template<
typename BasicJsonType,
typename T,
typename =
void>
3595struct has_non_default_from_json : std::false_type {};
3597template<
typename BasicJsonType,
typename T>
3598struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3600 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3602 static constexpr bool value =
3603 is_detected_exact<T, from_json_function, serializer,
3604 const BasicJsonType&>::value;
3609template<
typename BasicJsonType,
typename T,
typename =
void>
3610struct has_to_json : std::false_type {};
3612template<
typename BasicJsonType,
typename T>
3613struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3615 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3617 static constexpr bool value =
3618 is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3628template<
class...>
struct conjunction : std::true_type { };
3629template<
class B1>
struct conjunction<B1> : B1 { };
3630template<
class B1,
class... Bn>
3631struct conjunction<B1, Bn...>
3632: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3635template<
class B>
struct negation : std::integral_constant < bool, !B::value > { };
3640template <
typename T>
3641struct is_default_constructible : std::is_default_constructible<T> {};
3643template <
typename T1,
typename T2>
3644struct is_default_constructible<
std::pair<T1, T2>>
3645 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3647template <
typename T1,
typename T2>
3648struct is_default_constructible<const
std::pair<T1, T2>>
3649 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3651template <
typename... Ts>
3652struct is_default_constructible<
std::tuple<Ts...>>
3653 : conjunction<is_default_constructible<Ts>...> {};
3655template <
typename... Ts>
3656struct is_default_constructible<const
std::tuple<Ts...>>
3657 : conjunction<is_default_constructible<Ts>...> {};
3660template <
typename T,
typename... Args>
3661struct is_constructible : std::is_constructible<T, Args...> {};
3663template <
typename T1,
typename T2>
3664struct is_constructible<
std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3666template <
typename T1,
typename T2>
3667struct is_constructible<const
std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3669template <
typename... Ts>
3670struct is_constructible<
std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3672template <
typename... Ts>
3673struct is_constructible<const
std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3676template<
typename T,
typename =
void>
3677struct is_iterator_traits : std::false_type {};
3680struct is_iterator_traits<iterator_traits<T>>
3683 using traits = iterator_traits<T>;
3686 static constexpr auto value =
3687 is_detected<value_type_t, traits>::value &&
3688 is_detected<difference_type_t, traits>::value &&
3689 is_detected<pointer_t, traits>::value &&
3690 is_detected<iterator_category_t, traits>::value &&
3691 is_detected<reference_t, traits>::value;
3698 using t_ref =
typename std::add_lvalue_reference<T>::type;
3700 using iterator = detected_t<result_of_begin, t_ref>;
3701 using sentinel = detected_t<result_of_end, t_ref>;
3706 static constexpr auto is_iterator_begin =
3707 is_iterator_traits<iterator_traits<iterator>>::value;
3710 static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
3714using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3717using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
3723template<
typename T,
typename =
void>
3724struct is_complete_type : std::false_type {};
3727struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3729template<
typename BasicJsonType,
typename CompatibleObjectType,
3731struct is_compatible_object_type_impl : std::false_type {};
3733template<
typename BasicJsonType,
typename CompatibleObjectType>
3734struct is_compatible_object_type_impl <
3735 BasicJsonType, CompatibleObjectType,
3736 enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3737 is_detected<key_type_t, CompatibleObjectType>::value >>
3739 using object_t =
typename BasicJsonType::object_t;
3742 static constexpr bool value =
3743 is_constructible<
typename object_t::key_type,
3744 typename CompatibleObjectType::key_type>::value &&
3745 is_constructible<
typename object_t::mapped_type,
3746 typename CompatibleObjectType::mapped_type>::value;
3749template<
typename BasicJsonType,
typename CompatibleObjectType>
3750struct is_compatible_object_type
3751 : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3753template<
typename BasicJsonType,
typename ConstructibleObjectType,
3755struct is_constructible_object_type_impl : std::false_type {};
3757template<
typename BasicJsonType,
typename ConstructibleObjectType>
3758struct is_constructible_object_type_impl <
3759 BasicJsonType, ConstructibleObjectType,
3760 enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3761 is_detected<key_type_t, ConstructibleObjectType>::value >>
3763 using object_t =
typename BasicJsonType::object_t;
3765 static constexpr bool value =
3766 (is_default_constructible<ConstructibleObjectType>::value &&
3767 (std::is_move_assignable<ConstructibleObjectType>::value ||
3768 std::is_copy_assignable<ConstructibleObjectType>::value) &&
3769 (is_constructible<
typename ConstructibleObjectType::key_type,
3770 typename object_t::key_type>::value &&
3772 typename object_t::mapped_type,
3773 typename ConstructibleObjectType::mapped_type >::value)) ||
3774 (has_from_json<BasicJsonType,
3775 typename ConstructibleObjectType::mapped_type>::value ||
3776 has_non_default_from_json <
3778 typename ConstructibleObjectType::mapped_type >::value);
3781template<
typename BasicJsonType,
typename ConstructibleObjectType>
3782struct is_constructible_object_type
3783 : is_constructible_object_type_impl<BasicJsonType,
3784 ConstructibleObjectType> {};
3786template<
typename BasicJsonType,
typename CompatibleStringType>
3787struct is_compatible_string_type
3789 static constexpr auto value =
3790 is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3793template<
typename BasicJsonType,
typename ConstructibleStringType>
3794struct is_constructible_string_type
3796 static constexpr auto value =
3797 is_constructible<ConstructibleStringType,
3798 typename BasicJsonType::string_t>::value;
3801template<
typename BasicJsonType,
typename CompatibleArrayType,
typename =
void>
3802struct is_compatible_array_type_impl : std::false_type {};
3804template<
typename BasicJsonType,
typename CompatibleArrayType>
3805struct is_compatible_array_type_impl <
3806 BasicJsonType, CompatibleArrayType,
3808 is_detected<iterator_t, CompatibleArrayType>::value&&
3809 is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
3812 !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3814 static constexpr bool value =
3815 is_constructible<BasicJsonType,
3816 range_value_t<CompatibleArrayType>>::value;
3819template<
typename BasicJsonType,
typename CompatibleArrayType>
3820struct is_compatible_array_type
3821 : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3823template<
typename BasicJsonType,
typename ConstructibleArrayType,
typename =
void>
3824struct is_constructible_array_type_impl : std::false_type {};
3826template<
typename BasicJsonType,
typename ConstructibleArrayType>
3827struct is_constructible_array_type_impl <
3828 BasicJsonType, ConstructibleArrayType,
3829 enable_if_t<
std::is_same<ConstructibleArrayType,
3830 typename BasicJsonType::value_type>::value >>
3831 : std::true_type {};
3833template<
typename BasicJsonType,
typename ConstructibleArrayType>
3834struct is_constructible_array_type_impl <
3835 BasicJsonType, ConstructibleArrayType,
3836 enable_if_t < !
std::is_same<ConstructibleArrayType,
3837 typename BasicJsonType::value_type>::value&&
3838 !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3839 is_default_constructible<ConstructibleArrayType>::value&&
3840(std::is_move_assignable<ConstructibleArrayType>::value ||
3841 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3842is_detected<iterator_t, ConstructibleArrayType>::value&&
3843is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
3844is_detected<range_value_t, ConstructibleArrayType>::value&&
3847!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
3849 detected_t<range_value_t, ConstructibleArrayType >>::value >>
3851 using value_type = range_value_t<ConstructibleArrayType>;
3853 static constexpr bool value =
3854 std::is_same<value_type,
3855 typename BasicJsonType::array_t::value_type>::value ||
3856 has_from_json<BasicJsonType,
3857 value_type>::value ||
3858 has_non_default_from_json <
3860 value_type >::value;
3863template<
typename BasicJsonType,
typename ConstructibleArrayType>
3864struct is_constructible_array_type
3865 : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3867template<
typename RealIntegerType,
typename CompatibleNumberIntegerType,
3869struct is_compatible_integer_type_impl : std::false_type {};
3871template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3872struct is_compatible_integer_type_impl <
3873 RealIntegerType, CompatibleNumberIntegerType,
3874 enable_if_t <
std::is_integral<RealIntegerType>::value&&
3875 std::is_integral<CompatibleNumberIntegerType>::value&&
3876 !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3879 using RealLimits = std::numeric_limits<RealIntegerType>;
3880 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3882 static constexpr auto value =
3883 is_constructible<RealIntegerType,
3884 CompatibleNumberIntegerType>::value &&
3885 CompatibleLimits::is_integer &&
3886 RealLimits::is_signed == CompatibleLimits::is_signed;
3889template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3890struct is_compatible_integer_type
3891 : is_compatible_integer_type_impl<RealIntegerType,
3892 CompatibleNumberIntegerType> {};
3894template<
typename BasicJsonType,
typename CompatibleType,
typename =
void>
3895struct is_compatible_type_impl: std::false_type {};
3897template<
typename BasicJsonType,
typename CompatibleType>
3898struct is_compatible_type_impl <
3899 BasicJsonType, CompatibleType,
3900 enable_if_t<is_complete_type<CompatibleType>::value >>
3902 static constexpr bool value =
3903 has_to_json<BasicJsonType, CompatibleType>::value;
3906template<
typename BasicJsonType,
typename CompatibleType>
3907struct is_compatible_type
3908 : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3910template<
typename T1,
typename T2>
3911struct is_constructible_tuple : std::false_type {};
3913template<
typename T1,
typename... Args>
3914struct is_constructible_tuple<T1,
std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3918template <
typename T>
3919struct is_ordered_map
3928 template <
typename C>
static one test(
decltype(&C::capacity) ) ;
3929 template <
typename C>
static two test(...);
3931 enum { value =
sizeof(test<T>(
nullptr)) ==
sizeof(
char) };
3935template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value,
int > = 0 >
3936T conditional_static_cast(U value)
3938 return static_cast<T
>(value);
3941template<typename T, typename U, enable_if_t<std::is_same<T, U>::value,
int> = 0>
3942T conditional_static_cast(U value)
3953#ifdef JSON_HAS_CPP_17
3954 #include <filesystem>
3961template<
typename BasicJsonType>
3962void from_json(
const BasicJsonType& j,
typename std::nullptr_t& n)
3964 if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3966 JSON_THROW(type_error::create(302,
"type must be null, but is " + std::string(j.type_name()), j));
3972template <
typename BasicJsonType,
typename ArithmeticType,
3973 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3974 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3976void get_arithmetic_value(
const BasicJsonType& j, ArithmeticType& val)
3978 switch (
static_cast<value_t
>(j))
3980 case value_t::number_unsigned:
3982 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3985 case value_t::number_integer:
3987 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3990 case value_t::number_float:
3992 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3997 case value_t::object:
3998 case value_t::array:
3999 case value_t::string:
4000 case value_t::boolean:
4001 case value_t::binary:
4002 case value_t::discarded:
4004 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name()), j));
4008template<
typename BasicJsonType>
4009void from_json(
const BasicJsonType& j,
typename BasicJsonType::boolean_t& b)
4011 if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
4013 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(j.type_name()), j));
4015 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
4018template<
typename BasicJsonType>
4019void from_json(
const BasicJsonType& j,
typename BasicJsonType::string_t& s)
4021 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4023 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
4025 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4029 typename BasicJsonType,
typename ConstructibleStringType,
4031 is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
4032 !std::is_same<
typename BasicJsonType::string_t,
4033 ConstructibleStringType>::value,
4035void from_json(
const BasicJsonType& j, ConstructibleStringType& s)
4037 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4039 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
4042 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4045template<
typename BasicJsonType>
4046void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_float_t& val)
4048 get_arithmetic_value(j, val);
4051template<
typename BasicJsonType>
4052void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_unsigned_t& val)
4054 get_arithmetic_value(j, val);
4057template<
typename BasicJsonType>
4058void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_integer_t& val)
4060 get_arithmetic_value(j, val);
4063template<
typename BasicJsonType,
typename EnumType,
4064 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
4065void from_json(
const BasicJsonType& j, EnumType& e)
4067 typename std::underlying_type<EnumType>::type val;
4068 get_arithmetic_value(j, val);
4069 e =
static_cast<EnumType
>(val);
4073template<
typename BasicJsonType,
typename T,
typename Allocator,
4074 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
4075void from_json(
const BasicJsonType& j, std::forward_list<T, Allocator>& l)
4077 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4079 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4082 std::transform(j.rbegin(), j.rend(),
4083 std::front_inserter(l), [](
const BasicJsonType & i)
4085 return i.template get<T>();
4090template<
typename BasicJsonType,
typename T,
4091 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
4092void from_json(
const BasicJsonType& j, std::valarray<T>& l)
4094 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4096 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4099 std::transform(j.begin(), j.end(), std::begin(l),
4100 [](
const BasicJsonType & elem)
4102 return elem.template get<T>();
4106template<
typename BasicJsonType,
typename T, std::
size_t N>
4107auto from_json(
const BasicJsonType& j, T (&arr)[N])
4108->
decltype(j.template get<T>(), void())
4110 for (std::size_t i = 0; i < N; ++i)
4112 arr[i] = j.at(i).template get<T>();
4116template<
typename BasicJsonType>
4117void from_json_array_impl(
const BasicJsonType& j,
typename BasicJsonType::array_t& arr, priority_tag<3> )
4119 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
4122template<
typename BasicJsonType,
typename T, std::
size_t N>
4123auto from_json_array_impl(
const BasicJsonType& j, std::array<T, N>& arr,
4125->
decltype(j.template get<T>(), void())
4127 for (std::size_t i = 0; i < N; ++i)
4129 arr[i] = j.at(i).template get<T>();
4133template<
typename BasicJsonType,
typename ConstructibleArrayType,
4135 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4137auto from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> )
4139 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4140 j.template get<typename ConstructibleArrayType::value_type>(),
4145 ConstructibleArrayType ret;
4146 ret.reserve(j.size());
4147 std::transform(j.begin(), j.end(),
4148 std::inserter(ret, end(ret)), [](
const BasicJsonType & i)
4152 return i.template get<typename ConstructibleArrayType::value_type>();
4154 arr = std::move(ret);
4157template<
typename BasicJsonType,
typename ConstructibleArrayType,
4159 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4161void from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr,
4166 ConstructibleArrayType ret;
4168 j.begin(), j.end(), std::inserter(ret, end(ret)),
4169 [](
const BasicJsonType & i)
4173 return i.template get<typename ConstructibleArrayType::value_type>();
4175 arr = std::move(ret);
4178template <
typename BasicJsonType,
typename ConstructibleArrayType,
4180 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
4181 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
4182 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4183 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4184 !is_basic_json<ConstructibleArrayType>::value,
4186auto from_json(
const BasicJsonType& j, ConstructibleArrayType& arr)
4187->
decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
4188j.template get<typename ConstructibleArrayType::value_type>(),
4191 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4193 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4196 from_json_array_impl(j, arr, priority_tag<3> {});
4199template <
typename BasicJsonType,
typename T, std::size_t... Idx >
4200std::array<T,
sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4201 identity_tag<std::array<T,
sizeof...(Idx)>> , index_sequence<Idx...> )
4203 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4206template <
typename BasicJsonType,
typename T, std::
size_t N >
4207auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4208->
decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4210 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4212 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4215 return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4218template<
typename BasicJsonType>
4219void from_json(
const BasicJsonType& j,
typename BasicJsonType::binary_t& bin)
4221 if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
4223 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(j.type_name()), j));
4226 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4229template<
typename BasicJsonType,
typename ConstructibleObjectType,
4230 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value,
int> = 0>
4231void from_json(
const BasicJsonType& j, ConstructibleObjectType& obj)
4233 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
4235 JSON_THROW(type_error::create(302,
"type must be object, but is " + std::string(j.type_name()), j));
4238 ConstructibleObjectType ret;
4239 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4240 using value_type =
typename ConstructibleObjectType::value_type;
4242 inner_object->begin(), inner_object->end(),
4243 std::inserter(ret, ret.begin()),
4244 [](
typename BasicJsonType::object_t::value_type
const & p)
4246 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4248 obj = std::move(ret);
4255template <
typename BasicJsonType,
typename ArithmeticType,
4257 std::is_arithmetic<ArithmeticType>::value&&
4258 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4259 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4260 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4261 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4263void from_json(
const BasicJsonType& j, ArithmeticType& val)
4265 switch (
static_cast<value_t
>(j))
4267 case value_t::number_unsigned:
4269 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4272 case value_t::number_integer:
4274 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4277 case value_t::number_float:
4279 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4282 case value_t::boolean:
4284 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4289 case value_t::object:
4290 case value_t::array:
4291 case value_t::string:
4292 case value_t::binary:
4293 case value_t::discarded:
4295 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name()), j));
4299template<
typename BasicJsonType,
typename... Args, std::size_t... Idx>
4300std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> )
4302 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).
template get<Args>()...);
4305template <
typename BasicJsonType,
class A1,
class A2 >
4306std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> , priority_tag<0> )
4308 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4309 std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4312template<
typename BasicJsonType,
typename A1,
typename A2>
4313void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> )
4315 p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
4318template<
typename BasicJsonType,
typename... Args>
4319std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> , priority_tag<2> )
4321 return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4324template<
typename BasicJsonType,
typename... Args>
4325void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> )
4327 t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4330template<
typename BasicJsonType,
typename TupleRelated>
4331auto from_json(BasicJsonType&& j, TupleRelated&& t)
4332->
decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
4334 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4336 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4339 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4342template <
typename BasicJsonType,
typename Key,
typename Value,
typename Compare,
typename Allocator,
4343 typename = enable_if_t < !std::is_constructible <
4344 typename BasicJsonType::string_t, Key >::value >>
4345void from_json(
const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4347 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4349 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4352 for (
const auto& p : j)
4354 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4356 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name()), j));
4358 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4362template <
typename BasicJsonType,
typename Key,
typename Value,
typename Hash,
typename KeyEqual,
typename Allocator,
4363 typename = enable_if_t < !std::is_constructible <
4364 typename BasicJsonType::string_t, Key >::value >>
4365void from_json(
const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
4367 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4369 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4372 for (
const auto& p : j)
4374 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4376 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name()), j));
4378 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4382#ifdef JSON_HAS_CPP_17
4383template<
typename BasicJsonType>
4384void from_json(
const BasicJsonType& j, std::filesystem::path& p)
4386 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4388 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
4390 p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4396 template<
typename BasicJsonType,
typename T>
4397 auto operator()(
const BasicJsonType& j, T&& val)
const
4398 noexcept(
noexcept(
from_json(j, std::forward<T>(val))))
4399 ->
decltype(
from_json(j, std::forward<T>(val)))
4401 return from_json(j, std::forward<T>(val));
4411constexpr const auto&
from_json = detail::static_const<detail::from_json_fn>::value;
4422#include <type_traits>
4447template<
typename string_type>
4448void int_to_string( string_type& target, std::size_t value )
4451 using std::to_string;
4454template<
typename IteratorType>
class iteration_proxy_value
4457 using difference_type = std::ptrdiff_t;
4458 using value_type = iteration_proxy_value;
4459 using pointer = value_type * ;
4460 using reference = value_type & ;
4461 using iterator_category = std::input_iterator_tag;
4462 using string_type =
typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
4466 IteratorType anchor;
4468 std::size_t array_index = 0;
4470 mutable std::size_t array_index_last = 0;
4472 mutable string_type array_index_str =
"0";
4474 const string_type empty_str{};
4477 explicit iteration_proxy_value(IteratorType it) noexcept
4478 : anchor(std::move(it))
4482 iteration_proxy_value& operator*()
4488 iteration_proxy_value& operator++()
4497 bool operator==(
const iteration_proxy_value& o)
const
4499 return anchor == o.anchor;
4503 bool operator!=(
const iteration_proxy_value& o)
const
4505 return anchor != o.anchor;
4509 const string_type& key()
const
4511 JSON_ASSERT(anchor.m_object !=
nullptr);
4513 switch (anchor.m_object->type())
4516 case value_t::array:
4518 if (array_index != array_index_last)
4520 int_to_string( array_index_str, array_index );
4521 array_index_last = array_index;
4523 return array_index_str;
4527 case value_t::object:
4528 return anchor.key();
4532 case value_t::string:
4533 case value_t::boolean:
4534 case value_t::number_integer:
4535 case value_t::number_unsigned:
4536 case value_t::number_float:
4537 case value_t::binary:
4538 case value_t::discarded:
4545 typename IteratorType::reference value()
const
4547 return anchor.value();
4552template<
typename IteratorType>
class iteration_proxy
4556 typename IteratorType::reference container;
4560 explicit iteration_proxy(
typename IteratorType::reference cont) noexcept
4561 : container(cont) {}
4564 iteration_proxy_value<IteratorType> begin() noexcept
4566 return iteration_proxy_value<IteratorType>(container.begin());
4570 iteration_proxy_value<IteratorType> end() noexcept
4572 return iteration_proxy_value<IteratorType>(container.end());
4578template<std::
size_t N,
typename IteratorType, enable_if_t<N == 0,
int> = 0>
4579auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) ->
decltype(i.key())
4586template<std::
size_t N,
typename IteratorType, enable_if_t<N == 1,
int> = 0>
4587auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) ->
decltype(i.value())
4600#if defined(__clang__)
4602 #pragma clang diagnostic push
4603 #pragma clang diagnostic ignored "-Wmismatched-tags"
4605template<
typename IteratorType>
4606class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
4607 :
public std::integral_constant<std::size_t, 2> {};
4609template<std::
size_t N,
typename IteratorType>
4610class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
4613 using type =
decltype(
4614 get<N>(std::declval <
4615 ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
4617#if defined(__clang__)
4618 #pragma clang diagnostic pop
4629#ifdef JSON_HAS_CPP_17
4630 #include <filesystem>
4648template<value_t>
struct external_constructor;
4651struct external_constructor<value_t::boolean>
4653 template<
typename BasicJsonType>
4654 static void construct(BasicJsonType& j,
typename BasicJsonType::boolean_t b)
noexcept
4656 j.m_value.destroy(j.m_type);
4657 j.m_type = value_t::boolean;
4659 j.assert_invariant();
4664struct external_constructor<value_t::string>
4666 template<
typename BasicJsonType>
4667 static void construct(BasicJsonType& j,
const typename BasicJsonType::string_t& s)
4669 j.m_value.destroy(j.m_type);
4670 j.m_type = value_t::string;
4672 j.assert_invariant();
4675 template<
typename BasicJsonType>
4676 static void construct(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4678 j.m_value.destroy(j.m_type);
4679 j.m_type = value_t::string;
4680 j.m_value = std::move(s);
4681 j.assert_invariant();
4684 template <
typename BasicJsonType,
typename CompatibleStringType,
4685 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4687 static void construct(BasicJsonType& j,
const CompatibleStringType& str)
4689 j.m_value.destroy(j.m_type);
4690 j.m_type = value_t::string;
4691 j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4692 j.assert_invariant();
4697struct external_constructor<value_t::binary>
4699 template<
typename BasicJsonType>
4700 static void construct(BasicJsonType& j,
const typename BasicJsonType::binary_t& b)
4702 j.m_value.destroy(j.m_type);
4703 j.m_type = value_t::binary;
4704 j.m_value =
typename BasicJsonType::binary_t(b);
4705 j.assert_invariant();
4708 template<
typename BasicJsonType>
4709 static void construct(BasicJsonType& j,
typename BasicJsonType::binary_t&& b)
4711 j.m_value.destroy(j.m_type);
4712 j.m_type = value_t::binary;
4713 j.m_value =
typename BasicJsonType::binary_t(std::move(b));
4714 j.assert_invariant();
4719struct external_constructor<value_t::number_float>
4721 template<
typename BasicJsonType>
4722 static void construct(BasicJsonType& j,
typename BasicJsonType::number_float_t val)
noexcept
4724 j.m_value.destroy(j.m_type);
4725 j.m_type = value_t::number_float;
4727 j.assert_invariant();
4732struct external_constructor<value_t::number_unsigned>
4734 template<
typename BasicJsonType>
4735 static void construct(BasicJsonType& j,
typename BasicJsonType::number_unsigned_t val)
noexcept
4737 j.m_value.destroy(j.m_type);
4738 j.m_type = value_t::number_unsigned;
4740 j.assert_invariant();
4745struct external_constructor<value_t::number_integer>
4747 template<
typename BasicJsonType>
4748 static void construct(BasicJsonType& j,
typename BasicJsonType::number_integer_t val)
noexcept
4750 j.m_value.destroy(j.m_type);
4751 j.m_type = value_t::number_integer;
4753 j.assert_invariant();
4758struct external_constructor<value_t::array>
4760 template<
typename BasicJsonType>
4761 static void construct(BasicJsonType& j,
const typename BasicJsonType::array_t& arr)
4763 j.m_value.destroy(j.m_type);
4764 j.m_type = value_t::array;
4767 j.assert_invariant();
4770 template<
typename BasicJsonType>
4771 static void construct(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4773 j.m_value.destroy(j.m_type);
4774 j.m_type = value_t::array;
4775 j.m_value = std::move(arr);
4777 j.assert_invariant();
4780 template <
typename BasicJsonType,
typename CompatibleArrayType,
4781 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4783 static void construct(BasicJsonType& j,
const CompatibleArrayType& arr)
4788 j.m_value.destroy(j.m_type);
4789 j.m_type = value_t::array;
4790 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4792 j.assert_invariant();
4795 template<
typename BasicJsonType>
4796 static void construct(BasicJsonType& j,
const std::vector<bool>& arr)
4798 j.m_value.destroy(j.m_type);
4799 j.m_type = value_t::array;
4800 j.m_value = value_t::array;
4801 j.m_value.array->reserve(arr.size());
4802 for (
const bool x : arr)
4804 j.m_value.array->push_back(x);
4805 j.set_parent(j.m_value.array->back());
4807 j.assert_invariant();
4810 template<
typename BasicJsonType,
typename T,
4811 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4812 static void construct(BasicJsonType& j,
const std::valarray<T>& arr)
4814 j.m_value.destroy(j.m_type);
4815 j.m_type = value_t::array;
4816 j.m_value = value_t::array;
4817 j.m_value.array->resize(arr.size());
4820 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4823 j.assert_invariant();
4828struct external_constructor<value_t::object>
4830 template<
typename BasicJsonType>
4831 static void construct(BasicJsonType& j,
const typename BasicJsonType::object_t& obj)
4833 j.m_value.destroy(j.m_type);
4834 j.m_type = value_t::object;
4837 j.assert_invariant();
4840 template<
typename BasicJsonType>
4841 static void construct(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4843 j.m_value.destroy(j.m_type);
4844 j.m_type = value_t::object;
4845 j.m_value = std::move(obj);
4847 j.assert_invariant();
4850 template <
typename BasicJsonType,
typename CompatibleObjectType,
4851 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value,
int > = 0 >
4852 static void construct(BasicJsonType& j,
const CompatibleObjectType& obj)
4857 j.m_value.destroy(j.m_type);
4858 j.m_type = value_t::object;
4859 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4861 j.assert_invariant();
4869template<
typename BasicJsonType,
typename T,
4870 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value,
int> = 0>
4871void to_json(BasicJsonType& j, T b)
noexcept
4873 external_constructor<value_t::boolean>::construct(j, b);
4876template<
typename BasicJsonType,
typename CompatibleString,
4877 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value,
int> = 0>
4878void to_json(BasicJsonType& j,
const CompatibleString& s)
4880 external_constructor<value_t::string>::construct(j, s);
4883template<
typename BasicJsonType>
4884void to_json(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4886 external_constructor<value_t::string>::construct(j, std::move(s));
4889template<
typename BasicJsonType,
typename FloatType,
4890 enable_if_t<std::is_floating_point<FloatType>::value,
int> = 0>
4891void to_json(BasicJsonType& j, FloatType val)
noexcept
4893 external_constructor<value_t::number_float>::construct(j,
static_cast<typename BasicJsonType::number_float_t
>(val));
4896template<
typename BasicJsonType,
typename CompatibleNumberUnsignedType,
4897 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value,
int> = 0>
4898void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val)
noexcept
4900 external_constructor<value_t::number_unsigned>::construct(j,
static_cast<typename BasicJsonType::number_unsigned_t
>(val));
4903template<
typename BasicJsonType,
typename CompatibleNumberIntegerType,
4904 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value,
int> = 0>
4905void to_json(BasicJsonType& j, CompatibleNumberIntegerType val)
noexcept
4907 external_constructor<value_t::number_integer>::construct(j,
static_cast<typename BasicJsonType::number_integer_t
>(val));
4910template<
typename BasicJsonType,
typename EnumType,
4911 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
4912void to_json(BasicJsonType& j, EnumType e)
noexcept
4914 using underlying_type =
typename std::underlying_type<EnumType>::type;
4915 external_constructor<value_t::number_integer>::construct(j,
static_cast<underlying_type
>(e));
4918template<
typename BasicJsonType>
4919void to_json(BasicJsonType& j,
const std::vector<bool>& e)
4921 external_constructor<value_t::array>::construct(j, e);
4924template <
typename BasicJsonType,
typename CompatibleArrayType,
4925 enable_if_t < is_compatible_array_type<BasicJsonType,
4926 CompatibleArrayType>::value&&
4927 !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4928 !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4929 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4930 !is_basic_json<CompatibleArrayType>::value,
4932void to_json(BasicJsonType& j,
const CompatibleArrayType& arr)
4934 external_constructor<value_t::array>::construct(j, arr);
4937template<
typename BasicJsonType>
4938void to_json(BasicJsonType& j,
const typename BasicJsonType::binary_t& bin)
4940 external_constructor<value_t::binary>::construct(j, bin);
4943template<
typename BasicJsonType,
typename T,
4944 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4945void to_json(BasicJsonType& j,
const std::valarray<T>& arr)
4947 external_constructor<value_t::array>::construct(j, std::move(arr));
4950template<
typename BasicJsonType>
4951void to_json(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4953 external_constructor<value_t::array>::construct(j, std::move(arr));
4956template <
typename BasicJsonType,
typename CompatibleObjectType,
4957 enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value,
int > = 0 >
4958void to_json(BasicJsonType& j,
const CompatibleObjectType& obj)
4960 external_constructor<value_t::object>::construct(j, obj);
4963template<
typename BasicJsonType>
4964void to_json(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4966 external_constructor<value_t::object>::construct(j, std::move(obj));
4970 typename BasicJsonType,
typename T, std::size_t N,
4971 enable_if_t < !std::is_constructible<
typename BasicJsonType::string_t,
4972 const T(&)[N]>::value,
4974void to_json(BasicJsonType& j,
const T(&arr)[N])
4976 external_constructor<value_t::array>::construct(j, arr);
4979template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value,
int > = 0 >
4980void to_json(BasicJsonType& j,
const std::pair<T1, T2>& p)
4982 j = { p.first, p.second };
4986template<
typename BasicJsonType,
typename T,
4987 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value,
int> = 0>
4988void to_json(BasicJsonType& j,
const T& b)
4990 j = { {b.key(), b.value()} };
4993template<
typename BasicJsonType,
typename Tuple, std::size_t... Idx>
4994void to_json_tuple_impl(BasicJsonType& j,
const Tuple& t, index_sequence<Idx...> )
4996 j = { std::get<Idx>(t)... };
4999template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value,
int > = 0>
5000void to_json(BasicJsonType& j,
const T& t)
5002 to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
5005#ifdef JSON_HAS_CPP_17
5006template<
typename BasicJsonType>
5007void to_json(BasicJsonType& j,
const std::filesystem::path& p)
5015 template<
typename BasicJsonType,
typename T>
5016 auto operator()(BasicJsonType& j, T&& val)
const noexcept(
noexcept(
to_json(j, std::forward<T>(val))))
5017 ->
decltype(
to_json(j, std::forward<T>(val)), void())
5019 return to_json(j, std::forward<T>(val));
5029constexpr const auto&
to_json = detail::static_const<detail::to_json_fn>::value;
5041template<
typename ValueType,
typename>
5055 template<
typename BasicJsonType,
typename TargetType = ValueType>
5056 static auto from_json(BasicJsonType && j, TargetType& val)
noexcept(
5057 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
5058 ->
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
5060 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
5075 template<
typename BasicJsonType,
typename TargetType = ValueType>
5077 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
5078 ->
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
5080 return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
5092 template<
typename BasicJsonType,
typename TargetType = ValueType>
5093 static auto to_json(BasicJsonType& j, TargetType && val)
noexcept(
5094 noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
5095 ->
decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
5097 ::nlohmann::to_json(j, std::forward<TargetType>(val));
5125template<
typename BinaryType>
5148 , m_subtype(subtype_)
5149 , m_has_subtype(
true)
5154 , m_subtype(subtype_)
5155 , m_has_subtype(
true)
5160 return std::tie(
static_cast<const BinaryType&
>(*
this), m_subtype, m_has_subtype) ==
5161 std::tie(
static_cast<const BinaryType&
>(rhs), rhs.m_subtype, rhs.m_has_subtype);
5166 return !(rhs == *
this);
5189 m_subtype = subtype_;
5190 m_has_subtype =
true;
5238 return m_has_subtype;
5263 m_has_subtype =
false;
5268 bool m_has_subtype =
false;
5284#include <functional>
5297inline std::size_t combine(std::size_t seed, std::size_t h)
noexcept
5299 seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
5314template<
typename BasicJsonType>
5315std::size_t hash(
const BasicJsonType& j)
5317 using string_t =
typename BasicJsonType::string_t;
5318 using number_integer_t =
typename BasicJsonType::number_integer_t;
5319 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5320 using number_float_t =
typename BasicJsonType::number_float_t;
5322 const auto type =
static_cast<std::size_t
>(j.type());
5325 case BasicJsonType::value_t::null:
5326 case BasicJsonType::value_t::discarded:
5328 return combine(type, 0);
5331 case BasicJsonType::value_t::object:
5333 auto seed = combine(type, j.size());
5334 for (
const auto& element : j.items())
5336 const auto h = std::hash<string_t> {}(element.key());
5337 seed = combine(seed, h);
5338 seed = combine(seed, hash(element.value()));
5343 case BasicJsonType::value_t::array:
5345 auto seed = combine(type, j.size());
5346 for (
const auto& element : j)
5348 seed = combine(seed, hash(element));
5353 case BasicJsonType::value_t::string:
5355 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5356 return combine(type, h);
5359 case BasicJsonType::value_t::boolean:
5361 const auto h = std::hash<bool> {}(j.template get<bool>());
5362 return combine(type, h);
5365 case BasicJsonType::value_t::number_integer:
5367 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
5368 return combine(type, h);
5371 case BasicJsonType::value_t::number_unsigned:
5373 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
5374 return combine(type, h);
5377 case BasicJsonType::value_t::number_float:
5379 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
5380 return combine(type, h);
5383 case BasicJsonType::value_t::binary:
5385 auto seed = combine(type, j.get_binary().size());
5386 const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
5387 seed = combine(seed, h);
5388 seed = combine(seed,
static_cast<std::size_t
>(j.get_binary().subtype()));
5389 for (
const auto byte : j.get_binary())
5391 seed = combine(seed, std::hash<std::uint8_t> {}(byte));
5433#include <type_traits>
5451enum class input_format_t {
json, cbor, msgpack, ubjson, bson };
5462class file_input_adapter
5465 using char_type = char;
5467 JSON_HEDLEY_NON_NULL(2)
5468 explicit file_input_adapter(
std::FILE* f) noexcept
5473 file_input_adapter(
const file_input_adapter&) =
delete;
5474 file_input_adapter(file_input_adapter&&) noexcept = default;
5475 file_input_adapter& operator=(const file_input_adapter&) = delete;
5476 file_input_adapter& operator=(file_input_adapter&&) = delete;
5477 ~file_input_adapter() = default;
5479 std::char_traits<
char>::int_type get_character() noexcept
5481 return std::fgetc(m_file);
5499class input_stream_adapter
5502 using char_type = char;
5504 ~input_stream_adapter()
5510 is->clear(is->rdstate() & std::ios::eofbit);
5514 explicit input_stream_adapter(std::istream& i)
5515 : is(&i), sb(i.rdbuf())
5519 input_stream_adapter(
const input_stream_adapter&) =
delete;
5520 input_stream_adapter& operator=(input_stream_adapter&) =
delete;
5521 input_stream_adapter& operator=(input_stream_adapter&&) =
delete;
5523 input_stream_adapter(input_stream_adapter&& rhs) noexcept
5524 : is(rhs.is), sb(rhs.sb)
5533 std::char_traits<char>::int_type get_character()
5535 auto res = sb->sbumpc();
5537 if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
5539 is->clear(is->rdstate() | std::ios::eofbit);
5546 std::istream* is =
nullptr;
5547 std::streambuf* sb =
nullptr;
5553template<
typename IteratorType>
5554class iterator_input_adapter
5557 using char_type =
typename std::iterator_traits<IteratorType>::value_type;
5559 iterator_input_adapter(IteratorType first, IteratorType last)
5560 : current(
std::move(first)), end(
std::move(last))
5563 typename std::char_traits<char_type>::int_type get_character()
5565 if (JSON_HEDLEY_LIKELY(current != end))
5567 auto result = std::char_traits<char_type>::to_int_type(*current);
5568 std::advance(current, 1);
5572 return std::char_traits<char_type>::eof();
5576 IteratorType current;
5579 template<
typename BaseInputAdapter,
size_t T>
5580 friend struct wide_string_input_helper;
5584 return current == end;
5589template<
typename BaseInputAdapter,
size_t T>
5590struct wide_string_input_helper;
5592template<
typename BaseInputAdapter>
5593struct wide_string_input_helper<BaseInputAdapter, 4>
5596 static void fill_buffer(BaseInputAdapter& input,
5597 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5598 size_t& utf8_bytes_index,
5599 size_t& utf8_bytes_filled)
5601 utf8_bytes_index = 0;
5603 if (JSON_HEDLEY_UNLIKELY(input.empty()))
5605 utf8_bytes[0] = std::char_traits<char>::eof();
5606 utf8_bytes_filled = 1;
5611 const auto wc = input.get_character();
5616 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5617 utf8_bytes_filled = 1;
5619 else if (wc <= 0x7FF)
5621 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
5622 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5623 utf8_bytes_filled = 2;
5625 else if (wc <= 0xFFFF)
5627 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
5628 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5629 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5630 utf8_bytes_filled = 3;
5632 else if (wc <= 0x10FFFF)
5634 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | ((
static_cast<unsigned int>(wc) >> 18u) & 0x07u));
5635 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
5636 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5637 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5638 utf8_bytes_filled = 4;
5643 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5644 utf8_bytes_filled = 1;
5650template<
typename BaseInputAdapter>
5651struct wide_string_input_helper<BaseInputAdapter, 2>
5654 static void fill_buffer(BaseInputAdapter& input,
5655 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5656 size_t& utf8_bytes_index,
5657 size_t& utf8_bytes_filled)
5659 utf8_bytes_index = 0;
5661 if (JSON_HEDLEY_UNLIKELY(input.empty()))
5663 utf8_bytes[0] = std::char_traits<char>::eof();
5664 utf8_bytes_filled = 1;
5669 const auto wc = input.get_character();
5674 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5675 utf8_bytes_filled = 1;
5677 else if (wc <= 0x7FF)
5679 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u)));
5680 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5681 utf8_bytes_filled = 2;
5683 else if (0xD800 > wc || wc >= 0xE000)
5685 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u)));
5686 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5687 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5688 utf8_bytes_filled = 3;
5692 if (JSON_HEDLEY_UNLIKELY(!input.empty()))
5694 const auto wc2 =
static_cast<unsigned int>(input.get_character());
5695 const auto charcode = 0x10000u + (((
static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
5696 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | (charcode >> 18u));
5697 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 12u) & 0x3Fu));
5698 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 6u) & 0x3Fu));
5699 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (charcode & 0x3Fu));
5700 utf8_bytes_filled = 4;
5704 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5705 utf8_bytes_filled = 1;
5713template<
typename BaseInputAdapter,
typename W
ideCharType>
5714class wide_string_input_adapter
5717 using char_type = char;
5719 wide_string_input_adapter(BaseInputAdapter base)
5720 : base_adapter(base) {}
5722 typename std::char_traits<char>::int_type get_character() noexcept
5725 if (utf8_bytes_index == utf8_bytes_filled)
5727 fill_buffer<sizeof(WideCharType)>();
5729 JSON_ASSERT(utf8_bytes_filled > 0);
5730 JSON_ASSERT(utf8_bytes_index == 0);
5734 JSON_ASSERT(utf8_bytes_filled > 0);
5735 JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5736 return utf8_bytes[utf8_bytes_index++];
5740 BaseInputAdapter base_adapter;
5745 wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
5749 std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5752 std::size_t utf8_bytes_index = 0;
5754 std::size_t utf8_bytes_filled = 0;
5758template<
typename IteratorType,
typename Enable =
void>
5759struct iterator_input_adapter_factory
5761 using iterator_type = IteratorType;
5762 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5763 using adapter_type = iterator_input_adapter<iterator_type>;
5765 static adapter_type create(IteratorType first, IteratorType last)
5767 return adapter_type(std::move(first), std::move(last));
5772struct is_iterator_of_multibyte
5774 using value_type =
typename std::iterator_traits<T>::value_type;
5777 value =
sizeof(value_type) > 1
5781template<
typename IteratorType>
5782struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5784 using iterator_type = IteratorType;
5785 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5786 using base_adapter_type = iterator_input_adapter<iterator_type>;
5787 using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
5789 static adapter_type create(IteratorType first, IteratorType last)
5791 return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5796template<
typename IteratorType>
5797typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5799 using factory_type = iterator_input_adapter_factory<IteratorType>;
5800 return factory_type::create(first, last);
5807namespace container_input_adapter_factory_impl
5813template<
typename ContainerType,
typename Enable =
void>
5814struct container_input_adapter_factory {};
5816template<
typename ContainerType>
5817struct container_input_adapter_factory< ContainerType,
5818 void_t<decltype(begin(
std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
5820 using adapter_type =
decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
5822 static adapter_type create(
const ContainerType& container)
5824 return input_adapter(begin(container), end(container));
5830template<
typename ContainerType>
5831typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(
const ContainerType& container)
5833 return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
5838inline file_input_adapter input_adapter(std::FILE* file)
5840 return file_input_adapter(file);
5843inline input_stream_adapter input_adapter(std::istream& stream)
5845 return input_stream_adapter(stream);
5848inline input_stream_adapter input_adapter(std::istream&& stream)
5850 return input_stream_adapter(stream);
5854using contiguous_bytes_input_adapter =
decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5857template <
typename CharT,
5858 typename std::enable_if <
5859 std::is_pointer<CharT>::value&&
5860 !std::is_array<CharT>::value&&
5861 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5862 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5864contiguous_bytes_input_adapter input_adapter(CharT b)
5866 auto length = std::strlen(
reinterpret_cast<const char*
>(b));
5867 const auto* ptr =
reinterpret_cast<const char*
>(b);
5868 return input_adapter(ptr, ptr + length);
5871template<
typename T, std::
size_t N>
5872auto input_adapter(T (&array)[N]) ->
decltype(input_adapter(array, array + N))
5874 return input_adapter(array, array + N);
5880class span_input_adapter
5883 template <
typename CharT,
5884 typename std::enable_if <
5885 std::is_pointer<CharT>::value&&
5886 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5887 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5889 span_input_adapter(CharT b, std::size_t l)
5890 : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5892 template<
class IteratorType,
5893 typename std::enable_if<
5894 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5896 span_input_adapter(IteratorType first, IteratorType last)
5897 : ia(input_adapter(first, last)) {}
5899 contiguous_bytes_input_adapter&& get()
5901 return std::move(ia);
5905 contiguous_bytes_input_adapter ia;
5934template<
typename BasicJsonType>
5947 virtual bool null() = 0;
6038 const std::string& last_token,
6039 const detail::exception& ex) = 0;
6065template<
typename BasicJsonType>
6066class json_sax_dom_parser
6072 using string_t =
typename BasicJsonType::string_t;
6073 using binary_t =
typename BasicJsonType::binary_t;
6080 explicit json_sax_dom_parser(BasicJsonType& r,
const bool allow_exceptions_ =
true)
6081 : root(r), allow_exceptions(allow_exceptions_)
6085 json_sax_dom_parser(
const json_sax_dom_parser&) =
delete;
6086 json_sax_dom_parser(json_sax_dom_parser&&) =
default;
6087 json_sax_dom_parser&
operator=(
const json_sax_dom_parser&) =
delete;
6088 json_sax_dom_parser&
operator=(json_sax_dom_parser&&) =
default;
6089 ~json_sax_dom_parser() =
default;
6093 handle_value(
nullptr);
6129 handle_value(std::move(val));
6135 ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
6137 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6139 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6148 object_element = &(ref_stack.back()->m_value.object->operator[](val));
6154 ref_stack.back()->set_parents();
6155 ref_stack.pop_back();
6161 ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
6163 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6165 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6173 ref_stack.back()->set_parents();
6174 ref_stack.pop_back();
6178 template<
class Exception>
6179 bool parse_error(std::size_t ,
const std::string& ,
6180 const Exception& ex)
6183 static_cast<void>(ex);
6184 if (allow_exceptions)
6191 constexpr bool is_errored()
const
6203 template<
typename Value>
6205 BasicJsonType* handle_value(Value&& v)
6207 if (ref_stack.empty())
6209 root = BasicJsonType(std::forward<Value>(v));
6213 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6215 if (ref_stack.back()->is_array())
6217 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6218 return &(ref_stack.back()->m_value.array->back());
6221 JSON_ASSERT(ref_stack.back()->is_object());
6222 JSON_ASSERT(object_element);
6223 *object_element = BasicJsonType(std::forward<Value>(v));
6224 return object_element;
6228 BasicJsonType& root;
6230 std::vector<BasicJsonType*> ref_stack {};
6232 BasicJsonType* object_element =
nullptr;
6234 bool errored =
false;
6236 const bool allow_exceptions =
true;
6239template<
typename BasicJsonType>
6240class json_sax_dom_callback_parser
6246 using string_t =
typename BasicJsonType::string_t;
6247 using binary_t =
typename BasicJsonType::binary_t;
6248 using parser_callback_t =
typename BasicJsonType::parser_callback_t;
6249 using parse_event_t =
typename BasicJsonType::parse_event_t;
6251 json_sax_dom_callback_parser(BasicJsonType& r,
6252 const parser_callback_t cb,
6253 const bool allow_exceptions_ =
true)
6254 : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6256 keep_stack.push_back(
true);
6260 json_sax_dom_callback_parser(
const json_sax_dom_callback_parser&) =
delete;
6261 json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) =
default;
6262 json_sax_dom_callback_parser&
operator=(
const json_sax_dom_callback_parser&) =
delete;
6263 json_sax_dom_callback_parser&
operator=(json_sax_dom_callback_parser&&) =
default;
6264 ~json_sax_dom_callback_parser() =
default;
6268 handle_value(
nullptr);
6304 handle_value(std::move(val));
6311 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
6312 keep_stack.push_back(keep);
6314 auto val = handle_value(BasicJsonType::value_t::object,
true);
6315 ref_stack.push_back(val.second);
6318 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6320 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6328 BasicJsonType k = BasicJsonType(val);
6331 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::key, k);
6332 key_keep_stack.push_back(keep);
6335 if (keep && ref_stack.back())
6337 object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
6345 if (ref_stack.back())
6347 if (!callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
6350 *ref_stack.back() = discarded;
6354 ref_stack.back()->set_parents();
6358 JSON_ASSERT(!ref_stack.empty());
6359 JSON_ASSERT(!keep_stack.empty());
6360 ref_stack.pop_back();
6361 keep_stack.pop_back();
6363 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
6366 for (
auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
6368 if (it->is_discarded())
6370 ref_stack.back()->erase(it);
6381 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
6382 keep_stack.push_back(keep);
6384 auto val = handle_value(BasicJsonType::value_t::array,
true);
6385 ref_stack.push_back(val.second);
6388 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6390 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6400 if (ref_stack.back())
6402 keep = callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
6405 ref_stack.back()->set_parents();
6410 *ref_stack.back() = discarded;
6414 JSON_ASSERT(!ref_stack.empty());
6415 JSON_ASSERT(!keep_stack.empty());
6416 ref_stack.pop_back();
6417 keep_stack.pop_back();
6420 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
6422 ref_stack.back()->m_value.array->pop_back();
6428 template<
class Exception>
6429 bool parse_error(std::size_t ,
const std::string& ,
6430 const Exception& ex)
6433 static_cast<void>(ex);
6434 if (allow_exceptions)
6441 constexpr bool is_errored()
const
6462 template<
typename Value>
6463 std::pair<bool, BasicJsonType*> handle_value(Value&& v,
const bool skip_callback =
false)
6465 JSON_ASSERT(!keep_stack.empty());
6469 if (!keep_stack.back())
6471 return {
false,
nullptr};
6475 auto value = BasicJsonType(std::forward<Value>(v));
6478 const bool keep = skip_callback || callback(
static_cast<int>(ref_stack.size()), parse_event_t::value, value);
6483 return {
false,
nullptr};
6486 if (ref_stack.empty())
6488 root = std::move(value);
6489 return {
true, &root};
6494 if (!ref_stack.back())
6496 return {
false,
nullptr};
6500 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6503 if (ref_stack.back()->is_array())
6505 ref_stack.back()->m_value.array->emplace_back(std::move(value));
6506 return {
true, &(ref_stack.back()->m_value.array->back())};
6510 JSON_ASSERT(ref_stack.back()->is_object());
6512 JSON_ASSERT(!key_keep_stack.empty());
6513 const bool store_element = key_keep_stack.back();
6514 key_keep_stack.pop_back();
6518 return {
false,
nullptr};
6521 JSON_ASSERT(object_element);
6522 *object_element = std::move(value);
6523 return {
true, object_element};
6527 BasicJsonType& root;
6529 std::vector<BasicJsonType*> ref_stack {};
6531 std::vector<bool> keep_stack {};
6533 std::vector<bool> key_keep_stack {};
6535 BasicJsonType* object_element =
nullptr;
6537 bool errored =
false;
6539 const parser_callback_t callback =
nullptr;
6541 const bool allow_exceptions =
true;
6543 BasicJsonType discarded = BasicJsonType::value_t::discarded;
6546template<
typename BasicJsonType>
6547class json_sax_acceptor
6553 using string_t =
typename BasicJsonType::string_t;
6554 using binary_t =
typename BasicJsonType::binary_t;
6616 bool parse_error(std::size_t ,
const std::string& ,
const detail::exception& )
6633#include <initializer_list>
6653template<
typename BasicJsonType>
6658 enum class token_type
6682 static const char* token_type_name(
const token_type t)
noexcept
6686 case token_type::uninitialized:
6687 return "<uninitialized>";
6688 case token_type::literal_true:
6689 return "true literal";
6690 case token_type::literal_false:
6691 return "false literal";
6692 case token_type::literal_null:
6693 return "null literal";
6694 case token_type::value_string:
6695 return "string literal";
6696 case token_type::value_unsigned:
6697 case token_type::value_integer:
6698 case token_type::value_float:
6699 return "number literal";
6700 case token_type::begin_array:
6702 case token_type::begin_object:
6704 case token_type::end_array:
6706 case token_type::end_object:
6708 case token_type::name_separator:
6710 case token_type::value_separator:
6712 case token_type::parse_error:
6713 return "<parse error>";
6714 case token_type::end_of_input:
6715 return "end of input";
6716 case token_type::literal_or_value:
6717 return "'[', '{', or a literal";
6720 return "unknown token";
6730template<
typename BasicJsonType,
typename InputAdapterType>
6731class lexer :
public lexer_base<BasicJsonType>
6733 using number_integer_t =
typename BasicJsonType::number_integer_t;
6734 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
6735 using number_float_t =
typename BasicJsonType::number_float_t;
6736 using string_t =
typename BasicJsonType::string_t;
6737 using char_type =
typename InputAdapterType::char_type;
6738 using char_int_type =
typename std::char_traits<char_type>::int_type;
6741 using token_type =
typename lexer_base<BasicJsonType>::token_type;
6743 explicit lexer(InputAdapterType&& adapter,
bool ignore_comments_ =
false) noexcept
6744 : ia(
std::move(adapter))
6745 , ignore_comments(ignore_comments_)
6746 , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
6750 lexer(
const lexer&) =
delete;
6751 lexer(lexer&&) =
default;
6752 lexer& operator=(lexer&) =
delete;
6753 lexer& operator=(lexer&&) =
default;
6763 static char get_decimal_point() noexcept
6765 const auto* loc = localeconv();
6766 JSON_ASSERT(loc !=
nullptr);
6767 return (loc->decimal_point ==
nullptr) ?
'.' : *(loc->decimal_point);
6792 JSON_ASSERT(current ==
'u');
6795 const auto factors = { 12u, 8u, 4u, 0u };
6796 for (
const auto factor : factors)
6800 if (current >=
'0' && current <=
'9')
6802 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x30u) << factor);
6804 else if (current >=
'A' && current <=
'F')
6806 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x37u) << factor);
6808 else if (current >=
'a' && current <=
'f')
6810 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x57u) << factor);
6818 JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6837 bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6839 JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6842 for (
auto range = ranges.begin(); range != ranges.end(); ++range)
6845 if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6851 error_message =
"invalid string: ill-formed UTF-8 byte";
6874 token_type scan_string()
6880 JSON_ASSERT(current ==
'\"');
6888 case std::char_traits<char_type>::eof():
6890 error_message =
"invalid string: missing closing quote";
6891 return token_type::parse_error;
6897 return token_type::value_string;
6941 const int codepoint1 = get_codepoint();
6942 int codepoint = codepoint1;
6944 if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6946 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6947 return token_type::parse_error;
6951 if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6954 if (JSON_HEDLEY_LIKELY(get() ==
'\\' && get() ==
'u'))
6956 const int codepoint2 = get_codepoint();
6958 if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6960 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6961 return token_type::parse_error;
6965 if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6968 codepoint =
static_cast<int>(
6970 (
static_cast<unsigned int>(codepoint1) << 10u)
6972 +
static_cast<unsigned int>(codepoint2)
6980 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6981 return token_type::parse_error;
6986 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6987 return token_type::parse_error;
6992 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6994 error_message =
"invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6995 return token_type::parse_error;
7000 JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
7003 if (codepoint < 0x80)
7006 add(
static_cast<char_int_type
>(codepoint));
7008 else if (codepoint <= 0x7FF)
7011 add(
static_cast<char_int_type
>(0xC0u | (
static_cast<unsigned int>(codepoint) >> 6u)));
7012 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
7014 else if (codepoint <= 0xFFFF)
7017 add(
static_cast<char_int_type
>(0xE0u | (
static_cast<unsigned int>(codepoint) >> 12u)));
7018 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7019 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
7024 add(
static_cast<char_int_type
>(0xF0u | (
static_cast<unsigned int>(codepoint) >> 18u)));
7025 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
7026 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7027 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
7035 error_message =
"invalid string: forbidden character after backslash";
7036 return token_type::parse_error;
7045 error_message =
"invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
7046 return token_type::parse_error;
7051 error_message =
"invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
7052 return token_type::parse_error;
7057 error_message =
"invalid string: control character U+0002 (STX) must be escaped to \\u0002";
7058 return token_type::parse_error;
7063 error_message =
"invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
7064 return token_type::parse_error;
7069 error_message =
"invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
7070 return token_type::parse_error;
7075 error_message =
"invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
7076 return token_type::parse_error;
7081 error_message =
"invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
7082 return token_type::parse_error;
7087 error_message =
"invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
7088 return token_type::parse_error;
7093 error_message =
"invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
7094 return token_type::parse_error;
7099 error_message =
"invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
7100 return token_type::parse_error;
7105 error_message =
"invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
7106 return token_type::parse_error;
7111 error_message =
"invalid string: control character U+000B (VT) must be escaped to \\u000B";
7112 return token_type::parse_error;
7117 error_message =
"invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
7118 return token_type::parse_error;
7123 error_message =
"invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
7124 return token_type::parse_error;
7129 error_message =
"invalid string: control character U+000E (SO) must be escaped to \\u000E";
7130 return token_type::parse_error;
7135 error_message =
"invalid string: control character U+000F (SI) must be escaped to \\u000F";
7136 return token_type::parse_error;
7141 error_message =
"invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
7142 return token_type::parse_error;
7147 error_message =
"invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
7148 return token_type::parse_error;
7153 error_message =
"invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
7154 return token_type::parse_error;
7159 error_message =
"invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
7160 return token_type::parse_error;
7165 error_message =
"invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
7166 return token_type::parse_error;
7171 error_message =
"invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7172 return token_type::parse_error;
7177 error_message =
"invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7178 return token_type::parse_error;
7183 error_message =
"invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7184 return token_type::parse_error;
7189 error_message =
"invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7190 return token_type::parse_error;
7195 error_message =
"invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7196 return token_type::parse_error;
7201 error_message =
"invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7202 return token_type::parse_error;
7207 error_message =
"invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7208 return token_type::parse_error;
7213 error_message =
"invalid string: control character U+001C (FS) must be escaped to \\u001C";
7214 return token_type::parse_error;
7219 error_message =
"invalid string: control character U+001D (GS) must be escaped to \\u001D";
7220 return token_type::parse_error;
7225 error_message =
"invalid string: control character U+001E (RS) must be escaped to \\u001E";
7226 return token_type::parse_error;
7231 error_message =
"invalid string: control character U+001F (US) must be escaped to \\u001F";
7232 return token_type::parse_error;
7367 if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
7369 return token_type::parse_error;
7377 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7379 return token_type::parse_error;
7401 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7403 return token_type::parse_error;
7411 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7413 return token_type::parse_error;
7421 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7423 return token_type::parse_error;
7433 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7435 return token_type::parse_error;
7443 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7445 return token_type::parse_error;
7453 error_message =
"invalid string: ill-formed UTF-8 byte";
7454 return token_type::parse_error;
7477 case std::char_traits<char_type>::eof():
7494 case std::char_traits<char_type>::eof():
7497 error_message =
"invalid comment; missing closing '*/'";
7525 error_message =
"invalid comment; expecting '/' or '*' after '/'";
7531 JSON_HEDLEY_NON_NULL(2)
7532 static
void strtof(
float& f, const
char* str,
char** endptr) noexcept
7534 f = std::strtof(str, endptr);
7537 JSON_HEDLEY_NON_NULL(2)
7538 static
void strtof(
double& f, const
char* str,
char** endptr) noexcept
7540 f = std::strtod(str, endptr);
7543 JSON_HEDLEY_NON_NULL(2)
7544 static
void strtof(
long double& f, const
char* str,
char** endptr) noexcept
7546 f = std::strtold(str, endptr);
7589 token_type scan_number()
7596 token_type number_type = token_type::value_unsigned;
7604 goto scan_number_minus;
7610 goto scan_number_zero;
7624 goto scan_number_any1;
7634 number_type = token_type::value_integer;
7640 goto scan_number_zero;
7654 goto scan_number_any1;
7659 error_message =
"invalid number; expected digit after '-'";
7660 return token_type::parse_error;
7670 add(decimal_point_char);
7671 goto scan_number_decimal1;
7678 goto scan_number_exponent;
7682 goto scan_number_done;
7701 goto scan_number_any1;
7706 add(decimal_point_char);
7707 goto scan_number_decimal1;
7714 goto scan_number_exponent;
7718 goto scan_number_done;
7721scan_number_decimal1:
7723 number_type = token_type::value_float;
7738 goto scan_number_decimal2;
7743 error_message =
"invalid number; expected digit after '.'";
7744 return token_type::parse_error;
7748scan_number_decimal2:
7764 goto scan_number_decimal2;
7771 goto scan_number_exponent;
7775 goto scan_number_done;
7778scan_number_exponent:
7780 number_type = token_type::value_float;
7787 goto scan_number_sign;
7802 goto scan_number_any2;
7808 "invalid number; expected '+', '-', or digit after exponent";
7809 return token_type::parse_error;
7829 goto scan_number_any2;
7834 error_message =
"invalid number; expected digit after exponent sign";
7835 return token_type::parse_error;
7855 goto scan_number_any2;
7859 goto scan_number_done;
7867 char* endptr =
nullptr;
7871 if (number_type == token_type::value_unsigned)
7873 const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7876 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7880 value_unsigned =
static_cast<number_unsigned_t
>(x);
7881 if (value_unsigned == x)
7883 return token_type::value_unsigned;
7887 else if (number_type == token_type::value_integer)
7889 const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7892 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7896 value_integer =
static_cast<number_integer_t
>(x);
7897 if (value_integer == x)
7899 return token_type::value_integer;
7906 strtof(value_float, token_buffer.data(), &endptr);
7909 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7911 return token_type::value_float;
7919 JSON_HEDLEY_NON_NULL(2)
7920 token_type scan_literal(const char_type* literal_text, const
std::
size_t length,
7921 token_type return_type)
7923 JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7924 for (std::size_t i = 1; i < length; ++i)
7926 if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7928 error_message =
"invalid literal";
7929 return token_type::parse_error;
7940 void reset() noexcept
7942 token_buffer.clear();
7943 token_string.clear();
7944 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7959 ++position.chars_read_total;
7960 ++position.chars_read_current_line;
7969 current = ia.get_character();
7972 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7974 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7977 if (current ==
'\n')
7979 ++position.lines_read;
7980 position.chars_read_current_line = 0;
7998 --position.chars_read_total;
8001 if (position.chars_read_current_line == 0)
8003 if (position.lines_read > 0)
8005 --position.lines_read;
8010 --position.chars_read_current_line;
8013 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
8015 JSON_ASSERT(!token_string.empty());
8016 token_string.pop_back();
8021 void add(char_int_type c)
8023 token_buffer.push_back(
static_cast<typename string_t::value_type
>(c));
8032 constexpr number_integer_t get_number_integer() const noexcept
8034 return value_integer;
8038 constexpr number_unsigned_t get_number_unsigned() const noexcept
8040 return value_unsigned;
8044 constexpr number_float_t get_number_float() const noexcept
8050 string_t& get_string()
8052 return token_buffer;
8060 constexpr position_t get_position() const noexcept
8068 std::string get_token_string()
const
8072 for (
const auto c : token_string)
8074 if (
static_cast<unsigned char>(c) <=
'\x1F')
8077 std::array<char, 9> cs{{}};
8078 (std::snprintf)(cs.data(), cs.size(),
"<U+%.4X>",
static_cast<unsigned char>(c));
8079 result += cs.data();
8084 result.push_back(
static_cast<std::string::value_type
>(c));
8093 constexpr const char* get_error_message() const noexcept
8095 return error_message;
8111 return get() == 0xBB && get() == 0xBF;
8120 void skip_whitespace()
8126 while (current ==
' ' || current ==
'\t' || current ==
'\n' || current ==
'\r');
8132 if (position.chars_read_total == 0 && !skip_bom())
8134 error_message =
"invalid BOM; must be 0xEF 0xBB 0xBF if given";
8135 return token_type::parse_error;
8142 while (ignore_comments && current ==
'/')
8144 if (!scan_comment())
8146 return token_type::parse_error;
8157 return token_type::begin_array;
8159 return token_type::end_array;
8161 return token_type::begin_object;
8163 return token_type::end_object;
8165 return token_type::name_separator;
8167 return token_type::value_separator;
8172 std::array<char_type, 4> true_literal = {{char_type(
't'), char_type(
'r'), char_type(
'u'), char_type(
'e')}};
8173 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
8177 std::array<char_type, 5> false_literal = {{char_type(
'f'), char_type(
'a'), char_type(
'l'), char_type(
's'), char_type(
'e')}};
8178 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
8182 std::array<char_type, 4> null_literal = {{char_type(
'n'), char_type(
'u'), char_type(
'l'), char_type(
'l')}};
8183 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
8188 return scan_string();
8202 return scan_number();
8207 case std::char_traits<char_type>::eof():
8208 return token_type::end_of_input;
8212 error_message =
"invalid literal";
8213 return token_type::parse_error;
8219 InputAdapterType ia;
8222 const bool ignore_comments =
false;
8225 char_int_type current = std::char_traits<char_type>::eof();
8228 bool next_unget =
false;
8231 position_t position {};
8234 std::vector<char_type> token_string {};
8237 string_t token_buffer {};
8240 const char* error_message =
"";
8243 number_integer_t value_integer = 0;
8244 number_unsigned_t value_unsigned = 0;
8245 number_float_t value_float = 0;
8248 const char_int_type decimal_point_char =
'.';
8272using null_function_t =
decltype(std::declval<T&>().null());
8275using boolean_function_t =
8276 decltype(std::declval<T&>().boolean(std::declval<bool>()));
8278template<
typename T,
typename Integer>
8279using number_integer_function_t =
8280 decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8282template<
typename T,
typename Un
signed>
8283using number_unsigned_function_t =
8284 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8286template<
typename T,
typename Float,
typename String>
8287using number_float_function_t =
decltype(std::declval<T&>().number_float(
8288 std::declval<Float>(), std::declval<const String&>()));
8290template<
typename T,
typename String>
8291using string_function_t =
8292 decltype(std::declval<T&>().string(std::declval<String&>()));
8294template<
typename T,
typename Binary>
8295using binary_function_t =
8296 decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8299using start_object_function_t =
8300 decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8302template<
typename T,
typename String>
8303using key_function_t =
8304 decltype(std::declval<T&>().key(std::declval<String&>()));
8307using end_object_function_t =
decltype(std::declval<T&>().end_object());
8310using start_array_function_t =
8311 decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
8314using end_array_function_t =
decltype(std::declval<T&>().end_array());
8316template<
typename T,
typename Exception>
8317using parse_error_function_t =
decltype(std::declval<T&>().parse_error(
8318 std::declval<std::size_t>(), std::declval<const std::string&>(),
8319 std::declval<const Exception&>()));
8321template<
typename SAX,
typename BasicJsonType>
8325 static_assert(is_basic_json<BasicJsonType>::value,
8326 "BasicJsonType must be of type basic_json<...>");
8328 using number_integer_t =
typename BasicJsonType::number_integer_t;
8329 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8330 using number_float_t =
typename BasicJsonType::number_float_t;
8331 using string_t =
typename BasicJsonType::string_t;
8332 using binary_t =
typename BasicJsonType::binary_t;
8333 using exception_t =
typename BasicJsonType::exception;
8336 static constexpr bool value =
8337 is_detected_exact<bool, null_function_t, SAX>::value &&
8338 is_detected_exact<bool, boolean_function_t, SAX>::value &&
8339 is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
8340 is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
8341 is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
8342 is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
8343 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
8344 is_detected_exact<bool, start_object_function_t, SAX>::value &&
8345 is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
8346 is_detected_exact<bool, end_object_function_t, SAX>::value &&
8347 is_detected_exact<bool, start_array_function_t, SAX>::value &&
8348 is_detected_exact<bool, end_array_function_t, SAX>::value &&
8349 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
8352template<
typename SAX,
typename BasicJsonType>
8353struct is_sax_static_asserts
8356 static_assert(is_basic_json<BasicJsonType>::value,
8357 "BasicJsonType must be of type basic_json<...>");
8359 using number_integer_t =
typename BasicJsonType::number_integer_t;
8360 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8361 using number_float_t =
typename BasicJsonType::number_float_t;
8362 using string_t =
typename BasicJsonType::string_t;
8363 using binary_t =
typename BasicJsonType::binary_t;
8364 using exception_t =
typename BasicJsonType::exception;
8367 static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
8368 "Missing/invalid function: bool null()");
8369 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8370 "Missing/invalid function: bool boolean(bool)");
8371 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8372 "Missing/invalid function: bool boolean(bool)");
8374 is_detected_exact<bool, number_integer_function_t, SAX,
8375 number_integer_t>::value,
8376 "Missing/invalid function: bool number_integer(number_integer_t)");
8378 is_detected_exact<bool, number_unsigned_function_t, SAX,
8379 number_unsigned_t>::value,
8380 "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
8381 static_assert(is_detected_exact<bool, number_float_function_t, SAX,
8382 number_float_t, string_t>::value,
8383 "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
8385 is_detected_exact<bool, string_function_t, SAX, string_t>::value,
8386 "Missing/invalid function: bool string(string_t&)");
8388 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
8389 "Missing/invalid function: bool binary(binary_t&)");
8390 static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
8391 "Missing/invalid function: bool start_object(std::size_t)");
8392 static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
8393 "Missing/invalid function: bool key(string_t&)");
8394 static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
8395 "Missing/invalid function: bool end_object()");
8396 static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
8397 "Missing/invalid function: bool start_array(std::size_t)");
8398 static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
8399 "Missing/invalid function: bool end_array()");
8401 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
8402 "Missing/invalid function: bool parse_error(std::size_t, const "
8403 "std::string&, const exception&)");
8419enum class cbor_tag_handler_t
8433static inline bool little_endianess(
int num = 1) noexcept
8435 return *
reinterpret_cast<char*
>(&num) == 1;
8446template<
typename BasicJsonType,
typename InputAdapterType,
typename SAX = json_sax_dom_parser<BasicJsonType>>
8449 using number_integer_t =
typename BasicJsonType::number_integer_t;
8450 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8451 using number_float_t =
typename BasicJsonType::number_float_t;
8452 using string_t =
typename BasicJsonType::string_t;
8453 using binary_t =
typename BasicJsonType::binary_t;
8454 using json_sax_t = SAX;
8455 using char_type =
typename InputAdapterType::char_type;
8456 using char_int_type =
typename std::char_traits<char_type>::int_type;
8464 explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
8466 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
8470 binary_reader(
const binary_reader&) =
delete;
8471 binary_reader(binary_reader&&) =
default;
8472 binary_reader& operator=(
const binary_reader&) =
delete;
8473 binary_reader& operator=(binary_reader&&) =
default;
8474 ~binary_reader() =
default;
8484 JSON_HEDLEY_NON_NULL(3)
8485 bool sax_parse(const input_format_t format,
8487 const
bool strict = true,
8488 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
8491 bool result =
false;
8495 case input_format_t::bson:
8496 result = parse_bson_internal();
8499 case input_format_t::cbor:
8500 result = parse_cbor_internal(
true, tag_handler);
8503 case input_format_t::msgpack:
8504 result = parse_msgpack_internal();
8507 case input_format_t::ubjson:
8508 result = parse_ubjson_internal();
8511 case input_format_t::json:
8517 if (result && strict)
8519 if (format == input_format_t::ubjson)
8528 if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
8530 return sax->parse_error(chars_read, get_token_string(),
8531 parse_error::create(110, chars_read, exception_message(format,
"expected end of input; last byte: 0x" + get_token_string(),
"value"), BasicJsonType()));
8547 bool parse_bson_internal()
8549 std::int32_t document_size{};
8550 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8552 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
8557 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
false)))
8562 return sax->end_object();
8572 bool get_bson_cstr(string_t& result)
8574 auto out = std::back_inserter(result);
8578 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"cstring")))
8582 if (current == 0x00)
8586 *out++ =
static_cast<typename string_t::value_type
>(current);
8601 template<
typename NumberType>
8602 bool get_bson_string(
const NumberType len, string_t& result)
8604 if (JSON_HEDLEY_UNLIKELY(len < 1))
8606 auto last_token = get_token_string();
8607 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()));
8610 return get_string(input_format_t::bson, len -
static_cast<NumberType
>(1), result) && get() != std::char_traits<char_type>::eof();
8622 template<
typename NumberType>
8623 bool get_bson_binary(
const NumberType len, binary_t& result)
8625 if (JSON_HEDLEY_UNLIKELY(len < 0))
8627 auto last_token = get_token_string();
8628 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()));
8632 std::uint8_t subtype{};
8633 get_number<std::uint8_t>(input_format_t::bson, subtype);
8634 result.set_subtype(subtype);
8636 return get_binary(input_format_t::bson, len, result);
8649 bool parse_bson_element_internal(
const char_int_type element_type,
8650 const std::size_t element_type_parse_position)
8652 switch (element_type)
8657 return get_number<double, true>(input_format_t::bson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
8664 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
8669 return parse_bson_internal();
8674 return parse_bson_array();
8681 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
8686 return sax->boolean(get() != 0);
8696 std::int32_t value{};
8697 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8702 std::int64_t value{};
8703 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8708 std::array<char, 3> cr{{}};
8709 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(element_type));
8710 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()));
8727 bool parse_bson_element_list(
const bool is_array)
8731 while (
auto element_type = get())
8733 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"element list")))
8738 const std::size_t element_type_parse_position = chars_read;
8739 if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
8744 if (!is_array && !sax->key(key))
8749 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
8765 bool parse_bson_array()
8767 std::int32_t document_size{};
8768 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8770 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
8775 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
true)))
8780 return sax->end_array();
8795 bool parse_cbor_internal(
const bool get_char,
8796 const cbor_tag_handler_t tag_handler)
8798 switch (get_char ? get() : current)
8801 case std::char_traits<char_type>::eof():
8802 return unexpect_eof(input_format_t::cbor,
"value");
8829 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
8833 std::uint8_t number{};
8834 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8839 std::uint16_t number{};
8840 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8845 std::uint32_t number{};
8846 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8851 std::uint64_t number{};
8852 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8880 return sax->number_integer(
static_cast<std::int8_t
>(0x20 - 1 - current));
8884 std::uint8_t number{};
8885 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8890 std::uint16_t number{};
8891 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8896 std::uint32_t number{};
8897 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8902 std::uint64_t number{};
8903 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1)
8904 -
static_cast<number_integer_t
>(number));
8939 return get_cbor_binary(b) && sax->binary(b);
8974 return get_cbor_string(s) && sax->string(s);
9002 return get_cbor_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
9007 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
9012 std::uint16_t len{};
9013 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
9018 std::uint32_t len{};
9019 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
9024 std::uint64_t len{};
9025 return get_number(input_format_t::cbor, len) && get_cbor_array(detail::conditional_static_cast<std::size_t>(len), tag_handler);
9029 return get_cbor_array(std::size_t(-1), tag_handler);
9056 return get_cbor_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
9061 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
9066 std::uint16_t len{};
9067 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
9072 std::uint32_t len{};
9073 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
9078 std::uint64_t len{};
9079 return get_number(input_format_t::cbor, len) && get_cbor_object(detail::conditional_static_cast<std::size_t>(len), tag_handler);
9083 return get_cbor_object(std::size_t(-1), tag_handler);
9105 switch (tag_handler)
9107 case cbor_tag_handler_t::error:
9109 auto last_token = get_token_string();
9110 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()));
9113 case cbor_tag_handler_t::ignore:
9120 std::uint8_t subtype_to_ignore{};
9121 get_number(input_format_t::cbor, subtype_to_ignore);
9126 std::uint16_t subtype_to_ignore{};
9127 get_number(input_format_t::cbor, subtype_to_ignore);
9132 std::uint32_t subtype_to_ignore{};
9133 get_number(input_format_t::cbor, subtype_to_ignore);
9138 std::uint64_t subtype_to_ignore{};
9139 get_number(input_format_t::cbor, subtype_to_ignore);
9145 return parse_cbor_internal(
true, tag_handler);
9148 case cbor_tag_handler_t::store:
9156 std::uint8_t subtype{};
9157 get_number(input_format_t::cbor, subtype);
9158 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9163 std::uint16_t subtype{};
9164 get_number(input_format_t::cbor, subtype);
9165 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9170 std::uint32_t subtype{};
9171 get_number(input_format_t::cbor, subtype);
9172 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9177 std::uint64_t subtype{};
9178 get_number(input_format_t::cbor, subtype);
9179 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9183 return parse_cbor_internal(
true, tag_handler);
9186 return get_cbor_binary(b) && sax->binary(b);
9196 return sax->boolean(
false);
9199 return sax->boolean(
true);
9206 const auto byte1_raw = get();
9207 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
9211 const auto byte2_raw = get();
9212 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
9217 const auto byte1 =
static_cast<unsigned char>(byte1_raw);
9218 const auto byte2 =
static_cast<unsigned char>(byte2_raw);
9228 const auto half =
static_cast<unsigned int>((byte1 << 8u) + byte2);
9229 const double val = [&half]
9231 const int exp = (half >> 10u) & 0x1Fu;
9232 const unsigned int mant = half & 0x3FFu;
9233 JSON_ASSERT(0 <= exp&& exp <= 32);
9234 JSON_ASSERT(mant <= 1024);
9238 return std::ldexp(mant, -24);
9241 ? std::numeric_limits<double>::infinity()
9242 :
std::numeric_limits<double>::quiet_NaN();
9244 return std::ldexp(mant + 1024, exp - 25);
9247 return sax->number_float((half & 0x8000u) != 0
9248 ?
static_cast<number_float_t
>(-val)
9249 :
static_cast<number_float_t
>(val),
"");
9255 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9261 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9266 auto last_token = get_token_string();
9267 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()));
9283 bool get_cbor_string(string_t& result)
9285 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"string")))
9318 return get_string(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
9324 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9329 std::uint16_t len{};
9330 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9335 std::uint32_t len{};
9336 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9341 std::uint64_t len{};
9342 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9347 while (get() != 0xFF)
9350 if (!get_cbor_string(chunk))
9354 result.append(chunk);
9361 auto last_token = get_token_string();
9362 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()));
9378 bool get_cbor_binary(binary_t& result)
9380 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"binary")))
9413 return get_binary(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
9419 return get_number(input_format_t::cbor, len) &&
9420 get_binary(input_format_t::cbor, len, result);
9425 std::uint16_t len{};
9426 return get_number(input_format_t::cbor, len) &&
9427 get_binary(input_format_t::cbor, len, result);
9432 std::uint32_t len{};
9433 return get_number(input_format_t::cbor, len) &&
9434 get_binary(input_format_t::cbor, len, result);
9439 std::uint64_t len{};
9440 return get_number(input_format_t::cbor, len) &&
9441 get_binary(input_format_t::cbor, len, result);
9446 while (get() != 0xFF)
9449 if (!get_cbor_binary(chunk))
9453 result.insert(result.end(), chunk.begin(), chunk.end());
9460 auto last_token = get_token_string();
9461 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()));
9472 bool get_cbor_array(
const std::size_t len,
9473 const cbor_tag_handler_t tag_handler)
9475 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9480 if (len != std::size_t(-1))
9482 for (std::size_t i = 0; i < len; ++i)
9484 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9492 while (get() != 0xFF)
9494 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
false, tag_handler)))
9501 return sax->end_array();
9510 bool get_cbor_object(
const std::size_t len,
9511 const cbor_tag_handler_t tag_handler)
9513 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9521 if (len != std::size_t(-1))
9523 for (std::size_t i = 0; i < len; ++i)
9526 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9531 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9540 while (get() != 0xFF)
9542 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9547 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9556 return sax->end_object();
9566 bool parse_msgpack_internal()
9571 case std::char_traits<char_type>::eof():
9572 return unexpect_eof(input_format_t::msgpack,
"value");
9703 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
9722 return get_msgpack_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
9741 return get_msgpack_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
9781 return get_msgpack_string(s) && sax->string(s);
9788 return sax->boolean(
false);
9791 return sax->boolean(
true);
9806 return get_msgpack_binary(b) && sax->binary(b);
9812 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9818 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9823 std::uint8_t number{};
9824 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9829 std::uint16_t number{};
9830 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9835 std::uint32_t number{};
9836 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9841 std::uint64_t number{};
9842 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9847 std::int8_t number{};
9848 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9853 std::int16_t number{};
9854 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9859 std::int32_t number{};
9860 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9865 std::int64_t number{};
9866 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9871 std::uint16_t len{};
9872 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9877 std::uint32_t len{};
9878 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9883 std::uint16_t len{};
9884 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9889 std::uint32_t len{};
9890 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9926 return sax->number_integer(
static_cast<std::int8_t
>(current));
9930 auto last_token = get_token_string();
9931 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()));
9946 bool get_msgpack_string(string_t& result)
9948 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack,
"string")))
9989 return get_string(input_format_t::msgpack,
static_cast<unsigned int>(current) & 0x1Fu, result);
9995 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10000 std::uint16_t len{};
10001 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10006 std::uint32_t len{};
10007 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10012 auto last_token = get_token_string();
10013 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()));
10028 bool get_msgpack_binary(binary_t& result)
10031 auto assign_and_return_true = [&result](std::int8_t subtype)
10033 result.set_subtype(
static_cast<std::uint8_t
>(subtype));
10041 std::uint8_t len{};
10042 return get_number(input_format_t::msgpack, len) &&
10043 get_binary(input_format_t::msgpack, len, result);
10048 std::uint16_t len{};
10049 return get_number(input_format_t::msgpack, len) &&
10050 get_binary(input_format_t::msgpack, len, result);
10055 std::uint32_t len{};
10056 return get_number(input_format_t::msgpack, len) &&
10057 get_binary(input_format_t::msgpack, len, result);
10062 std::uint8_t len{};
10063 std::int8_t subtype{};
10064 return get_number(input_format_t::msgpack, len) &&
10065 get_number(input_format_t::msgpack, subtype) &&
10066 get_binary(input_format_t::msgpack, len, result) &&
10067 assign_and_return_true(subtype);
10072 std::uint16_t len{};
10073 std::int8_t subtype{};
10074 return get_number(input_format_t::msgpack, len) &&
10075 get_number(input_format_t::msgpack, subtype) &&
10076 get_binary(input_format_t::msgpack, len, result) &&
10077 assign_and_return_true(subtype);
10082 std::uint32_t len{};
10083 std::int8_t subtype{};
10084 return get_number(input_format_t::msgpack, len) &&
10085 get_number(input_format_t::msgpack, subtype) &&
10086 get_binary(input_format_t::msgpack, len, result) &&
10087 assign_and_return_true(subtype);
10092 std::int8_t subtype{};
10093 return get_number(input_format_t::msgpack, subtype) &&
10094 get_binary(input_format_t::msgpack, 1, result) &&
10095 assign_and_return_true(subtype);
10100 std::int8_t subtype{};
10101 return get_number(input_format_t::msgpack, subtype) &&
10102 get_binary(input_format_t::msgpack, 2, result) &&
10103 assign_and_return_true(subtype);
10108 std::int8_t subtype{};
10109 return get_number(input_format_t::msgpack, subtype) &&
10110 get_binary(input_format_t::msgpack, 4, result) &&
10111 assign_and_return_true(subtype);
10116 std::int8_t subtype{};
10117 return get_number(input_format_t::msgpack, subtype) &&
10118 get_binary(input_format_t::msgpack, 8, result) &&
10119 assign_and_return_true(subtype);
10124 std::int8_t subtype{};
10125 return get_number(input_format_t::msgpack, subtype) &&
10126 get_binary(input_format_t::msgpack, 16, result) &&
10127 assign_and_return_true(subtype);
10139 bool get_msgpack_array(
const std::size_t len)
10141 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
10146 for (std::size_t i = 0; i < len; ++i)
10148 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
10154 return sax->end_array();
10161 bool get_msgpack_object(
const std::size_t len)
10163 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
10169 for (std::size_t i = 0; i < len; ++i)
10172 if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
10177 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
10184 return sax->end_object();
10198 bool parse_ubjson_internal(
const bool get_char =
true)
10200 return get_ubjson_value(get_char ? get_ignore_noop() : current);
10217 bool get_ubjson_string(string_t& result,
const bool get_char =
true)
10224 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
10233 std::uint8_t len{};
10234 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10240 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10245 std::int16_t len{};
10246 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10251 std::int32_t len{};
10252 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10257 std::int64_t len{};
10258 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10262 auto last_token = get_token_string();
10263 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()));
10271 bool get_ubjson_size_value(std::size_t& result)
10273 switch (get_ignore_noop())
10277 std::uint8_t number{};
10278 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10282 result =
static_cast<std::size_t
>(number);
10288 std::int8_t number{};
10289 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10293 result =
static_cast<std::size_t
>(number);
10299 std::int16_t number{};
10300 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10304 result =
static_cast<std::size_t
>(number);
10310 std::int32_t number{};
10311 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10315 result =
static_cast<std::size_t
>(number);
10321 std::int64_t number{};
10322 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10326 result =
static_cast<std::size_t
>(number);
10332 auto last_token = get_token_string();
10333 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()));
10348 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
10350 result.first = string_t::npos;
10355 if (current ==
'$')
10357 result.second = get();
10358 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"type")))
10364 if (JSON_HEDLEY_UNLIKELY(current !=
'#'))
10366 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
10370 auto last_token = get_token_string();
10371 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()));
10374 return get_ubjson_size_value(result.first);
10377 if (current ==
'#')
10379 return get_ubjson_size_value(result.first);
10389 bool get_ubjson_value(
const char_int_type prefix)
10393 case std::char_traits<char_type>::eof():
10394 return unexpect_eof(input_format_t::ubjson,
"value");
10397 return sax->boolean(
true);
10399 return sax->boolean(
false);
10402 return sax->null();
10406 std::uint8_t number{};
10407 return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
10412 std::int8_t number{};
10413 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10418 std::int16_t number{};
10419 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10424 std::int32_t number{};
10425 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10430 std::int64_t number{};
10431 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10437 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
10443 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
10448 return get_ubjson_high_precision_number();
10454 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"char")))
10458 if (JSON_HEDLEY_UNLIKELY(current > 127))
10460 auto last_token = get_token_string();
10461 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()));
10463 string_t s(1,
static_cast<typename string_t::value_type
>(current));
10464 return sax->string(s);
10470 return get_ubjson_string(s) && sax->string(s);
10474 return get_ubjson_array();
10477 return get_ubjson_object();
10481 auto last_token = get_token_string();
10482 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()));
10490 bool get_ubjson_array()
10492 std::pair<std::size_t, char_int_type> size_and_type;
10493 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10498 if (size_and_type.first != string_t::npos)
10500 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
10505 if (size_and_type.second != 0)
10507 if (size_and_type.second !=
'N')
10509 for (std::size_t i = 0; i < size_and_type.first; ++i)
10511 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10520 for (std::size_t i = 0; i < size_and_type.first; ++i)
10522 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10531 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10536 while (current !=
']')
10538 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(
false)))
10546 return sax->end_array();
10552 bool get_ubjson_object()
10554 std::pair<std::size_t, char_int_type> size_and_type;
10555 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10561 if (size_and_type.first != string_t::npos)
10563 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
10568 if (size_and_type.second != 0)
10570 for (std::size_t i = 0; i < size_and_type.first; ++i)
10572 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10576 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10585 for (std::size_t i = 0; i < size_and_type.first; ++i)
10587 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10591 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10601 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10606 while (current !=
'}')
10608 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key,
false) || !sax->key(key)))
10612 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10621 return sax->end_object();
10627 bool get_ubjson_high_precision_number()
10630 std::size_t size{};
10631 auto res = get_ubjson_size_value(size);
10632 if (JSON_HEDLEY_UNLIKELY(!res))
10638 std::vector<char> number_vector;
10639 for (std::size_t i = 0; i < size; ++i)
10642 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"number")))
10646 number_vector.push_back(
static_cast<char>(current));
10650 using ia_type =
decltype(detail::input_adapter(number_vector));
10651 auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector),
false);
10652 const auto result_number = number_lexer.scan();
10653 const auto number_string = number_lexer.get_token_string();
10654 const auto result_remainder = number_lexer.scan();
10656 using token_type =
typename detail::lexer_base<BasicJsonType>::token_type;
10658 if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
10660 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()));
10663 switch (result_number)
10665 case token_type::value_integer:
10666 return sax->number_integer(number_lexer.get_number_integer());
10667 case token_type::value_unsigned:
10668 return sax->number_unsigned(number_lexer.get_number_unsigned());
10669 case token_type::value_float:
10670 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
10671 case token_type::uninitialized:
10672 case token_type::literal_true:
10673 case token_type::literal_false:
10674 case token_type::literal_null:
10675 case token_type::value_string:
10676 case token_type::begin_array:
10677 case token_type::begin_object:
10678 case token_type::end_array:
10679 case token_type::end_object:
10680 case token_type::name_separator:
10681 case token_type::value_separator:
10682 case token_type::parse_error:
10683 case token_type::end_of_input:
10684 case token_type::literal_or_value:
10686 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()));
10703 char_int_type get()
10706 return current = ia.get_character();
10712 char_int_type get_ignore_noop()
10718 while (current ==
'N');
10736 template<
typename NumberType,
bool InputIsLittleEndian = false>
10737 bool get_number(
const input_format_t format, NumberType& result)
10740 std::array<std::uint8_t,
sizeof(NumberType)> vec{};
10741 for (std::size_t i = 0; i <
sizeof(NumberType); ++i)
10744 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"number")))
10750 if (is_little_endian != InputIsLittleEndian)
10752 vec[
sizeof(NumberType) - i - 1] =
static_cast<std::uint8_t
>(current);
10756 vec[i] =
static_cast<std::uint8_t
>(current);
10761 std::memcpy(&result, vec.data(),
sizeof(NumberType));
10779 template<
typename NumberType>
10780 bool get_string(
const input_format_t format,
10781 const NumberType len,
10784 bool success =
true;
10785 for (NumberType i = 0; i < len; i++)
10788 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"string")))
10793 result.push_back(
static_cast<typename string_t::value_type
>(current));
10812 template<
typename NumberType>
10813 bool get_binary(
const input_format_t format,
10814 const NumberType len,
10817 bool success =
true;
10818 for (NumberType i = 0; i < len; i++)
10821 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"binary")))
10826 result.push_back(
static_cast<std::uint8_t
>(current));
10836 JSON_HEDLEY_NON_NULL(3)
10837 bool unexpect_eof(const input_format_t format, const
char* context)
const
10839 if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10841 return sax->parse_error(chars_read,
"<end of file>",
10842 parse_error::create(110, chars_read, exception_message(format,
"unexpected end of input", context), BasicJsonType()));
10850 std::string get_token_string()
const
10852 std::array<char, 3> cr{{}};
10853 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(current));
10854 return std::string{cr.data()};
10863 std::string exception_message(
const input_format_t format,
10864 const std::string& detail,
10865 const std::string& context)
const
10867 std::string error_msg =
"syntax error while parsing ";
10871 case input_format_t::cbor:
10872 error_msg +=
"CBOR";
10875 case input_format_t::msgpack:
10876 error_msg +=
"MessagePack";
10879 case input_format_t::ubjson:
10880 error_msg +=
"UBJSON";
10883 case input_format_t::bson:
10884 error_msg +=
"BSON";
10887 case input_format_t::json:
10889 JSON_ASSERT(
false);
10892 return error_msg +
" " + context +
": " + detail;
10897 InputAdapterType ia;
10900 char_int_type current = std::char_traits<char_type>::eof();
10903 std::size_t chars_read = 0;
10906 const bool is_little_endian = little_endianess();
10909 json_sax_t* sax =
nullptr;
10923#include <functional>
10951enum class parse_event_t : std::uint8_t
10967template<
typename BasicJsonType>
10968using parser_callback_t =
10969 std::function<bool(
int , parse_event_t , BasicJsonType& )>;
10976template<
typename BasicJsonType,
typename InputAdapterType>
10979 using number_integer_t =
typename BasicJsonType::number_integer_t;
10980 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
10981 using number_float_t =
typename BasicJsonType::number_float_t;
10982 using string_t =
typename BasicJsonType::string_t;
10983 using lexer_t = lexer<BasicJsonType, InputAdapterType>;
10984 using token_type =
typename lexer_t::token_type;
10988 explicit parser(InputAdapterType&& adapter,
10989 const parser_callback_t<BasicJsonType> cb =
nullptr,
10990 const bool allow_exceptions_ =
true,
10991 const bool skip_comments =
false)
10993 , m_lexer(
std::move(adapter), skip_comments)
10994 , allow_exceptions(allow_exceptions_)
11010 void parse(
const bool strict, BasicJsonType& result)
11014 json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
11015 sax_parse_internal(&sdp);
11018 if (strict && (get_token() != token_type::end_of_input))
11020 sdp.parse_error(m_lexer.get_position(),
11021 m_lexer.get_token_string(),
11022 parse_error::create(101, m_lexer.get_position(),
11023 exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
11027 if (sdp.is_errored())
11029 result = value_t::discarded;
11035 if (result.is_discarded())
11042 json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
11043 sax_parse_internal(&sdp);
11046 if (strict && (get_token() != token_type::end_of_input))
11048 sdp.parse_error(m_lexer.get_position(),
11049 m_lexer.get_token_string(),
11050 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
11054 if (sdp.is_errored())
11056 result = value_t::discarded;
11061 result.assert_invariant();
11070 bool accept(
const bool strict =
true)
11072 json_sax_acceptor<BasicJsonType> sax_acceptor;
11073 return sax_parse(&sax_acceptor, strict);
11076 template<
typename SAX>
11077 JSON_HEDLEY_NON_NULL(2)
11078 bool sax_parse(SAX* sax, const
bool strict = true)
11080 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
11081 const bool result = sax_parse_internal(sax);
11084 if (result && strict && (get_token() != token_type::end_of_input))
11086 return sax->parse_error(m_lexer.get_position(),
11087 m_lexer.get_token_string(),
11088 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
11095 template<
typename SAX>
11096 JSON_HEDLEY_NON_NULL(2)
11097 bool sax_parse_internal(SAX* sax)
11101 std::vector<bool> states;
11103 bool skip_to_state_evaluation =
false;
11107 if (!skip_to_state_evaluation)
11110 switch (last_token)
11112 case token_type::begin_object:
11114 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
11120 if (get_token() == token_type::end_object)
11122 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11130 if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
11132 return sax->parse_error(m_lexer.get_position(),
11133 m_lexer.get_token_string(),
11134 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string,
"object key"), BasicJsonType()));
11136 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11142 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11144 return sax->parse_error(m_lexer.get_position(),
11145 m_lexer.get_token_string(),
11146 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator,
"object separator"), BasicJsonType()));
11150 states.push_back(
false);
11157 case token_type::begin_array:
11159 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
11165 if (get_token() == token_type::end_array)
11167 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11175 states.push_back(
true);
11181 case token_type::value_float:
11183 const auto res = m_lexer.get_number_float();
11185 if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
11187 return sax->parse_error(m_lexer.get_position(),
11188 m_lexer.get_token_string(),
11189 out_of_range::create(406,
"number overflow parsing '" + m_lexer.get_token_string() +
"'", BasicJsonType()));
11192 if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
11200 case token_type::literal_false:
11202 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
false)))
11209 case token_type::literal_null:
11211 if (JSON_HEDLEY_UNLIKELY(!sax->null()))
11218 case token_type::literal_true:
11220 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
true)))
11227 case token_type::value_integer:
11229 if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
11236 case token_type::value_string:
11238 if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
11245 case token_type::value_unsigned:
11247 if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
11254 case token_type::parse_error:
11257 return sax->parse_error(m_lexer.get_position(),
11258 m_lexer.get_token_string(),
11259 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized,
"value"), BasicJsonType()));
11262 case token_type::uninitialized:
11263 case token_type::end_array:
11264 case token_type::end_object:
11265 case token_type::name_separator:
11266 case token_type::value_separator:
11267 case token_type::end_of_input:
11268 case token_type::literal_or_value:
11271 return sax->parse_error(m_lexer.get_position(),
11272 m_lexer.get_token_string(),
11273 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value,
"value"), BasicJsonType()));
11279 skip_to_state_evaluation =
false;
11283 if (states.empty())
11292 if (get_token() == token_type::value_separator)
11300 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
11302 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11311 JSON_ASSERT(!states.empty());
11313 skip_to_state_evaluation =
true;
11317 return sax->parse_error(m_lexer.get_position(),
11318 m_lexer.get_token_string(),
11319 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array,
"array"), BasicJsonType()));
11325 if (get_token() == token_type::value_separator)
11328 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
11330 return sax->parse_error(m_lexer.get_position(),
11331 m_lexer.get_token_string(),
11332 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string,
"object key"), BasicJsonType()));
11335 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11341 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11343 return sax->parse_error(m_lexer.get_position(),
11344 m_lexer.get_token_string(),
11345 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator,
"object separator"), BasicJsonType()));
11354 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
11356 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11365 JSON_ASSERT(!states.empty());
11367 skip_to_state_evaluation =
true;
11371 return sax->parse_error(m_lexer.get_position(),
11372 m_lexer.get_token_string(),
11373 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object,
"object"), BasicJsonType()));
11378 token_type get_token()
11380 return last_token = m_lexer.scan();
11383 std::string exception_message(
const token_type expected,
const std::string& context)
11385 std::string error_msg =
"syntax error ";
11387 if (!context.empty())
11389 error_msg +=
"while parsing " + context +
" ";
11394 if (last_token == token_type::parse_error)
11396 error_msg += std::string(m_lexer.get_error_message()) +
"; last read: '" +
11397 m_lexer.get_token_string() +
"'";
11401 error_msg +=
"unexpected " + std::string(lexer_t::token_type_name(last_token));
11404 if (expected != token_type::uninitialized)
11406 error_msg +=
"; expected " + std::string(lexer_t::token_type_name(expected));
11414 const parser_callback_t<BasicJsonType> callback =
nullptr;
11416 token_type last_token = token_type::uninitialized;
11420 const bool allow_exceptions =
true;
11451class primitive_iterator_t
11454 using difference_type = std::ptrdiff_t;
11455 static constexpr difference_type begin_value = 0;
11456 static constexpr difference_type end_value = begin_value + 1;
11458 JSON_PRIVATE_UNLESS_TESTED:
11460 difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
11463 constexpr difference_type get_value() const noexcept
11469 void set_begin() noexcept
11471 m_it = begin_value;
11475 void set_end() noexcept
11481 constexpr bool is_begin() const noexcept
11483 return m_it == begin_value;
11487 constexpr bool is_end() const noexcept
11489 return m_it == end_value;
11492 friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs)
noexcept
11494 return lhs.m_it == rhs.m_it;
11497 friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs)
noexcept
11499 return lhs.m_it < rhs.m_it;
11502 primitive_iterator_t operator+(difference_type n)
noexcept
11504 auto result = *
this;
11509 friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs)
noexcept
11511 return lhs.m_it - rhs.m_it;
11514 primitive_iterator_t& operator++() noexcept
11520 primitive_iterator_t
const operator++(
int)
noexcept
11522 auto result = *
this;
11527 primitive_iterator_t& operator--() noexcept
11533 primitive_iterator_t
const operator--(
int)
noexcept
11535 auto result = *
this;
11540 primitive_iterator_t& operator+=(difference_type n)
noexcept
11546 primitive_iterator_t& operator-=(difference_type n)
noexcept
11566template<
typename BasicJsonType>
struct internal_iterator
11569 typename BasicJsonType::object_t::iterator object_iterator {};
11571 typename BasicJsonType::array_t::iterator array_iterator {};
11573 primitive_iterator_t primitive_iterator {};
11582#include <type_traits>
11604template<
typename IteratorType>
class iteration_proxy;
11605template<
typename IteratorType>
class iteration_proxy_value;
11623template<
typename BasicJsonType>
11627 using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value,
typename std::remove_const<BasicJsonType>::type,
const BasicJsonType>::type>;
11629 friend other_iter_impl;
11630 friend BasicJsonType;
11631 friend iteration_proxy<iter_impl>;
11632 friend iteration_proxy_value<iter_impl>;
11634 using object_t =
typename BasicJsonType::object_t;
11635 using array_t =
typename BasicJsonType::array_t;
11637 static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
11638 "iter_impl only accepts (const) basic_json");
11647 using iterator_category = std::bidirectional_iterator_tag;
11650 using value_type =
typename BasicJsonType::value_type;
11652 using difference_type =
typename BasicJsonType::difference_type;
11654 using pointer =
typename std::conditional<std::is_const<BasicJsonType>::value,
11655 typename BasicJsonType::const_pointer,
11656 typename BasicJsonType::pointer>::type;
11659 typename std::conditional<std::is_const<BasicJsonType>::value,
11660 typename BasicJsonType::const_reference,
11661 typename BasicJsonType::reference>::type;
11663 iter_impl() =
default;
11664 ~iter_impl() =
default;
11665 iter_impl(iter_impl&&) noexcept = default;
11666 iter_impl& operator=(iter_impl&&) noexcept = default;
11674 explicit iter_impl(pointer
object) noexcept : m_object(
object)
11676 JSON_ASSERT(m_object !=
nullptr);
11678 switch (m_object->m_type)
11680 case value_t::object:
11682 m_it.object_iterator =
typename object_t::iterator();
11686 case value_t::array:
11688 m_it.array_iterator =
typename array_t::iterator();
11692 case value_t::null:
11693 case value_t::string:
11694 case value_t::boolean:
11695 case value_t::number_integer:
11696 case value_t::number_unsigned:
11697 case value_t::number_float:
11698 case value_t::binary:
11699 case value_t::discarded:
11702 m_it.primitive_iterator = primitive_iterator_t();
11724 iter_impl(
const iter_impl<const BasicJsonType>& other) noexcept
11725 : m_object(other.m_object), m_it(other.m_it)
11734 iter_impl& operator=(
const iter_impl<const BasicJsonType>& other)
noexcept
11736 if (&other !=
this)
11738 m_object = other.m_object;
11749 iter_impl(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
11750 : m_object(other.m_object), m_it(other.m_it)
11759 iter_impl& operator=(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other)
noexcept
11761 m_object = other.m_object;
11766 JSON_PRIVATE_UNLESS_TESTED:
11771 void set_begin() noexcept
11773 JSON_ASSERT(m_object !=
nullptr);
11775 switch (m_object->m_type)
11777 case value_t::object:
11779 m_it.object_iterator = m_object->m_value.object->begin();
11783 case value_t::array:
11785 m_it.array_iterator = m_object->m_value.array->begin();
11789 case value_t::null:
11792 m_it.primitive_iterator.set_end();
11796 case value_t::string:
11797 case value_t::boolean:
11798 case value_t::number_integer:
11799 case value_t::number_unsigned:
11800 case value_t::number_float:
11801 case value_t::binary:
11802 case value_t::discarded:
11805 m_it.primitive_iterator.set_begin();
11815 void set_end() noexcept
11817 JSON_ASSERT(m_object !=
nullptr);
11819 switch (m_object->m_type)
11821 case value_t::object:
11823 m_it.object_iterator = m_object->m_value.object->end();
11827 case value_t::array:
11829 m_it.array_iterator = m_object->m_value.array->end();
11833 case value_t::null:
11834 case value_t::string:
11835 case value_t::boolean:
11836 case value_t::number_integer:
11837 case value_t::number_unsigned:
11838 case value_t::number_float:
11839 case value_t::binary:
11840 case value_t::discarded:
11843 m_it.primitive_iterator.set_end();
11854 reference operator*()
const
11856 JSON_ASSERT(m_object !=
nullptr);
11858 switch (m_object->m_type)
11860 case value_t::object:
11862 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11863 return m_it.object_iterator->second;
11866 case value_t::array:
11868 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11869 return *m_it.array_iterator;
11872 case value_t::null:
11873 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11875 case value_t::string:
11876 case value_t::boolean:
11877 case value_t::number_integer:
11878 case value_t::number_unsigned:
11879 case value_t::number_float:
11880 case value_t::binary:
11881 case value_t::discarded:
11884 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11889 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11898 pointer operator->()
const
11900 JSON_ASSERT(m_object !=
nullptr);
11902 switch (m_object->m_type)
11904 case value_t::object:
11906 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11907 return &(m_it.object_iterator->second);
11910 case value_t::array:
11912 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11913 return &*m_it.array_iterator;
11916 case value_t::null:
11917 case value_t::string:
11918 case value_t::boolean:
11919 case value_t::number_integer:
11920 case value_t::number_unsigned:
11921 case value_t::number_float:
11922 case value_t::binary:
11923 case value_t::discarded:
11926 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11931 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11940 iter_impl
const operator++(
int)
11942 auto result = *
this;
11951 iter_impl& operator++()
11953 JSON_ASSERT(m_object !=
nullptr);
11955 switch (m_object->m_type)
11957 case value_t::object:
11959 std::advance(m_it.object_iterator, 1);
11963 case value_t::array:
11965 std::advance(m_it.array_iterator, 1);
11969 case value_t::null:
11970 case value_t::string:
11971 case value_t::boolean:
11972 case value_t::number_integer:
11973 case value_t::number_unsigned:
11974 case value_t::number_float:
11975 case value_t::binary:
11976 case value_t::discarded:
11979 ++m_it.primitive_iterator;
11991 iter_impl
const operator--(
int)
11993 auto result = *
this;
12002 iter_impl& operator--()
12004 JSON_ASSERT(m_object !=
nullptr);
12006 switch (m_object->m_type)
12008 case value_t::object:
12010 std::advance(m_it.object_iterator, -1);
12014 case value_t::array:
12016 std::advance(m_it.array_iterator, -1);
12020 case value_t::null:
12021 case value_t::string:
12022 case value_t::boolean:
12023 case value_t::number_integer:
12024 case value_t::number_unsigned:
12025 case value_t::number_float:
12026 case value_t::binary:
12027 case value_t::discarded:
12030 --m_it.primitive_iterator;
12042 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 >
12043 bool operator==(
const IterImpl& other)
const
12046 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
12048 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers", *m_object));
12051 JSON_ASSERT(m_object !=
nullptr);
12053 switch (m_object->m_type)
12055 case value_t::object:
12056 return (m_it.object_iterator == other.m_it.object_iterator);
12058 case value_t::array:
12059 return (m_it.array_iterator == other.m_it.array_iterator);
12061 case value_t::null:
12062 case value_t::string:
12063 case value_t::boolean:
12064 case value_t::number_integer:
12065 case value_t::number_unsigned:
12066 case value_t::number_float:
12067 case value_t::binary:
12068 case value_t::discarded:
12070 return (m_it.primitive_iterator == other.m_it.primitive_iterator);
12078 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 >
12079 bool operator!=(
const IterImpl& other)
const
12081 return !operator==(other);
12088 bool operator<(
const iter_impl& other)
const
12091 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
12093 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers", *m_object));
12096 JSON_ASSERT(m_object !=
nullptr);
12098 switch (m_object->m_type)
12100 case value_t::object:
12101 JSON_THROW(invalid_iterator::create(213,
"cannot compare order of object iterators", *m_object));
12103 case value_t::array:
12104 return (m_it.array_iterator < other.m_it.array_iterator);
12106 case value_t::null:
12107 case value_t::string:
12108 case value_t::boolean:
12109 case value_t::number_integer:
12110 case value_t::number_unsigned:
12111 case value_t::number_float:
12112 case value_t::binary:
12113 case value_t::discarded:
12115 return (m_it.primitive_iterator < other.m_it.primitive_iterator);
12123 bool operator<=(
const iter_impl& other)
const
12125 return !other.operator < (*this);
12132 bool operator>(
const iter_impl& other)
const
12134 return !operator<=(other);
12141 bool operator>=(
const iter_impl& other)
const
12143 return !operator<(other);
12150 iter_impl& operator+=(difference_type i)
12152 JSON_ASSERT(m_object !=
nullptr);
12154 switch (m_object->m_type)
12156 case value_t::object:
12157 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators", *m_object));
12159 case value_t::array:
12161 std::advance(m_it.array_iterator, i);
12165 case value_t::null:
12166 case value_t::string:
12167 case value_t::boolean:
12168 case value_t::number_integer:
12169 case value_t::number_unsigned:
12170 case value_t::number_float:
12171 case value_t::binary:
12172 case value_t::discarded:
12175 m_it.primitive_iterator += i;
12187 iter_impl& operator-=(difference_type i)
12189 return operator+=(-i);
12196 iter_impl operator+(difference_type i)
const
12198 auto result = *
this;
12207 friend iter_impl operator+(difference_type i,
const iter_impl& it)
12218 iter_impl operator-(difference_type i)
const
12220 auto result = *
this;
12229 difference_type operator-(
const iter_impl& other)
const
12231 JSON_ASSERT(m_object !=
nullptr);
12233 switch (m_object->m_type)
12235 case value_t::object:
12236 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators", *m_object));
12238 case value_t::array:
12239 return m_it.array_iterator - other.m_it.array_iterator;
12241 case value_t::null:
12242 case value_t::string:
12243 case value_t::boolean:
12244 case value_t::number_integer:
12245 case value_t::number_unsigned:
12246 case value_t::number_float:
12247 case value_t::binary:
12248 case value_t::discarded:
12250 return m_it.primitive_iterator - other.m_it.primitive_iterator;
12258 reference operator[](difference_type n)
const
12260 JSON_ASSERT(m_object !=
nullptr);
12262 switch (m_object->m_type)
12264 case value_t::object:
12265 JSON_THROW(invalid_iterator::create(208,
"cannot use operator[] for object iterators", *m_object));
12267 case value_t::array:
12268 return *std::next(m_it.array_iterator, n);
12270 case value_t::null:
12271 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
12273 case value_t::string:
12274 case value_t::boolean:
12275 case value_t::number_integer:
12276 case value_t::number_unsigned:
12277 case value_t::number_float:
12278 case value_t::binary:
12279 case value_t::discarded:
12282 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
12287 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
12296 const typename object_t::key_type& key()
const
12298 JSON_ASSERT(m_object !=
nullptr);
12300 if (JSON_HEDLEY_LIKELY(m_object->is_object()))
12302 return m_it.object_iterator->first;
12305 JSON_THROW(invalid_iterator::create(207,
"cannot use key() for non-object iterators", *m_object));
12312 reference value()
const
12314 return operator*();
12317 JSON_PRIVATE_UNLESS_TESTED:
12319 pointer m_object =
nullptr;
12321 internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
12361template<
typename Base>
12362class json_reverse_iterator :
public std::reverse_iterator<Base>
12365 using difference_type = std::ptrdiff_t;
12367 using base_iterator = std::reverse_iterator<Base>;
12369 using reference =
typename Base::reference;
12372 explicit json_reverse_iterator(
const typename base_iterator::iterator_type& it) noexcept
12373 : base_iterator(it) {}
12376 explicit json_reverse_iterator(
const base_iterator& it) noexcept : base_iterator(it) {}
12379 json_reverse_iterator
const operator++(
int)
12381 return static_cast<json_reverse_iterator
>(base_iterator::operator++(1));
12385 json_reverse_iterator& operator++()
12387 return static_cast<json_reverse_iterator&
>(base_iterator::operator++());
12391 json_reverse_iterator
const operator--(
int)
12393 return static_cast<json_reverse_iterator
>(base_iterator::operator--(1));
12397 json_reverse_iterator& operator--()
12399 return static_cast<json_reverse_iterator&
>(base_iterator::operator--());
12403 json_reverse_iterator& operator+=(difference_type i)
12405 return static_cast<json_reverse_iterator&
>(base_iterator::operator+=(i));
12409 json_reverse_iterator operator+(difference_type i)
const
12411 return static_cast<json_reverse_iterator
>(base_iterator::operator+(i));
12415 json_reverse_iterator operator-(difference_type i)
const
12417 return static_cast<json_reverse_iterator
>(base_iterator::operator-(i));
12421 difference_type operator-(
const json_reverse_iterator& other)
const
12423 return base_iterator(*
this) - base_iterator(other);
12427 reference operator[](difference_type n)
const
12429 return *(this->operator+(n));
12433 auto key() const -> decltype(
std::declval<Base>().key())
12435 auto it = --this->base();
12440 reference value()
const
12442 auto it = --this->base();
12443 return it.operator * ();
12454#include <algorithm>
12473template<
typename BasicJsonType>
12477 NLOHMANN_BASIC_JSON_TPL_DECLARATION
12503 : reference_tokens(split(s))
12522 return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
12524 [](
const std::string & a,
const std::string & b)
12526 return a +
"/" + detail::escape(b);
12531 operator std::string()
const
12554 reference_tokens.insert(reference_tokens.end(),
12555 ptr.reference_tokens.begin(),
12556 ptr.reference_tokens.end());
12600 return *
this /= std::to_string(array_idx);
12704 if (JSON_HEDLEY_UNLIKELY(
empty()))
12706 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12709 reference_tokens.pop_back();
12728 if (JSON_HEDLEY_UNLIKELY(
empty()))
12730 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12733 return reference_tokens.back();
12750 reference_tokens.push_back(token);
12756 reference_tokens.push_back(std::move(token));
12775 return reference_tokens.empty();
12789 static typename BasicJsonType::size_type array_index(
const std::string& s)
12791 using size_type =
typename BasicJsonType::size_type;
12794 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] ==
'0'))
12796 JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + s +
"' must not begin with '0'", BasicJsonType()));
12800 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >=
'1' && s[0] <=
'9')))
12802 JSON_THROW(detail::parse_error::create(109, 0,
"array index '" + s +
"' is not a number", BasicJsonType()));
12805 std::size_t processed_chars = 0;
12806 unsigned long long res = 0;
12809 res = std::stoull(s, &processed_chars);
12811 JSON_CATCH(std::out_of_range&)
12813 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'", BasicJsonType()));
12817 if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
12819 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'", BasicJsonType()));
12824 if (res >=
static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
12826 JSON_THROW(detail::out_of_range::create(410,
"array index " + s +
" exceeds size_type", BasicJsonType()));
12829 return static_cast<size_type
>(res);
12832 JSON_PRIVATE_UNLESS_TESTED:
12835 if (JSON_HEDLEY_UNLIKELY(
empty()))
12837 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12841 result.reference_tokens = {reference_tokens[0]};
12854 BasicJsonType& get_and_create(BasicJsonType& j)
const
12860 for (
const auto& reference_token : reference_tokens)
12862 switch (result->type())
12864 case detail::value_t::null:
12866 if (reference_token ==
"0")
12869 result = &result->operator[](0);
12874 result = &result->operator[](reference_token);
12879 case detail::value_t::object:
12882 result = &result->operator[](reference_token);
12886 case detail::value_t::array:
12889 result = &result->operator[](array_index(reference_token));
12899 case detail::value_t::string:
12900 case detail::value_t::boolean:
12901 case detail::value_t::number_integer:
12902 case detail::value_t::number_unsigned:
12903 case detail::value_t::number_float:
12904 case detail::value_t::binary:
12905 case detail::value_t::discarded:
12907 JSON_THROW(detail::type_error::create(313,
"invalid value to unflatten", j));
12933 BasicJsonType& get_unchecked(BasicJsonType* ptr)
const
12935 for (
const auto& reference_token : reference_tokens)
12938 if (ptr->is_null())
12942 std::all_of(reference_token.begin(), reference_token.end(),
12943 [](
const unsigned char x)
12945 return std::isdigit(x);
12949 *ptr = (nums || reference_token ==
"-")
12950 ? detail::value_t::array
12951 : detail::value_t::object;
12954 switch (ptr->type())
12956 case detail::value_t::object:
12959 ptr = &ptr->operator[](reference_token);
12963 case detail::value_t::array:
12965 if (reference_token ==
"-")
12968 ptr = &ptr->operator[](ptr->m_value.array->size());
12973 ptr = &ptr->operator[](array_index(reference_token));
12978 case detail::value_t::null:
12979 case detail::value_t::string:
12980 case detail::value_t::boolean:
12981 case detail::value_t::number_integer:
12982 case detail::value_t::number_unsigned:
12983 case detail::value_t::number_float:
12984 case detail::value_t::binary:
12985 case detail::value_t::discarded:
12987 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
13000 BasicJsonType& get_checked(BasicJsonType* ptr)
const
13002 for (
const auto& reference_token : reference_tokens)
13004 switch (ptr->type())
13006 case detail::value_t::object:
13009 ptr = &ptr->at(reference_token);
13013 case detail::value_t::array:
13015 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
13018 JSON_THROW(detail::out_of_range::create(402,
13019 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
13020 ") is out of range", *ptr));
13024 ptr = &ptr->at(array_index(reference_token));
13028 case detail::value_t::null:
13029 case detail::value_t::string:
13030 case detail::value_t::boolean:
13031 case detail::value_t::number_integer:
13032 case detail::value_t::number_unsigned:
13033 case detail::value_t::number_float:
13034 case detail::value_t::binary:
13035 case detail::value_t::discarded:
13037 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
13057 const BasicJsonType& get_unchecked(
const BasicJsonType* ptr)
const
13059 for (
const auto& reference_token : reference_tokens)
13061 switch (ptr->type())
13063 case detail::value_t::object:
13066 ptr = &ptr->operator[](reference_token);
13070 case detail::value_t::array:
13072 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
13075 JSON_THROW(detail::out_of_range::create(402,
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
") is out of range", *ptr));
13079 ptr = &ptr->operator[](array_index(reference_token));
13083 case detail::value_t::null:
13084 case detail::value_t::string:
13085 case detail::value_t::boolean:
13086 case detail::value_t::number_integer:
13087 case detail::value_t::number_unsigned:
13088 case detail::value_t::number_float:
13089 case detail::value_t::binary:
13090 case detail::value_t::discarded:
13092 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
13105 const BasicJsonType& get_checked(
const BasicJsonType* ptr)
const
13107 for (
const auto& reference_token : reference_tokens)
13109 switch (ptr->type())
13111 case detail::value_t::object:
13114 ptr = &ptr->at(reference_token);
13118 case detail::value_t::array:
13120 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
13123 JSON_THROW(detail::out_of_range::create(402,
13124 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
13125 ") is out of range", *ptr));
13129 ptr = &ptr->at(array_index(reference_token));
13133 case detail::value_t::null:
13134 case detail::value_t::string:
13135 case detail::value_t::boolean:
13136 case detail::value_t::number_integer:
13137 case detail::value_t::number_unsigned:
13138 case detail::value_t::number_float:
13139 case detail::value_t::binary:
13140 case detail::value_t::discarded:
13142 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
13153 bool contains(
const BasicJsonType* ptr)
const
13155 for (
const auto& reference_token : reference_tokens)
13157 switch (ptr->type())
13159 case detail::value_t::object:
13161 if (!ptr->contains(reference_token))
13167 ptr = &ptr->operator[](reference_token);
13171 case detail::value_t::array:
13173 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
13178 if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !(
"0" <= reference_token && reference_token <=
"9")))
13183 if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
13185 if (JSON_HEDLEY_UNLIKELY(!(
'1' <= reference_token[0] && reference_token[0] <=
'9')))
13190 for (std::size_t i = 1; i < reference_token.size(); i++)
13192 if (JSON_HEDLEY_UNLIKELY(!(
'0' <= reference_token[i] && reference_token[i] <=
'9')))
13200 const auto idx = array_index(reference_token);
13201 if (idx >= ptr->size())
13207 ptr = &ptr->operator[](idx);
13211 case detail::value_t::null:
13212 case detail::value_t::string:
13213 case detail::value_t::boolean:
13214 case detail::value_t::number_integer:
13215 case detail::value_t::number_unsigned:
13216 case detail::value_t::number_float:
13217 case detail::value_t::binary:
13218 case detail::value_t::discarded:
13241 static std::vector<std::string> split(
const std::string& reference_string)
13243 std::vector<std::string> result;
13246 if (reference_string.empty())
13252 if (JSON_HEDLEY_UNLIKELY(reference_string[0] !=
'/'))
13254 JSON_THROW(detail::parse_error::create(107, 1,
"JSON pointer must be empty or begin with '/' - was: '" + reference_string +
"'", BasicJsonType()));
13262 std::size_t slash = reference_string.find_first_of(
'/', 1),
13269 start = (slash == std::string::npos) ? 0 : slash + 1,
13271 slash = reference_string.find_first_of(
'/', start))
13275 auto reference_token = reference_string.substr(start, slash - start);
13278 for (std::size_t pos = reference_token.find_first_of(
'~');
13279 pos != std::string::npos;
13280 pos = reference_token.find_first_of(
'~', pos + 1))
13282 JSON_ASSERT(reference_token[pos] ==
'~');
13285 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
13286 (reference_token[pos + 1] !=
'0' &&
13287 reference_token[pos + 1] !=
'1')))
13289 JSON_THROW(detail::parse_error::create(108, 0,
"escape character '~' must be followed with '0' or '1'", BasicJsonType()));
13294 detail::unescape(reference_token);
13295 result.push_back(reference_token);
13309 static void flatten(
const std::string& reference_string,
13310 const BasicJsonType& value,
13311 BasicJsonType& result)
13313 switch (value.type())
13315 case detail::value_t::array:
13317 if (value.m_value.array->empty())
13320 result[reference_string] =
nullptr;
13325 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
13327 flatten(reference_string +
"/" + std::to_string(i),
13328 value.m_value.array->operator[](i), result);
13334 case detail::value_t::object:
13336 if (value.m_value.object->empty())
13339 result[reference_string] =
nullptr;
13344 for (
const auto& element : *value.m_value.object)
13346 flatten(reference_string +
"/" + detail::escape(element.first), element.second, result);
13352 case detail::value_t::null:
13353 case detail::value_t::string:
13354 case detail::value_t::boolean:
13355 case detail::value_t::number_integer:
13356 case detail::value_t::number_unsigned:
13357 case detail::value_t::number_float:
13358 case detail::value_t::binary:
13359 case detail::value_t::discarded:
13363 result[reference_string] = value;
13379 static BasicJsonType
13380 unflatten(
const BasicJsonType& value)
13382 if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
13384 JSON_THROW(detail::type_error::create(314,
"only objects can be unflattened", value));
13387 BasicJsonType result;
13390 for (
const auto& element : *value.m_value.object)
13392 if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
13394 JSON_THROW(detail::type_error::create(315,
"values in object must be primitive", element.second));
13401 json_pointer(element.first).get_and_create(result) = element.second;
13421 return lhs.reference_tokens == rhs.reference_tokens;
13438 return !(lhs == rhs);
13442 std::vector<std::string> reference_tokens;
13449#include <initializer_list>
13459template<
typename BasicJsonType>
13463 using value_type = BasicJsonType;
13465 json_ref(value_type&& value)
13466 : owned_value(
std::move(value))
13469 json_ref(
const value_type& value)
13470 : value_ref(&value)
13473 json_ref(std::initializer_list<json_ref> init)
13474 : owned_value(init)
13479 enable_if_t<std::is_constructible<value_type, Args...>::value,
int> = 0 >
13480 json_ref(Args && ... args)
13481 : owned_value(
std::forward<Args>(args)...)
13485 json_ref(json_ref&&) noexcept = default;
13486 json_ref(const json_ref&) = delete;
13487 json_ref& operator=(const json_ref&) = delete;
13488 json_ref& operator=(json_ref&&) = delete;
13489 ~json_ref() = default;
13491 value_type moved_or_copied()
const
13493 if (value_ref ==
nullptr)
13495 return std::move(owned_value);
13500 value_type
const& operator*()
const
13502 return value_ref ? *value_ref : owned_value;
13505 value_type
const* operator->()
const
13511 mutable value_type owned_value =
nullptr;
13512 value_type
const* value_ref =
nullptr;
13528#include <algorithm>
13544#include <algorithm>
13564template<
typename CharType>
struct output_adapter_protocol
13566 virtual void write_character(CharType c) = 0;
13567 virtual void write_characters(
const CharType* s, std::size_t length) = 0;
13568 virtual ~output_adapter_protocol() =
default;
13570 output_adapter_protocol() =
default;
13571 output_adapter_protocol(
const output_adapter_protocol&) =
default;
13572 output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
13573 output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
13574 output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
13578template<typename CharType>
13579using output_adapter_t =
std::shared_ptr<output_adapter_protocol<CharType>>;
13582template<typename CharType, typename AllocatorType =
std::allocator<CharType>>
13583class output_vector_adapter : public output_adapter_protocol<CharType>
13586 explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
13590 void write_character(CharType c)
override
13595 JSON_HEDLEY_NON_NULL(2)
13596 void write_characters(const CharType* s,
std::
size_t length)
override
13598 std::copy(s, s + length, std::back_inserter(v));
13602 std::vector<CharType, AllocatorType>& v;
13607template<
typename CharType>
13608class output_stream_adapter :
public output_adapter_protocol<CharType>
13611 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
13615 void write_character(CharType c)
override
13620 JSON_HEDLEY_NON_NULL(2)
13621 void write_characters(const CharType* s,
std::
size_t length)
override
13623 stream.write(s,
static_cast<std::streamsize
>(length));
13627 std::basic_ostream<CharType>& stream;
13632template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13633class output_string_adapter :
public output_adapter_protocol<CharType>
13636 explicit output_string_adapter(StringType& s) noexcept
13640 void write_character(CharType c)
override
13645 JSON_HEDLEY_NON_NULL(2)
13646 void write_characters(const CharType* s,
std::
size_t length)
override
13648 str.append(s, length);
13655template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13656class output_adapter
13659 template<
typename AllocatorType = std::allocator<CharType>>
13660 output_adapter(std::vector<CharType, AllocatorType>& vec)
13661 : oa(
std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
13664 output_adapter(std::basic_ostream<CharType>& s)
13665 : oa(
std::make_shared<output_stream_adapter<CharType>>(s)) {}
13668 output_adapter(StringType& s)
13669 : oa(
std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
13671 operator output_adapter_t<CharType>()
13677 output_adapter_t<CharType> oa =
nullptr;
13694template<
typename BasicJsonType,
typename CharType>
13697 using string_t =
typename BasicJsonType::string_t;
13698 using binary_t =
typename BasicJsonType::binary_t;
13699 using number_float_t =
typename BasicJsonType::number_float_t;
13707 explicit binary_writer(output_adapter_t<CharType> adapter) : oa(
std::move(adapter))
13716 void write_bson(
const BasicJsonType& j)
13720 case value_t::object:
13722 write_bson_object(*j.m_value.object);
13726 case value_t::null:
13727 case value_t::array:
13728 case value_t::string:
13729 case value_t::boolean:
13730 case value_t::number_integer:
13731 case value_t::number_unsigned:
13732 case value_t::number_float:
13733 case value_t::binary:
13734 case value_t::discarded:
13737 JSON_THROW(type_error::create(317,
"to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));
13745 void write_cbor(
const BasicJsonType& j)
13749 case value_t::null:
13751 oa->write_character(to_char_type(0xF6));
13755 case value_t::boolean:
13757 oa->write_character(j.m_value.boolean
13758 ? to_char_type(0xF5)
13759 : to_char_type(0xF4));
13763 case value_t::number_integer:
13765 if (j.m_value.number_integer >= 0)
13770 if (j.m_value.number_integer <= 0x17)
13772 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13774 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
13776 oa->write_character(to_char_type(0x18));
13777 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13779 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
13781 oa->write_character(to_char_type(0x19));
13782 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13784 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
13786 oa->write_character(to_char_type(0x1A));
13787 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13791 oa->write_character(to_char_type(0x1B));
13792 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13799 const auto positive_number = -1 - j.m_value.number_integer;
13800 if (j.m_value.number_integer >= -24)
13802 write_number(
static_cast<std::uint8_t
>(0x20 + positive_number));
13804 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
13806 oa->write_character(to_char_type(0x38));
13807 write_number(
static_cast<std::uint8_t
>(positive_number));
13809 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
13811 oa->write_character(to_char_type(0x39));
13812 write_number(
static_cast<std::uint16_t
>(positive_number));
13814 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
13816 oa->write_character(to_char_type(0x3A));
13817 write_number(
static_cast<std::uint32_t
>(positive_number));
13821 oa->write_character(to_char_type(0x3B));
13822 write_number(
static_cast<std::uint64_t
>(positive_number));
13828 case value_t::number_unsigned:
13830 if (j.m_value.number_unsigned <= 0x17)
13832 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13834 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13836 oa->write_character(to_char_type(0x18));
13837 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13839 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13841 oa->write_character(to_char_type(0x19));
13842 write_number(
static_cast<std::uint16_t
>(j.m_value.number_unsigned));
13844 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13846 oa->write_character(to_char_type(0x1A));
13847 write_number(
static_cast<std::uint32_t
>(j.m_value.number_unsigned));
13851 oa->write_character(to_char_type(0x1B));
13852 write_number(
static_cast<std::uint64_t
>(j.m_value.number_unsigned));
13857 case value_t::number_float:
13859 if (std::isnan(j.m_value.number_float))
13862 oa->write_character(to_char_type(0xF9));
13863 oa->write_character(to_char_type(0x7E));
13864 oa->write_character(to_char_type(0x00));
13866 else if (std::isinf(j.m_value.number_float))
13869 oa->write_character(to_char_type(0xf9));
13870 oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
13871 oa->write_character(to_char_type(0x00));
13875 write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
13880 case value_t::string:
13883 const auto N = j.m_value.string->size();
13886 write_number(
static_cast<std::uint8_t
>(0x60 + N));
13888 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13890 oa->write_character(to_char_type(0x78));
13891 write_number(
static_cast<std::uint8_t
>(N));
13893 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13895 oa->write_character(to_char_type(0x79));
13896 write_number(
static_cast<std::uint16_t
>(N));
13898 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13900 oa->write_character(to_char_type(0x7A));
13901 write_number(
static_cast<std::uint32_t
>(N));
13904 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13906 oa->write_character(to_char_type(0x7B));
13907 write_number(
static_cast<std::uint64_t
>(N));
13912 oa->write_characters(
13913 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13914 j.m_value.string->size());
13918 case value_t::array:
13921 const auto N = j.m_value.array->size();
13924 write_number(
static_cast<std::uint8_t
>(0x80 + N));
13926 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13928 oa->write_character(to_char_type(0x98));
13929 write_number(
static_cast<std::uint8_t
>(N));
13931 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13933 oa->write_character(to_char_type(0x99));
13934 write_number(
static_cast<std::uint16_t
>(N));
13936 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13938 oa->write_character(to_char_type(0x9A));
13939 write_number(
static_cast<std::uint32_t
>(N));
13942 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13944 oa->write_character(to_char_type(0x9B));
13945 write_number(
static_cast<std::uint64_t
>(N));
13950 for (
const auto& el : *j.m_value.array)
13957 case value_t::binary:
13959 if (j.m_value.binary->has_subtype())
13961 if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
13963 write_number(
static_cast<std::uint8_t
>(0xd8));
13964 write_number(
static_cast<std::uint8_t
>(j.m_value.binary->subtype()));
13966 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
13968 write_number(
static_cast<std::uint8_t
>(0xd9));
13969 write_number(
static_cast<std::uint16_t
>(j.m_value.binary->subtype()));
13971 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
13973 write_number(
static_cast<std::uint8_t
>(0xda));
13974 write_number(
static_cast<std::uint32_t
>(j.m_value.binary->subtype()));
13976 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
13978 write_number(
static_cast<std::uint8_t
>(0xdb));
13979 write_number(
static_cast<std::uint64_t
>(j.m_value.binary->subtype()));
13984 const auto N = j.m_value.binary->size();
13987 write_number(
static_cast<std::uint8_t
>(0x40 + N));
13989 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13991 oa->write_character(to_char_type(0x58));
13992 write_number(
static_cast<std::uint8_t
>(N));
13994 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13996 oa->write_character(to_char_type(0x59));
13997 write_number(
static_cast<std::uint16_t
>(N));
13999 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14001 oa->write_character(to_char_type(0x5A));
14002 write_number(
static_cast<std::uint32_t
>(N));
14005 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
14007 oa->write_character(to_char_type(0x5B));
14008 write_number(
static_cast<std::uint64_t
>(N));
14013 oa->write_characters(
14014 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14020 case value_t::object:
14023 const auto N = j.m_value.object->size();
14026 write_number(
static_cast<std::uint8_t
>(0xA0 + N));
14028 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
14030 oa->write_character(to_char_type(0xB8));
14031 write_number(
static_cast<std::uint8_t
>(N));
14033 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14035 oa->write_character(to_char_type(0xB9));
14036 write_number(
static_cast<std::uint16_t
>(N));
14038 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14040 oa->write_character(to_char_type(0xBA));
14041 write_number(
static_cast<std::uint32_t
>(N));
14044 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
14046 oa->write_character(to_char_type(0xBB));
14047 write_number(
static_cast<std::uint64_t
>(N));
14052 for (
const auto& el : *j.m_value.object)
14054 write_cbor(el.first);
14055 write_cbor(el.second);
14060 case value_t::discarded:
14069 void write_msgpack(
const BasicJsonType& j)
14073 case value_t::null:
14075 oa->write_character(to_char_type(0xC0));
14079 case value_t::boolean:
14081 oa->write_character(j.m_value.boolean
14082 ? to_char_type(0xC3)
14083 : to_char_type(0xC2));
14087 case value_t::number_integer:
14089 if (j.m_value.number_integer >= 0)
14094 if (j.m_value.number_unsigned < 128)
14097 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14099 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
14102 oa->write_character(to_char_type(0xCC));
14103 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14105 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
14108 oa->write_character(to_char_type(0xCD));
14109 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
14111 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
14114 oa->write_character(to_char_type(0xCE));
14115 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
14117 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
14120 oa->write_character(to_char_type(0xCF));
14121 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
14126 if (j.m_value.number_integer >= -32)
14129 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
14131 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
14132 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
14135 oa->write_character(to_char_type(0xD0));
14136 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
14138 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
14139 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
14142 oa->write_character(to_char_type(0xD1));
14143 write_number(
static_cast<std::int16_t
>(j.m_value.number_integer));
14145 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
14146 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
14149 oa->write_character(to_char_type(0xD2));
14150 write_number(
static_cast<std::int32_t
>(j.m_value.number_integer));
14152 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
14153 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
14156 oa->write_character(to_char_type(0xD3));
14157 write_number(
static_cast<std::int64_t
>(j.m_value.number_integer));
14163 case value_t::number_unsigned:
14165 if (j.m_value.number_unsigned < 128)
14168 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14170 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
14173 oa->write_character(to_char_type(0xCC));
14174 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14176 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
14179 oa->write_character(to_char_type(0xCD));
14180 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
14182 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
14185 oa->write_character(to_char_type(0xCE));
14186 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
14188 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
14191 oa->write_character(to_char_type(0xCF));
14192 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
14197 case value_t::number_float:
14199 write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
14203 case value_t::string:
14206 const auto N = j.m_value.string->size();
14210 write_number(
static_cast<std::uint8_t
>(0xA0 | N));
14212 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
14215 oa->write_character(to_char_type(0xD9));
14216 write_number(
static_cast<std::uint8_t
>(N));
14218 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14221 oa->write_character(to_char_type(0xDA));
14222 write_number(
static_cast<std::uint16_t
>(N));
14224 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14227 oa->write_character(to_char_type(0xDB));
14228 write_number(
static_cast<std::uint32_t
>(N));
14232 oa->write_characters(
14233 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14234 j.m_value.string->size());
14238 case value_t::array:
14241 const auto N = j.m_value.array->size();
14245 write_number(
static_cast<std::uint8_t
>(0x90 | N));
14247 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14250 oa->write_character(to_char_type(0xDC));
14251 write_number(
static_cast<std::uint16_t
>(N));
14253 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14256 oa->write_character(to_char_type(0xDD));
14257 write_number(
static_cast<std::uint32_t
>(N));
14261 for (
const auto& el : *j.m_value.array)
14268 case value_t::binary:
14272 const bool use_ext = j.m_value.binary->has_subtype();
14275 const auto N = j.m_value.binary->size();
14276 if (N <= (std::numeric_limits<std::uint8_t>::max)())
14278 std::uint8_t output_type{};
14285 output_type = 0xD4;
14288 output_type = 0xD5;
14291 output_type = 0xD6;
14294 output_type = 0xD7;
14297 output_type = 0xD8;
14300 output_type = 0xC7;
14308 output_type = 0xC4;
14312 oa->write_character(to_char_type(output_type));
14315 write_number(
static_cast<std::uint8_t
>(N));
14318 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14320 std::uint8_t output_type = use_ext
14324 oa->write_character(to_char_type(output_type));
14325 write_number(
static_cast<std::uint16_t
>(N));
14327 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14329 std::uint8_t output_type = use_ext
14333 oa->write_character(to_char_type(output_type));
14334 write_number(
static_cast<std::uint32_t
>(N));
14340 write_number(
static_cast<std::int8_t
>(j.m_value.binary->subtype()));
14344 oa->write_characters(
14345 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14351 case value_t::object:
14354 const auto N = j.m_value.object->size();
14358 write_number(
static_cast<std::uint8_t
>(0x80 | (N & 0xF)));
14360 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14363 oa->write_character(to_char_type(0xDE));
14364 write_number(
static_cast<std::uint16_t
>(N));
14366 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14369 oa->write_character(to_char_type(0xDF));
14370 write_number(
static_cast<std::uint32_t
>(N));
14374 for (
const auto& el : *j.m_value.object)
14376 write_msgpack(el.first);
14377 write_msgpack(el.second);
14382 case value_t::discarded:
14394 void write_ubjson(
const BasicJsonType& j,
const bool use_count,
14395 const bool use_type,
const bool add_prefix =
true)
14399 case value_t::null:
14403 oa->write_character(to_char_type(
'Z'));
14408 case value_t::boolean:
14412 oa->write_character(j.m_value.boolean
14413 ? to_char_type(
'T')
14414 : to_char_type(
'F'));
14419 case value_t::number_integer:
14421 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
14425 case value_t::number_unsigned:
14427 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
14431 case value_t::number_float:
14433 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
14437 case value_t::string:
14441 oa->write_character(to_char_type(
'S'));
14443 write_number_with_ubjson_prefix(j.m_value.string->size(),
true);
14444 oa->write_characters(
14445 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14446 j.m_value.string->size());
14450 case value_t::array:
14454 oa->write_character(to_char_type(
'['));
14457 bool prefix_required =
true;
14458 if (use_type && !j.m_value.array->empty())
14460 JSON_ASSERT(use_count);
14461 const CharType first_prefix = ubjson_prefix(j.front());
14462 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
14463 [
this, first_prefix](
const BasicJsonType & v)
14465 return ubjson_prefix(v) == first_prefix;
14470 prefix_required =
false;
14471 oa->write_character(to_char_type(
'$'));
14472 oa->write_character(first_prefix);
14478 oa->write_character(to_char_type(
'#'));
14479 write_number_with_ubjson_prefix(j.m_value.array->size(),
true);
14482 for (
const auto& el : *j.m_value.array)
14484 write_ubjson(el, use_count, use_type, prefix_required);
14489 oa->write_character(to_char_type(
']'));
14495 case value_t::binary:
14499 oa->write_character(to_char_type(
'['));
14502 if (use_type && !j.m_value.binary->empty())
14504 JSON_ASSERT(use_count);
14505 oa->write_character(to_char_type(
'$'));
14506 oa->write_character(
'U');
14511 oa->write_character(to_char_type(
'#'));
14512 write_number_with_ubjson_prefix(j.m_value.binary->size(),
true);
14517 oa->write_characters(
14518 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14519 j.m_value.binary->size());
14523 for (
size_t i = 0; i < j.m_value.binary->size(); ++i)
14525 oa->write_character(to_char_type(
'U'));
14526 oa->write_character(j.m_value.binary->data()[i]);
14532 oa->write_character(to_char_type(
']'));
14538 case value_t::object:
14542 oa->write_character(to_char_type(
'{'));
14545 bool prefix_required =
true;
14546 if (use_type && !j.m_value.object->empty())
14548 JSON_ASSERT(use_count);
14549 const CharType first_prefix = ubjson_prefix(j.front());
14550 const bool same_prefix = std::all_of(j.begin(), j.end(),
14551 [
this, first_prefix](
const BasicJsonType & v)
14553 return ubjson_prefix(v) == first_prefix;
14558 prefix_required =
false;
14559 oa->write_character(to_char_type(
'$'));
14560 oa->write_character(first_prefix);
14566 oa->write_character(to_char_type(
'#'));
14567 write_number_with_ubjson_prefix(j.m_value.object->size(),
true);
14570 for (
const auto& el : *j.m_value.object)
14572 write_number_with_ubjson_prefix(el.first.size(),
true);
14573 oa->write_characters(
14574 reinterpret_cast<const CharType*
>(el.first.c_str()),
14576 write_ubjson(el.second, use_count, use_type, prefix_required);
14581 oa->write_character(to_char_type(
'}'));
14587 case value_t::discarded:
14602 static std::size_t calc_bson_entry_header_size(
const string_t& name,
const BasicJsonType& j)
14604 const auto it = name.find(
static_cast<typename string_t::value_type
>(0));
14605 if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
14607 JSON_THROW(out_of_range::create(409,
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) +
")", j));
14608 static_cast<void>(j);
14611 return 1ul + name.size() + 1u;
14617 void write_bson_entry_header(
const string_t& name,
14618 const std::uint8_t element_type)
14620 oa->write_character(to_char_type(element_type));
14621 oa->write_characters(
14622 reinterpret_cast<const CharType*
>(name.c_str()),
14629 void write_bson_boolean(
const string_t& name,
14632 write_bson_entry_header(name, 0x08);
14633 oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
14639 void write_bson_double(
const string_t& name,
14640 const double value)
14642 write_bson_entry_header(name, 0x01);
14643 write_number<double, true>(value);
14649 static std::size_t calc_bson_string_size(
const string_t& value)
14651 return sizeof(std::int32_t) + value.size() + 1ul;
14657 void write_bson_string(
const string_t& name,
14658 const string_t& value)
14660 write_bson_entry_header(name, 0x02);
14662 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size() + 1ul));
14663 oa->write_characters(
14664 reinterpret_cast<const CharType*
>(value.c_str()),
14671 void write_bson_null(
const string_t& name)
14673 write_bson_entry_header(name, 0x0A);
14679 static std::size_t calc_bson_integer_size(
const std::int64_t value)
14681 return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
14682 ?
sizeof(std::int32_t)
14683 :
sizeof(std::int64_t);
14689 void write_bson_integer(
const string_t& name,
14690 const std::int64_t value)
14692 if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
14694 write_bson_entry_header(name, 0x10);
14695 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value));
14699 write_bson_entry_header(name, 0x12);
14700 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(value));
14707 static constexpr std::size_t calc_bson_unsigned_size(
const std::uint64_t value)
noexcept
14709 return (value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14710 ?
sizeof(std::int32_t)
14711 :
sizeof(std::int64_t);
14717 void write_bson_unsigned(
const string_t& name,
14718 const BasicJsonType& j)
14720 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14722 write_bson_entry_header(name, 0x10 );
14723 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(j.m_value.number_unsigned));
14725 else if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14727 write_bson_entry_header(name, 0x12 );
14728 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(j.m_value.number_unsigned));
14732 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));
14739 void write_bson_object_entry(
const string_t& name,
14740 const typename BasicJsonType::object_t& value)
14742 write_bson_entry_header(name, 0x03);
14743 write_bson_object(value);
14749 static std::size_t calc_bson_array_size(
const typename BasicJsonType::array_t& value)
14751 std::size_t array_index = 0ul;
14753 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)
14755 return result + calc_bson_element_size(std::to_string(array_index++), el);
14758 return sizeof(std::int32_t) + embedded_document_size + 1ul;
14764 static std::size_t calc_bson_binary_size(
const typename BasicJsonType::binary_t& value)
14766 return sizeof(std::int32_t) + value.size() + 1ul;
14772 void write_bson_array(
const string_t& name,
14773 const typename BasicJsonType::array_t& value)
14775 write_bson_entry_header(name, 0x04);
14776 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_array_size(value)));
14778 std::size_t array_index = 0ul;
14780 for (
const auto& el : value)
14782 write_bson_element(std::to_string(array_index++), el);
14785 oa->write_character(to_char_type(0x00));
14791 void write_bson_binary(
const string_t& name,
14792 const binary_t& value)
14794 write_bson_entry_header(name, 0x05);
14796 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size()));
14797 write_number(value.has_subtype() ?
static_cast<std::uint8_t
>(value.subtype()) : std::uint8_t(0x00));
14799 oa->write_characters(
reinterpret_cast<const CharType*
>(value.data()), value.size());
14806 static std::size_t calc_bson_element_size(
const string_t& name,
14807 const BasicJsonType& j)
14809 const auto header_size = calc_bson_entry_header_size(name, j);
14812 case value_t::object:
14813 return header_size + calc_bson_object_size(*j.m_value.object);
14815 case value_t::array:
14816 return header_size + calc_bson_array_size(*j.m_value.array);
14818 case value_t::binary:
14819 return header_size + calc_bson_binary_size(*j.m_value.binary);
14821 case value_t::boolean:
14822 return header_size + 1ul;
14824 case value_t::number_float:
14825 return header_size + 8ul;
14827 case value_t::number_integer:
14828 return header_size + calc_bson_integer_size(j.m_value.number_integer);
14830 case value_t::number_unsigned:
14831 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
14833 case value_t::string:
14834 return header_size + calc_bson_string_size(*j.m_value.string);
14836 case value_t::null:
14837 return header_size + 0ul;
14840 case value_t::discarded:
14842 JSON_ASSERT(
false);
14854 void write_bson_element(
const string_t& name,
14855 const BasicJsonType& j)
14859 case value_t::object:
14860 return write_bson_object_entry(name, *j.m_value.object);
14862 case value_t::array:
14863 return write_bson_array(name, *j.m_value.array);
14865 case value_t::binary:
14866 return write_bson_binary(name, *j.m_value.binary);
14868 case value_t::boolean:
14869 return write_bson_boolean(name, j.m_value.boolean);
14871 case value_t::number_float:
14872 return write_bson_double(name, j.m_value.number_float);
14874 case value_t::number_integer:
14875 return write_bson_integer(name, j.m_value.number_integer);
14877 case value_t::number_unsigned:
14878 return write_bson_unsigned(name, j);
14880 case value_t::string:
14881 return write_bson_string(name, *j.m_value.string);
14883 case value_t::null:
14884 return write_bson_null(name);
14887 case value_t::discarded:
14889 JSON_ASSERT(
false);
14901 static std::size_t calc_bson_object_size(
const typename BasicJsonType::object_t& value)
14903 std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
14904 [](
size_t result,
const typename BasicJsonType::object_t::value_type & el)
14906 return result += calc_bson_element_size(el.first, el.second);
14909 return sizeof(std::int32_t) + document_size + 1ul;
14916 void write_bson_object(
const typename BasicJsonType::object_t& value)
14918 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_object_size(value)));
14920 for (
const auto& el : value)
14922 write_bson_element(el.first, el.second);
14925 oa->write_character(to_char_type(0x00));
14932 static constexpr CharType get_cbor_float_prefix(
float )
14934 return to_char_type(0xFA);
14937 static constexpr CharType get_cbor_float_prefix(
double )
14939 return to_char_type(0xFB);
14946 static constexpr CharType get_msgpack_float_prefix(
float )
14948 return to_char_type(0xCA);
14951 static constexpr CharType get_msgpack_float_prefix(
double )
14953 return to_char_type(0xCB);
14961 template<
typename NumberType,
typename std::enable_if<
14962 std::is_floating_point<NumberType>::value,
int>::type = 0>
14963 void write_number_with_ubjson_prefix(
const NumberType n,
14964 const bool add_prefix)
14968 oa->write_character(get_ubjson_float_prefix(n));
14974 template<
typename NumberType,
typename std::enable_if<
14975 std::is_unsigned<NumberType>::value,
int>::type = 0>
14976 void write_number_with_ubjson_prefix(
const NumberType n,
14977 const bool add_prefix)
14979 if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14983 oa->write_character(to_char_type(
'i'));
14985 write_number(
static_cast<std::uint8_t
>(n));
14987 else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14991 oa->write_character(to_char_type(
'U'));
14993 write_number(
static_cast<std::uint8_t
>(n));
14995 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14999 oa->write_character(to_char_type(
'I'));
15001 write_number(
static_cast<std::int16_t
>(n));
15003 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
15007 oa->write_character(to_char_type(
'l'));
15009 write_number(
static_cast<std::int32_t
>(n));
15011 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
15015 oa->write_character(to_char_type(
'L'));
15017 write_number(
static_cast<std::int64_t
>(n));
15023 oa->write_character(to_char_type(
'H'));
15026 const auto number = BasicJsonType(n).dump();
15027 write_number_with_ubjson_prefix(number.size(),
true);
15028 for (std::size_t i = 0; i < number.size(); ++i)
15030 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
15036 template <
typename NumberType,
typename std::enable_if <
15037 std::is_signed<NumberType>::value&&
15038 !std::is_floating_point<NumberType>::value,
int >::type = 0 >
15039 void write_number_with_ubjson_prefix(
const NumberType n,
15040 const bool add_prefix)
15042 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
15046 oa->write_character(to_char_type(
'i'));
15048 write_number(
static_cast<std::int8_t
>(n));
15050 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)()))
15054 oa->write_character(to_char_type(
'U'));
15056 write_number(
static_cast<std::uint8_t
>(n));
15058 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
15062 oa->write_character(to_char_type(
'I'));
15064 write_number(
static_cast<std::int16_t
>(n));
15066 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
15070 oa->write_character(to_char_type(
'l'));
15072 write_number(
static_cast<std::int32_t
>(n));
15074 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
15078 oa->write_character(to_char_type(
'L'));
15080 write_number(
static_cast<std::int64_t
>(n));
15087 oa->write_character(to_char_type(
'H'));
15090 const auto number = BasicJsonType(n).dump();
15091 write_number_with_ubjson_prefix(number.size(),
true);
15092 for (std::size_t i = 0; i < number.size(); ++i)
15094 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
15103 CharType ubjson_prefix(
const BasicJsonType& j)
const noexcept
15107 case value_t::null:
15110 case value_t::boolean:
15111 return j.m_value.boolean ?
'T' :
'F';
15113 case value_t::number_integer:
15115 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)())
15119 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)())
15123 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)())
15127 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)())
15131 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)())
15139 case value_t::number_unsigned:
15141 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
15145 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::uint8_t>::max)()))
15149 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
15153 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
15157 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
15165 case value_t::number_float:
15166 return get_ubjson_float_prefix(j.m_value.number_float);
15168 case value_t::string:
15171 case value_t::array:
15172 case value_t::binary:
15175 case value_t::object:
15178 case value_t::discarded:
15184 static constexpr CharType get_ubjson_float_prefix(
float )
15189 static constexpr CharType get_ubjson_float_prefix(
double )
15209 template<
typename NumberType,
bool OutputIsLittleEndian = false>
15210 void write_number(
const NumberType n)
15213 std::array<CharType,
sizeof(NumberType)> vec{};
15214 std::memcpy(vec.data(), &n,
sizeof(NumberType));
15217 if (is_little_endian != OutputIsLittleEndian)
15220 std::reverse(vec.begin(), vec.end());
15223 oa->write_characters(vec.data(),
sizeof(NumberType));
15226 void write_compact_float(
const number_float_t n, detail::input_format_t format)
15229#pragma GCC diagnostic push
15230#pragma GCC diagnostic ignored "-Wfloat-equal"
15232 if (
static_cast<double>(n) >=
static_cast<double>(std::numeric_limits<float>::lowest()) &&
15233 static_cast<double>(n) <=
static_cast<double>((std::numeric_limits<float>::max)()) &&
15234 static_cast<double>(
static_cast<float>(n)) ==
static_cast<double>(n))
15236 oa->write_character(format == detail::input_format_t::cbor
15237 ? get_cbor_float_prefix(
static_cast<float>(n))
15238 : get_msgpack_float_prefix(
static_cast<float>(n)));
15239 write_number(
static_cast<float>(n));
15243 oa->write_character(format == detail::input_format_t::cbor
15244 ? get_cbor_float_prefix(n)
15245 : get_msgpack_float_prefix(n));
15249#pragma GCC diagnostic pop
15258 template <
typename C = CharType,
15259 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * =
nullptr >
15260 static constexpr CharType to_char_type(std::uint8_t x)
noexcept
15262 return *
reinterpret_cast<char*
>(&x);
15265 template <
typename C = CharType,
15266 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * =
nullptr >
15267 static CharType to_char_type(std::uint8_t x)
noexcept
15269 static_assert(
sizeof(std::uint8_t) ==
sizeof(CharType),
"size of CharType must be equal to std::uint8_t");
15270 static_assert(std::is_trivial<CharType>::value,
"CharType must be trivial");
15272 std::memcpy(&result, &x,
sizeof(x));
15276 template<
typename C = CharType,
15277 enable_if_t<std::is_unsigned<C>::value>* =
nullptr>
15278 static constexpr CharType to_char_type(std::uint8_t x)
noexcept
15283 template <
typename InputCharType,
typename C = CharType,
15285 std::is_signed<C>::value &&
15286 std::is_signed<char>::value &&
15287 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
15289 static constexpr CharType to_char_type(InputCharType x)
noexcept
15296 const bool is_little_endian = little_endianess();
15299 output_adapter_t<CharType> oa =
nullptr;
15309#include <algorithm>
15318#include <type_traits>
15329#include <type_traits>
15361template<
typename Target,
typename Source>
15362Target reinterpret_bits(
const Source source)
15364 static_assert(
sizeof(Target) ==
sizeof(Source),
"size mismatch");
15367 std::memcpy(&target, &source,
sizeof(Source));
15373 static constexpr int kPrecision = 64;
15375 std::uint64_t f = 0;
15378 constexpr diyfp(std::uint64_t f_,
int e_) noexcept : f(f_), e(e_) {}
15384 static diyfp sub(
const diyfp& x,
const diyfp& y)
noexcept
15386 JSON_ASSERT(x.e == y.e);
15387 JSON_ASSERT(x.f >= y.f);
15389 return {x.f - y.f, x.e};
15396 static diyfp mul(
const diyfp& x,
const diyfp& y)
noexcept
15398 static_assert(kPrecision == 64,
"internal error");
15423 const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
15424 const std::uint64_t u_hi = x.f >> 32u;
15425 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
15426 const std::uint64_t v_hi = y.f >> 32u;
15428 const std::uint64_t p0 = u_lo * v_lo;
15429 const std::uint64_t p1 = u_lo * v_hi;
15430 const std::uint64_t p2 = u_hi * v_lo;
15431 const std::uint64_t p3 = u_hi * v_hi;
15433 const std::uint64_t p0_hi = p0 >> 32u;
15434 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
15435 const std::uint64_t p1_hi = p1 >> 32u;
15436 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
15437 const std::uint64_t p2_hi = p2 >> 32u;
15439 std::uint64_t Q = p0_hi + p1_lo + p2_lo;
15450 Q += std::uint64_t{1} << (64u - 32u - 1u);
15452 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
15454 return {h, x.e + y.e + 64};
15461 static diyfp normalize(diyfp x)
noexcept
15463 JSON_ASSERT(x.f != 0);
15465 while ((x.f >> 63u) == 0)
15478 static diyfp normalize_to(
const diyfp& x,
const int target_exponent)
noexcept
15480 const int delta = x.e - target_exponent;
15482 JSON_ASSERT(delta >= 0);
15483 JSON_ASSERT(((x.f << delta) >> delta) == x.f);
15485 return {x.f << delta, target_exponent};
15502template<
typename FloatType>
15503boundaries compute_boundaries(FloatType value)
15505 JSON_ASSERT(std::isfinite(value));
15506 JSON_ASSERT(value > 0);
15515 static_assert(std::numeric_limits<FloatType>::is_iec559,
15516 "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
15518 constexpr int kPrecision = std::numeric_limits<FloatType>::digits;
15519 constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
15520 constexpr int kMinExp = 1 - kBias;
15521 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1);
15523 using bits_type =
typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
15525 const auto bits =
static_cast<std::uint64_t
>(reinterpret_bits<bits_type>(value));
15526 const std::uint64_t E = bits >> (kPrecision - 1);
15527 const std::uint64_t F = bits & (kHiddenBit - 1);
15529 const bool is_denormal = E == 0;
15530 const diyfp v = is_denormal
15531 ? diyfp(F, kMinExp)
15532 : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
15555 const bool lower_boundary_is_closer = F == 0 && E > 1;
15556 const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
15557 const diyfp m_minus = lower_boundary_is_closer
15558 ? diyfp(4 * v.f - 1, v.e - 2)
15559 : diyfp(2 * v.f - 1, v.e - 1);
15562 const diyfp w_plus = diyfp::normalize(m_plus);
15565 const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
15567 return {diyfp::normalize(v), w_minus, w_plus};
15625constexpr int kAlpha = -60;
15626constexpr int kGamma = -32;
15642inline cached_power get_cached_power_for_binary_exponent(
int e)
15694 constexpr int kCachedPowersMinDecExp = -300;
15695 constexpr int kCachedPowersDecStep = 8;
15697 static constexpr std::array<cached_power, 79> kCachedPowers =
15700 { 0xAB70FE17C79AC6CA, -1060, -300 },
15701 { 0xFF77B1FCBEBCDC4F, -1034, -292 },
15702 { 0xBE5691EF416BD60C, -1007, -284 },
15703 { 0x8DD01FAD907FFC3C, -980, -276 },
15704 { 0xD3515C2831559A83, -954, -268 },
15705 { 0x9D71AC8FADA6C9B5, -927, -260 },
15706 { 0xEA9C227723EE8BCB, -901, -252 },
15707 { 0xAECC49914078536D, -874, -244 },
15708 { 0x823C12795DB6CE57, -847, -236 },
15709 { 0xC21094364DFB5637, -821, -228 },
15710 { 0x9096EA6F3848984F, -794, -220 },
15711 { 0xD77485CB25823AC7, -768, -212 },
15712 { 0xA086CFCD97BF97F4, -741, -204 },
15713 { 0xEF340A98172AACE5, -715, -196 },
15714 { 0xB23867FB2A35B28E, -688, -188 },
15715 { 0x84C8D4DFD2C63F3B, -661, -180 },
15716 { 0xC5DD44271AD3CDBA, -635, -172 },
15717 { 0x936B9FCEBB25C996, -608, -164 },
15718 { 0xDBAC6C247D62A584, -582, -156 },
15719 { 0xA3AB66580D5FDAF6, -555, -148 },
15720 { 0xF3E2F893DEC3F126, -529, -140 },
15721 { 0xB5B5ADA8AAFF80B8, -502, -132 },
15722 { 0x87625F056C7C4A8B, -475, -124 },
15723 { 0xC9BCFF6034C13053, -449, -116 },
15724 { 0x964E858C91BA2655, -422, -108 },
15725 { 0xDFF9772470297EBD, -396, -100 },
15726 { 0xA6DFBD9FB8E5B88F, -369, -92 },
15727 { 0xF8A95FCF88747D94, -343, -84 },
15728 { 0xB94470938FA89BCF, -316, -76 },
15729 { 0x8A08F0F8BF0F156B, -289, -68 },
15730 { 0xCDB02555653131B6, -263, -60 },
15731 { 0x993FE2C6D07B7FAC, -236, -52 },
15732 { 0xE45C10C42A2B3B06, -210, -44 },
15733 { 0xAA242499697392D3, -183, -36 },
15734 { 0xFD87B5F28300CA0E, -157, -28 },
15735 { 0xBCE5086492111AEB, -130, -20 },
15736 { 0x8CBCCC096F5088CC, -103, -12 },
15737 { 0xD1B71758E219652C, -77, -4 },
15738 { 0x9C40000000000000, -50, 4 },
15739 { 0xE8D4A51000000000, -24, 12 },
15740 { 0xAD78EBC5AC620000, 3, 20 },
15741 { 0x813F3978F8940984, 30, 28 },
15742 { 0xC097CE7BC90715B3, 56, 36 },
15743 { 0x8F7E32CE7BEA5C70, 83, 44 },
15744 { 0xD5D238A4ABE98068, 109, 52 },
15745 { 0x9F4F2726179A2245, 136, 60 },
15746 { 0xED63A231D4C4FB27, 162, 68 },
15747 { 0xB0DE65388CC8ADA8, 189, 76 },
15748 { 0x83C7088E1AAB65DB, 216, 84 },
15749 { 0xC45D1DF942711D9A, 242, 92 },
15750 { 0x924D692CA61BE758, 269, 100 },
15751 { 0xDA01EE641A708DEA, 295, 108 },
15752 { 0xA26DA3999AEF774A, 322, 116 },
15753 { 0xF209787BB47D6B85, 348, 124 },
15754 { 0xB454E4A179DD1877, 375, 132 },
15755 { 0x865B86925B9BC5C2, 402, 140 },
15756 { 0xC83553C5C8965D3D, 428, 148 },
15757 { 0x952AB45CFA97A0B3, 455, 156 },
15758 { 0xDE469FBD99A05FE3, 481, 164 },
15759 { 0xA59BC234DB398C25, 508, 172 },
15760 { 0xF6C69A72A3989F5C, 534, 180 },
15761 { 0xB7DCBF5354E9BECE, 561, 188 },
15762 { 0x88FCF317F22241E2, 588, 196 },
15763 { 0xCC20CE9BD35C78A5, 614, 204 },
15764 { 0x98165AF37B2153DF, 641, 212 },
15765 { 0xE2A0B5DC971F303A, 667, 220 },
15766 { 0xA8D9D1535CE3B396, 694, 228 },
15767 { 0xFB9B7CD9A4A7443C, 720, 236 },
15768 { 0xBB764C4CA7A44410, 747, 244 },
15769 { 0x8BAB8EEFB6409C1A, 774, 252 },
15770 { 0xD01FEF10A657842C, 800, 260 },
15771 { 0x9B10A4E5E9913129, 827, 268 },
15772 { 0xE7109BFBA19C0C9D, 853, 276 },
15773 { 0xAC2820D9623BF429, 880, 284 },
15774 { 0x80444B5E7AA7CF85, 907, 292 },
15775 { 0xBF21E44003ACDD2D, 933, 300 },
15776 { 0x8E679C2F5E44FF8F, 960, 308 },
15777 { 0xD433179D9C8CB841, 986, 316 },
15778 { 0x9E19DB92B4E31BA9, 1013, 324 },
15786 JSON_ASSERT(e >= -1500);
15787 JSON_ASSERT(e <= 1500);
15788 const int f = kAlpha - e - 1;
15789 const int k = (f * 78913) / (1 << 18) +
static_cast<int>(f > 0);
15791 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
15792 JSON_ASSERT(index >= 0);
15793 JSON_ASSERT(
static_cast<std::size_t
>(index) < kCachedPowers.size());
15795 const cached_power cached = kCachedPowers[
static_cast<std::size_t
>(index)];
15796 JSON_ASSERT(kAlpha <= cached.e + e + 64);
15797 JSON_ASSERT(kGamma >= cached.e + e + 64);
15806inline int find_largest_pow10(
const std::uint32_t n, std::uint32_t& pow10)
15809 if (n >= 1000000000)
15811 pow10 = 1000000000;
15815 if (n >= 100000000)
15860inline void grisu2_round(
char* buf,
int len, std::uint64_t dist, std::uint64_t delta,
15861 std::uint64_t rest, std::uint64_t ten_k)
15863 JSON_ASSERT(len >= 1);
15864 JSON_ASSERT(dist <= delta);
15865 JSON_ASSERT(rest <= delta);
15866 JSON_ASSERT(ten_k > 0);
15888 && delta - rest >= ten_k
15889 && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
15891 JSON_ASSERT(buf[len - 1] !=
'0');
15901inline void grisu2_digit_gen(
char* buffer,
int& length,
int& decimal_exponent,
15902 diyfp M_minus, diyfp w, diyfp M_plus)
15904 static_assert(kAlpha >= -60,
"internal error");
15905 static_assert(kGamma <= -32,
"internal error");
15919 JSON_ASSERT(M_plus.e >= kAlpha);
15920 JSON_ASSERT(M_plus.e <= kGamma);
15922 std::uint64_t delta = diyfp::sub(M_plus, M_minus).f;
15923 std::uint64_t dist = diyfp::sub(M_plus, w ).f;
15932 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
15934 auto p1 =
static_cast<std::uint32_t
>(M_plus.f >> -one.e);
15935 std::uint64_t p2 = M_plus.f & (one.f - 1);
15941 JSON_ASSERT(p1 > 0);
15943 std::uint32_t pow10{};
15944 const int k = find_largest_pow10(p1, pow10);
15971 const std::uint32_t d = p1 / pow10;
15972 const std::uint32_t r = p1 % pow10;
15977 JSON_ASSERT(d <= 9);
15978 buffer[length++] =
static_cast<char>(
'0' + d);
15997 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
16002 decimal_exponent += n;
16013 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
16014 grisu2_round(buffer, length, dist, delta, rest, ten_n);
16064 JSON_ASSERT(p2 > delta);
16075 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
16077 const std::uint64_t d = p2 >> -one.e;
16078 const std::uint64_t r = p2 & (one.f - 1);
16084 JSON_ASSERT(d <= 9);
16085 buffer[length++] =
static_cast<char>(
'0' + d);
16110 decimal_exponent -= m;
16118 const std::uint64_t ten_m = one.f;
16119 grisu2_round(buffer, length, dist, delta, p2, ten_m);
16141JSON_HEDLEY_NON_NULL(1)
16142inline
void grisu2(
char* buf,
int& len,
int& decimal_exponent,
16143 diyfp m_minus, diyfp v, diyfp m_plus)
16145 JSON_ASSERT(m_plus.e == m_minus.e);
16146 JSON_ASSERT(m_plus.e == v.e);
16157 const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
16159 const diyfp c_minus_k(cached.f, cached.e);
16162 const diyfp w = diyfp::mul(v, c_minus_k);
16163 const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
16164 const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
16187 const diyfp M_minus(w_minus.f + 1, w_minus.e);
16188 const diyfp M_plus (w_plus.f - 1, w_plus.e );
16190 decimal_exponent = -cached.k;
16192 grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
16200template<
typename FloatType>
16201JSON_HEDLEY_NON_NULL(1)
16202void grisu2(
char* buf,
int& len,
int& decimal_exponent, FloatType value)
16204 static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
16205 "internal error: not enough precision");
16207 JSON_ASSERT(std::isfinite(value));
16208 JSON_ASSERT(value > 0);
16227 const boundaries w = compute_boundaries(
static_cast<double>(value));
16229 const boundaries w = compute_boundaries(value);
16232 grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
16240JSON_HEDLEY_NON_NULL(1)
16242inline
char* append_exponent(
char* buf,
int e)
16244 JSON_ASSERT(e > -1000);
16245 JSON_ASSERT(e < 1000);
16257 auto k =
static_cast<std::uint32_t
>(e);
16263 *buf++ =
static_cast<char>(
'0' + k);
16267 *buf++ =
static_cast<char>(
'0' + k / 10);
16269 *buf++ =
static_cast<char>(
'0' + k);
16273 *buf++ =
static_cast<char>(
'0' + k / 100);
16275 *buf++ =
static_cast<char>(
'0' + k / 10);
16277 *buf++ =
static_cast<char>(
'0' + k);
16292JSON_HEDLEY_NON_NULL(1)
16294inline
char* format_buffer(
char* buf,
int len,
int decimal_exponent,
16295 int min_exp,
int max_exp)
16297 JSON_ASSERT(min_exp < 0);
16298 JSON_ASSERT(max_exp > 0);
16301 const int n = len + decimal_exponent;
16307 if (k <= n && n <= max_exp)
16312 std::memset(buf + k,
'0',
static_cast<size_t>(n) -
static_cast<size_t>(k));
16316 return buf + (
static_cast<size_t>(n) + 2);
16319 if (0 < n && n <= max_exp)
16324 JSON_ASSERT(k > n);
16326 std::memmove(buf + (
static_cast<size_t>(n) + 1), buf + n,
static_cast<size_t>(k) -
static_cast<size_t>(n));
16328 return buf + (
static_cast<size_t>(k) + 1U);
16331 if (min_exp < n && n <= 0)
16336 std::memmove(buf + (2 +
static_cast<size_t>(-n)), buf,
static_cast<size_t>(k));
16339 std::memset(buf + 2,
'0',
static_cast<size_t>(-n));
16340 return buf + (2U +
static_cast<size_t>(-n) +
static_cast<size_t>(k));
16355 std::memmove(buf + 2, buf + 1,
static_cast<size_t>(k) - 1);
16357 buf += 1 +
static_cast<size_t>(k);
16361 return append_exponent(buf, n - 1);
16376template<
typename FloatType>
16377JSON_HEDLEY_NON_NULL(1, 2)
16379char* to_chars(
char* first, const
char* last, FloatType value)
16381 static_cast<void>(last);
16382 JSON_ASSERT(std::isfinite(value));
16385 if (std::signbit(value))
16392#pragma GCC diagnostic push
16393#pragma GCC diagnostic ignored "-Wfloat-equal"
16404#pragma GCC diagnostic pop
16407 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
16414 int decimal_exponent = 0;
16415 dtoa_impl::grisu2(first, len, decimal_exponent, value);
16417 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
16420 constexpr int kMinExp = -4;
16422 constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
16424 JSON_ASSERT(last - first >= kMaxExp + 2);
16425 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
16426 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
16428 return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
16456enum class error_handler_t
16463template<
typename BasicJsonType>
16466 using string_t =
typename BasicJsonType::string_t;
16467 using number_float_t =
typename BasicJsonType::number_float_t;
16468 using number_integer_t =
typename BasicJsonType::number_integer_t;
16469 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
16470 using binary_char_t =
typename BasicJsonType::binary_t::value_type;
16471 static constexpr std::uint8_t UTF8_ACCEPT = 0;
16472 static constexpr std::uint8_t UTF8_REJECT = 1;
16480 serializer(output_adapter_t<char> s,
const char ichar,
16481 error_handler_t error_handler_ = error_handler_t::strict)
16483 , loc(
std::localeconv())
16484 , thousands_sep(loc->thousands_sep == nullptr ?
'\0' :
std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
16485 , decimal_point(loc->decimal_point == nullptr ?
'\0' :
std::char_traits<char>::to_char_type(* (loc->decimal_point)))
16486 , indent_char(ichar)
16487 , indent_string(512, indent_char)
16488 , error_handler(error_handler_)
16492 serializer(
const serializer&) =
delete;
16493 serializer& operator=(
const serializer&) =
delete;
16494 serializer(serializer&&) =
delete;
16495 serializer& operator=(serializer&&) =
delete;
16496 ~serializer() =
default;
16520 void dump(
const BasicJsonType& val,
16521 const bool pretty_print,
16522 const bool ensure_ascii,
16523 const unsigned int indent_step,
16524 const unsigned int current_indent = 0)
16526 switch (val.m_type)
16528 case value_t::object:
16530 if (val.m_value.object->empty())
16532 o->write_characters(
"{}", 2);
16538 o->write_characters(
"{\n", 2);
16541 const auto new_indent = current_indent + indent_step;
16542 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16544 indent_string.resize(indent_string.size() * 2,
' ');
16548 auto i = val.m_value.object->cbegin();
16549 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16551 o->write_characters(indent_string.c_str(), new_indent);
16552 o->write_character(
'\"');
16553 dump_escaped(i->first, ensure_ascii);
16554 o->write_characters(
"\": ", 3);
16555 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
16556 o->write_characters(
",\n", 2);
16560 JSON_ASSERT(i != val.m_value.object->cend());
16561 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16562 o->write_characters(indent_string.c_str(), new_indent);
16563 o->write_character(
'\"');
16564 dump_escaped(i->first, ensure_ascii);
16565 o->write_characters(
"\": ", 3);
16566 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
16568 o->write_character(
'\n');
16569 o->write_characters(indent_string.c_str(), current_indent);
16570 o->write_character(
'}');
16574 o->write_character(
'{');
16577 auto i = val.m_value.object->cbegin();
16578 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16580 o->write_character(
'\"');
16581 dump_escaped(i->first, ensure_ascii);
16582 o->write_characters(
"\":", 2);
16583 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
16584 o->write_character(
',');
16588 JSON_ASSERT(i != val.m_value.object->cend());
16589 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16590 o->write_character(
'\"');
16591 dump_escaped(i->first, ensure_ascii);
16592 o->write_characters(
"\":", 2);
16593 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
16595 o->write_character(
'}');
16601 case value_t::array:
16603 if (val.m_value.array->empty())
16605 o->write_characters(
"[]", 2);
16611 o->write_characters(
"[\n", 2);
16614 const auto new_indent = current_indent + indent_step;
16615 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16617 indent_string.resize(indent_string.size() * 2,
' ');
16621 for (
auto i = val.m_value.array->cbegin();
16622 i != val.m_value.array->cend() - 1; ++i)
16624 o->write_characters(indent_string.c_str(), new_indent);
16625 dump(*i,
true, ensure_ascii, indent_step, new_indent);
16626 o->write_characters(
",\n", 2);
16630 JSON_ASSERT(!val.m_value.array->empty());
16631 o->write_characters(indent_string.c_str(), new_indent);
16632 dump(val.m_value.array->back(),
true, ensure_ascii, indent_step, new_indent);
16634 o->write_character(
'\n');
16635 o->write_characters(indent_string.c_str(), current_indent);
16636 o->write_character(
']');
16640 o->write_character(
'[');
16643 for (
auto i = val.m_value.array->cbegin();
16644 i != val.m_value.array->cend() - 1; ++i)
16646 dump(*i,
false, ensure_ascii, indent_step, current_indent);
16647 o->write_character(
',');
16651 JSON_ASSERT(!val.m_value.array->empty());
16652 dump(val.m_value.array->back(),
false, ensure_ascii, indent_step, current_indent);
16654 o->write_character(
']');
16660 case value_t::string:
16662 o->write_character(
'\"');
16663 dump_escaped(*val.m_value.string, ensure_ascii);
16664 o->write_character(
'\"');
16668 case value_t::binary:
16672 o->write_characters(
"{\n", 2);
16675 const auto new_indent = current_indent + indent_step;
16676 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16678 indent_string.resize(indent_string.size() * 2,
' ');
16681 o->write_characters(indent_string.c_str(), new_indent);
16683 o->write_characters(
"\"bytes\": [", 10);
16685 if (!val.m_value.binary->empty())
16687 for (
auto i = val.m_value.binary->cbegin();
16688 i != val.m_value.binary->cend() - 1; ++i)
16691 o->write_characters(
", ", 2);
16693 dump_integer(val.m_value.binary->back());
16696 o->write_characters(
"],\n", 3);
16697 o->write_characters(indent_string.c_str(), new_indent);
16699 o->write_characters(
"\"subtype\": ", 11);
16700 if (val.m_value.binary->has_subtype())
16702 dump_integer(val.m_value.binary->subtype());
16706 o->write_characters(
"null", 4);
16708 o->write_character(
'\n');
16709 o->write_characters(indent_string.c_str(), current_indent);
16710 o->write_character(
'}');
16714 o->write_characters(
"{\"bytes\":[", 10);
16716 if (!val.m_value.binary->empty())
16718 for (
auto i = val.m_value.binary->cbegin();
16719 i != val.m_value.binary->cend() - 1; ++i)
16722 o->write_character(
',');
16724 dump_integer(val.m_value.binary->back());
16727 o->write_characters(
"],\"subtype\":", 12);
16728 if (val.m_value.binary->has_subtype())
16730 dump_integer(val.m_value.binary->subtype());
16731 o->write_character(
'}');
16735 o->write_characters(
"null}", 5);
16741 case value_t::boolean:
16743 if (val.m_value.boolean)
16745 o->write_characters(
"true", 4);
16749 o->write_characters(
"false", 5);
16754 case value_t::number_integer:
16756 dump_integer(val.m_value.number_integer);
16760 case value_t::number_unsigned:
16762 dump_integer(val.m_value.number_unsigned);
16766 case value_t::number_float:
16768 dump_float(val.m_value.number_float);
16772 case value_t::discarded:
16774 o->write_characters(
"<discarded>", 11);
16778 case value_t::null:
16780 o->write_characters(
"null", 4);
16785 JSON_ASSERT(
false);
16789 JSON_PRIVATE_UNLESS_TESTED:
16804 void dump_escaped(
const string_t& s,
const bool ensure_ascii)
16806 std::uint32_t codepoint{};
16807 std::uint8_t state = UTF8_ACCEPT;
16808 std::size_t bytes = 0;
16811 std::size_t bytes_after_last_accept = 0;
16812 std::size_t undumped_chars = 0;
16814 for (std::size_t i = 0; i < s.size(); ++i)
16816 const auto byte =
static_cast<std::uint8_t
>(s[i]);
16818 switch (decode(state, codepoint,
byte))
16826 string_buffer[bytes++] =
'\\';
16827 string_buffer[bytes++] =
'b';
16833 string_buffer[bytes++] =
'\\';
16834 string_buffer[bytes++] =
't';
16840 string_buffer[bytes++] =
'\\';
16841 string_buffer[bytes++] =
'n';
16847 string_buffer[bytes++] =
'\\';
16848 string_buffer[bytes++] =
'f';
16854 string_buffer[bytes++] =
'\\';
16855 string_buffer[bytes++] =
'r';
16861 string_buffer[bytes++] =
'\\';
16862 string_buffer[bytes++] =
'\"';
16868 string_buffer[bytes++] =
'\\';
16869 string_buffer[bytes++] =
'\\';
16877 if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
16879 if (codepoint <= 0xFFFF)
16882 (std::snprintf)(string_buffer.data() + bytes, 7,
"\\u%04x",
16883 static_cast<std::uint16_t
>(codepoint));
16889 (std::snprintf)(string_buffer.data() + bytes, 13,
"\\u%04x\\u%04x",
16890 static_cast<std::uint16_t
>(0xD7C0u + (codepoint >> 10u)),
16891 static_cast<std::uint16_t
>(0xDC00u + (codepoint & 0x3FFu)));
16899 string_buffer[bytes++] = s[i];
16908 if (string_buffer.size() - bytes < 13)
16910 o->write_characters(string_buffer.data(), bytes);
16915 bytes_after_last_accept = bytes;
16916 undumped_chars = 0;
16922 switch (error_handler)
16924 case error_handler_t::strict:
16926 std::string sn(9,
'\0');
16928 (std::snprintf)(&sn[0], sn.size(),
"%.2X", byte);
16929 JSON_THROW(type_error::create(316,
"invalid UTF-8 byte at index " + std::to_string(i) +
": 0x" + sn, BasicJsonType()));
16932 case error_handler_t::ignore:
16933 case error_handler_t::replace:
16939 if (undumped_chars > 0)
16946 bytes = bytes_after_last_accept;
16948 if (error_handler == error_handler_t::replace)
16953 string_buffer[bytes++] =
'\\';
16954 string_buffer[bytes++] =
'u';
16955 string_buffer[bytes++] =
'f';
16956 string_buffer[bytes++] =
'f';
16957 string_buffer[bytes++] =
'f';
16958 string_buffer[bytes++] =
'd';
16962 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xEF');
16963 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBF');
16964 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBD');
16970 if (string_buffer.size() - bytes < 13)
16972 o->write_characters(string_buffer.data(), bytes);
16976 bytes_after_last_accept = bytes;
16979 undumped_chars = 0;
16982 state = UTF8_ACCEPT;
16987 JSON_ASSERT(
false);
16997 string_buffer[bytes++] = s[i];
17006 if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
17011 o->write_characters(string_buffer.data(), bytes);
17017 switch (error_handler)
17019 case error_handler_t::strict:
17021 std::string sn(9,
'\0');
17023 (std::snprintf)(&sn[0], sn.size(),
"%.2X",
static_cast<std::uint8_t
>(s.back()));
17024 JSON_THROW(type_error::create(316,
"incomplete UTF-8 string; last byte: 0x" + sn, BasicJsonType()));
17027 case error_handler_t::ignore:
17030 o->write_characters(string_buffer.data(), bytes_after_last_accept);
17034 case error_handler_t::replace:
17037 o->write_characters(string_buffer.data(), bytes_after_last_accept);
17041 o->write_characters(
"\\ufffd", 6);
17045 o->write_characters(
"\xEF\xBF\xBD", 3);
17051 JSON_ASSERT(
false);
17065 inline unsigned int count_digits(number_unsigned_t x)
noexcept
17067 unsigned int n_digits = 1;
17076 return n_digits + 1;
17080 return n_digits + 2;
17084 return n_digits + 3;
17100 template <
typename NumberType, detail::enable_if_t <
17101 std::is_integral<NumberType>::value ||
17102 std::is_same<NumberType, number_unsigned_t>::value ||
17103 std::is_same<NumberType, number_integer_t>::value ||
17104 std::is_same<NumberType, binary_char_t>::value,
17106 void dump_integer(NumberType x)
17108 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
17111 {{
'0',
'0'}}, {{
'0',
'1'}}, {{
'0',
'2'}}, {{
'0',
'3'}}, {{
'0',
'4'}}, {{
'0',
'5'}}, {{
'0',
'6'}}, {{
'0',
'7'}}, {{
'0',
'8'}}, {{
'0',
'9'}},
17112 {{
'1',
'0'}}, {{
'1',
'1'}}, {{
'1',
'2'}}, {{
'1',
'3'}}, {{
'1',
'4'}}, {{
'1',
'5'}}, {{
'1',
'6'}}, {{
'1',
'7'}}, {{
'1',
'8'}}, {{
'1',
'9'}},
17113 {{
'2',
'0'}}, {{
'2',
'1'}}, {{
'2',
'2'}}, {{
'2',
'3'}}, {{
'2',
'4'}}, {{
'2',
'5'}}, {{
'2',
'6'}}, {{
'2',
'7'}}, {{
'2',
'8'}}, {{
'2',
'9'}},
17114 {{
'3',
'0'}}, {{
'3',
'1'}}, {{
'3',
'2'}}, {{
'3',
'3'}}, {{
'3',
'4'}}, {{
'3',
'5'}}, {{
'3',
'6'}}, {{
'3',
'7'}}, {{
'3',
'8'}}, {{
'3',
'9'}},
17115 {{
'4',
'0'}}, {{
'4',
'1'}}, {{
'4',
'2'}}, {{
'4',
'3'}}, {{
'4',
'4'}}, {{
'4',
'5'}}, {{
'4',
'6'}}, {{
'4',
'7'}}, {{
'4',
'8'}}, {{
'4',
'9'}},
17116 {{
'5',
'0'}}, {{
'5',
'1'}}, {{
'5',
'2'}}, {{
'5',
'3'}}, {{
'5',
'4'}}, {{
'5',
'5'}}, {{
'5',
'6'}}, {{
'5',
'7'}}, {{
'5',
'8'}}, {{
'5',
'9'}},
17117 {{
'6',
'0'}}, {{
'6',
'1'}}, {{
'6',
'2'}}, {{
'6',
'3'}}, {{
'6',
'4'}}, {{
'6',
'5'}}, {{
'6',
'6'}}, {{
'6',
'7'}}, {{
'6',
'8'}}, {{
'6',
'9'}},
17118 {{
'7',
'0'}}, {{
'7',
'1'}}, {{
'7',
'2'}}, {{
'7',
'3'}}, {{
'7',
'4'}}, {{
'7',
'5'}}, {{
'7',
'6'}}, {{
'7',
'7'}}, {{
'7',
'8'}}, {{
'7',
'9'}},
17119 {{
'8',
'0'}}, {{
'8',
'1'}}, {{
'8',
'2'}}, {{
'8',
'3'}}, {{
'8',
'4'}}, {{
'8',
'5'}}, {{
'8',
'6'}}, {{
'8',
'7'}}, {{
'8',
'8'}}, {{
'8',
'9'}},
17120 {{
'9',
'0'}}, {{
'9',
'1'}}, {{
'9',
'2'}}, {{
'9',
'3'}}, {{
'9',
'4'}}, {{
'9',
'5'}}, {{
'9',
'6'}}, {{
'9',
'7'}}, {{
'9',
'8'}}, {{
'9',
'9'}},
17127 o->write_character(
'0');
17132 auto buffer_ptr = number_buffer.begin();
17134 const bool is_negative = std::is_signed<NumberType>::value && !(x >= 0);
17135 number_unsigned_t abs_value;
17137 unsigned int n_chars{};
17142 abs_value = remove_sign(
static_cast<number_integer_t
>(x));
17145 n_chars = 1 + count_digits(abs_value);
17149 abs_value =
static_cast<number_unsigned_t
>(x);
17150 n_chars = count_digits(abs_value);
17154 JSON_ASSERT(n_chars < number_buffer.size() - 1);
17158 buffer_ptr += n_chars;
17162 while (abs_value >= 100)
17164 const auto digits_index =
static_cast<unsigned>((abs_value % 100));
17166 *(--buffer_ptr) = digits_to_99[digits_index][1];
17167 *(--buffer_ptr) = digits_to_99[digits_index][0];
17170 if (abs_value >= 10)
17172 const auto digits_index =
static_cast<unsigned>(abs_value);
17173 *(--buffer_ptr) = digits_to_99[digits_index][1];
17174 *(--buffer_ptr) = digits_to_99[digits_index][0];
17178 *(--buffer_ptr) =
static_cast<char>(
'0' + abs_value);
17181 o->write_characters(number_buffer.data(), n_chars);
17192 void dump_float(number_float_t x)
17195 if (!std::isfinite(x))
17197 o->write_characters(
"null", 4);
17206 static constexpr bool is_ieee_single_or_double
17207 = (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) ||
17208 (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);
17210 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
17213 void dump_float(number_float_t x, std::true_type )
17215 auto* begin = number_buffer.data();
17216 auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
17218 o->write_characters(begin,
static_cast<size_t>(end - begin));
17221 void dump_float(number_float_t x, std::false_type )
17224 static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
17228 std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(),
"%.*g", d, x);
17231 JSON_ASSERT(len > 0);
17233 JSON_ASSERT(
static_cast<std::size_t
>(len) < number_buffer.size());
17236 if (thousands_sep !=
'\0')
17239 const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
17240 std::fill(end, number_buffer.end(),
'\0');
17241 JSON_ASSERT((end - number_buffer.begin()) <= len);
17242 len = (end - number_buffer.begin());
17246 if (decimal_point !=
'\0' && decimal_point !=
'.')
17249 const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
17250 if (dec_pos != number_buffer.end())
17256 o->write_characters(number_buffer.data(),
static_cast<std::size_t
>(len));
17259 const bool value_is_int_like =
17260 std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
17263 return c ==
'.' || c ==
'e';
17266 if (value_is_int_like)
17268 o->write_characters(
".0", 2);
17293 static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep,
const std::uint8_t
byte)
noexcept
17295 static const std::array<std::uint8_t, 400> utf8d =
17298 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,
17299 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,
17300 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,
17301 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,
17302 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,
17303 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,
17304 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,
17305 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3,
17306 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
17307 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1,
17308 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,
17309 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,
17310 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,
17311 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
17315 JSON_ASSERT(
byte < utf8d.size());
17316 const std::uint8_t type = utf8d[byte];
17318 codep = (state != UTF8_ACCEPT)
17319 ? (
byte & 0x3fu) | (codep << 6u)
17320 : (0xFFu >> type) & (byte);
17322 std::size_t index = 256u +
static_cast<size_t>(state) * 16u +
static_cast<size_t>(type);
17323 JSON_ASSERT(index < 400);
17324 state = utf8d[index];
17333 number_unsigned_t remove_sign(number_unsigned_t x)
17335 JSON_ASSERT(
false);
17348 inline number_unsigned_t remove_sign(number_integer_t x)
noexcept
17350 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
17351 return static_cast<number_unsigned_t
>(-(x + 1)) + 1;
17356 output_adapter_t<char> o =
nullptr;
17359 std::array<char, 64> number_buffer{{}};
17362 const std::lconv* loc =
nullptr;
17364 const char thousands_sep =
'\0';
17366 const char decimal_point =
'\0';
17369 std::array<char, 512> string_buffer{{}};
17372 const char indent_char;
17374 string_t indent_string;
17377 const error_handler_t error_handler;
17389#include <functional>
17390#include <initializer_list>
17393#include <stdexcept>
17394#include <type_traits>
17406template <
class Key,
class T,
class IgnoredLess = std::less<Key>,
17407 class Allocator = std::allocator<std::pair<const Key, T>>>
17412 using Container = std::vector<std::pair<const Key, T>, Allocator>;
17413 using typename Container::iterator;
17414 using typename Container::const_iterator;
17415 using typename Container::size_type;
17416 using typename Container::value_type;
17421 template <
class It>
17424 ordered_map(std::initializer_list<T> init,
const Allocator& alloc = Allocator() )
17429 for (
auto it = this->begin(); it != this->end(); ++it)
17431 if (it->first == key)
17433 return {it,
false};
17436 Container::emplace_back(key, t);
17437 return {--this->end(),
true};
17442 return emplace(key, T{}).first->second;
17452 for (
auto it = this->begin(); it != this->end(); ++it)
17454 if (it->first == key)
17460 JSON_THROW(std::out_of_range(
"key not found"));
17463 const T&
at(
const Key& key)
const
17465 for (
auto it = this->begin(); it != this->end(); ++it)
17467 if (it->first == key)
17473 JSON_THROW(std::out_of_range(
"key not found"));
17478 for (
auto it = this->begin(); it != this->end(); ++it)
17480 if (it->first == key)
17483 for (
auto next = it; ++next != this->end(); ++it)
17486 new (&*it) value_type{std::move(*next)};
17488 Container::pop_back();
17500 for (
auto next = it; ++next != this->end(); ++it)
17503 new (&*it) value_type{std::move(*next)};
17505 Container::pop_back();
17511 for (
auto it = this->begin(); it != this->end(); ++it)
17513 if (it->first == key)
17523 for (
auto it = this->begin(); it != this->end(); ++it)
17525 if (it->first == key)
17530 return Container::end();
17533 const_iterator
find(
const Key& key)
const
17535 for (
auto it = this->begin(); it != this->end(); ++it)
17537 if (it->first == key)
17542 return Container::end();
17545 std::pair<iterator, bool>
insert( value_type&& value )
17547 return emplace(value.first, std::move(value.second));
17550 std::pair<iterator, bool>
insert(
const value_type& value )
17552 for (
auto it = this->begin(); it != this->end(); ++it)
17554 if (it->first == value.first)
17556 return {it,
false};
17559 Container::push_back(value);
17560 return {--this->end(),
true};
17563 template<
typename InputIt>
17564 using require_input_iter =
typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
17565 std::input_iterator_tag>::value>::type;
17567 template<
typename InputIt,
typename = require_input_iter<InputIt>>
17570 for (
auto it = first; it != last; ++it)
17580#if defined(JSON_HAS_CPP_17)
17581 #include <string_view>
17676NLOHMANN_BASIC_JSON_TPL_DECLARATION
17681 friend ::nlohmann::json_pointer<basic_json>;
17683 template<
typename BasicJsonType,
typename InputType>
17684 friend class ::nlohmann::detail::parser;
17685 friend ::nlohmann::detail::serializer<basic_json>;
17686 template<
typename BasicJsonType>
17687 friend class ::nlohmann::detail::iter_impl;
17688 template<
typename BasicJsonType,
typename CharType>
17689 friend class ::nlohmann::detail::binary_writer;
17690 template<
typename BasicJsonType,
typename InputType,
typename SAX>
17691 friend class ::nlohmann::detail::binary_reader;
17692 template<
typename BasicJsonType>
17693 friend class ::nlohmann::detail::json_sax_dom_parser;
17694 template<
typename BasicJsonType>
17695 friend class ::nlohmann::detail::json_sax_dom_callback_parser;
17696 friend class ::nlohmann::detail::exception;
17699 using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
17701 JSON_PRIVATE_UNLESS_TESTED:
17703 using lexer = ::nlohmann::detail::lexer_base<basic_json>;
17705 template<
typename InputAdapterType>
17706 static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
17707 InputAdapterType adapter,
17708 detail::parser_callback_t<basic_json>cb =
nullptr,
17709 const bool allow_exceptions =
true,
17710 const bool ignore_comments =
false
17713 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
17714 std::move(cb), allow_exceptions, ignore_comments);
17718 using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
17719 template<
typename BasicJsonType>
17720 using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
17721 template<
typename BasicJsonType>
17722 using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
17723 template<
typename Iterator>
17724 using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
17725 template<
typename Base>
using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
17727 template<
typename CharType>
17728 using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
17730 template<
typename InputType>
17731 using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
17732 template<
typename CharType>
using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
17734 JSON_PRIVATE_UNLESS_TESTED:
17735 using serializer = ::nlohmann::detail::serializer<basic_json>;
17738 using value_t = detail::value_t;
17741 template<
typename T,
typename SFINAE>
17744 using error_handler_t = detail::error_handler_t;
17746 using cbor_tag_handler_t = detail::cbor_tag_handler_t;
17750 using input_format_t = detail::input_format_t;
17804 using pointer =
typename std::allocator_traits<allocator_type>::pointer;
17806 using const_pointer =
typename std::allocator_traits<allocator_type>::const_pointer;
17859 result[
"copyright"] =
"(C) 2013-2021 Niels Lohmann";
17860 result[
"name"] =
"JSON for Modern C++";
17861 result[
"url"] =
"https://github.com/nlohmann/json";
17862 result[
"version"][
"string"] =
17863 std::to_string(NLOHMANN_JSON_VERSION_MAJOR) +
"." +
17864 std::to_string(NLOHMANN_JSON_VERSION_MINOR) +
"." +
17865 std::to_string(NLOHMANN_JSON_VERSION_PATCH);
17866 result[
"version"][
"major"] = NLOHMANN_JSON_VERSION_MAJOR;
17867 result[
"version"][
"minor"] = NLOHMANN_JSON_VERSION_MINOR;
17868 result[
"version"][
"patch"] = NLOHMANN_JSON_VERSION_PATCH;
17871 result[
"platform"] =
"win32";
17872#elif defined __linux__
17873 result[
"platform"] =
"linux";
17874#elif defined __APPLE__
17875 result[
"platform"] =
"apple";
17876#elif defined __unix__
17877 result[
"platform"] =
"unix";
17879 result[
"platform"] =
"unknown";
17882#if defined(__ICC) || defined(__INTEL_COMPILER)
17883 result[
"compiler"] = {{
"family",
"icc"}, {
"version", __INTEL_COMPILER}};
17884#elif defined(__clang__)
17885 result[
"compiler"] = {{
"family",
"clang"}, {
"version", __clang_version__}};
17886#elif defined(__GNUC__) || defined(__GNUG__)
17887 result[
"compiler"] = {{
"family",
"gcc"}, {
"version", std::to_string(__GNUC__) +
"." + std::to_string(__GNUC_MINOR__) +
"." + std::to_string(__GNUC_PATCHLEVEL__)}};
17888#elif defined(__HP_cc) || defined(__HP_aCC)
17889 result[
"compiler"] =
"hp"
17890#elif defined(__IBMCPP__)
17891 result[
"compiler"] = {{
"family",
"ilecpp"}, {
"version", __IBMCPP__}};
17892#elif defined(_MSC_VER)
17893 result[
"compiler"] = {{
"family",
"msvc"}, {
"version", _MSC_VER}};
17894#elif defined(__PGI)
17895 result[
"compiler"] = {{
"family",
"pgcpp"}, {
"version", __PGI}};
17896#elif defined(__SUNPRO_CC)
17897 result[
"compiler"] = {{
"family",
"sunpro"}, {
"version", __SUNPRO_CC}};
17899 result[
"compiler"] = {{
"family",
"unknown"}, {
"version",
"unknown"}};
17903 result[
"compiler"][
"c++"] = std::to_string(__cplusplus);
17905 result[
"compiler"][
"c++"] =
"unknown";
17920#if defined(JSON_HAS_CPP_14)
18014 AllocatorType<std::pair<
const StringType,
18061 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
18428 template<
typename T,
typename... Args>
18430 static T* create(Args&& ... args)
18432 AllocatorType<T> alloc;
18433 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
18435 auto deleter = [&](T * obj)
18437 AllocatorTraits::deallocate(alloc, obj, 1);
18439 std::unique_ptr<T,
decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
18440 AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
18441 JSON_ASSERT(obj !=
nullptr);
18442 return obj.release();
18449 JSON_PRIVATE_UNLESS_TESTED:
18495 json_value() =
default;
18497 json_value(
boolean_t v) noexcept : boolean(v) {}
18509 case value_t::object:
18511 object = create<object_t>();
18515 case value_t::array:
18517 array = create<array_t>();
18521 case value_t::string:
18523 string = create<string_t>(
"");
18527 case value_t::binary:
18529 binary = create<binary_t>();
18533 case value_t::boolean:
18539 case value_t::number_integer:
18545 case value_t::number_unsigned:
18551 case value_t::number_float:
18557 case value_t::null:
18563 case value_t::discarded:
18567 if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
18569 JSON_THROW(other_error::create(500,
"961c151d2e87f2686a955a9be24d316f1362bf21 3.10.4",
basic_json()));
18579 string = create<string_t>(
value);
18585 string = create<string_t>(std::move(
value));
18591 object = create<object_t>(
value);
18597 object = create<object_t>(std::move(
value));
18603 array = create<array_t>(
value);
18609 array = create<array_t>(std::move(
value));
18615 binary = create<binary_t>(
value);
18621 binary = create<binary_t>(std::move(
value));
18627 binary = create<binary_t>(
value);
18633 binary = create<binary_t>(std::move(
value));
18638 if (t == value_t::array || t == value_t::object)
18641 std::vector<basic_json> stack;
18644 if (t == value_t::array)
18646 stack.reserve(array->size());
18647 std::move(array->begin(), array->end(), std::back_inserter(stack));
18652 for (
auto&& it : *
object)
18654 stack.push_back(std::move(it.second));
18658 while (!stack.empty())
18661 basic_json current_item(std::move(stack.back()));
18666 if (current_item.is_array())
18668 std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
18670 current_item.m_value.array->clear();
18672 else if (current_item.is_object())
18674 for (
auto&& it : *current_item.m_value.object)
18676 stack.push_back(std::move(it.second));
18679 current_item.m_value.object->clear();
18689 case value_t::object:
18691 AllocatorType<object_t> alloc;
18692 std::allocator_traits<
decltype(alloc)>::destroy(alloc,
object);
18693 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
object, 1);
18697 case value_t::array:
18699 AllocatorType<array_t> alloc;
18700 std::allocator_traits<
decltype(alloc)>::destroy(alloc, array);
18701 std::allocator_traits<
decltype(alloc)>::deallocate(alloc, array, 1);
18705 case value_t::string:
18707 AllocatorType<string_t> alloc;
18708 std::allocator_traits<
decltype(alloc)>::destroy(alloc,
string);
18709 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
string, 1);
18713 case value_t::binary:
18715 AllocatorType<binary_t> alloc;
18716 std::allocator_traits<
decltype(alloc)>::destroy(alloc, binary);
18717 std::allocator_traits<
decltype(alloc)>::deallocate(alloc, binary, 1);
18721 case value_t::null:
18722 case value_t::boolean:
18723 case value_t::number_integer:
18724 case value_t::number_unsigned:
18725 case value_t::number_float:
18726 case value_t::discarded:
18754 void assert_invariant(
bool check_parents =
true) const noexcept
18756 JSON_ASSERT(m_type != value_t::object ||
m_value.object !=
nullptr);
18757 JSON_ASSERT(m_type != value_t::array ||
m_value.array !=
nullptr);
18758 JSON_ASSERT(m_type != value_t::string ||
m_value.string !=
nullptr);
18759 JSON_ASSERT(m_type != value_t::binary ||
m_value.binary !=
nullptr);
18761#if JSON_DIAGNOSTICS
18767 return j.m_parent ==
this;
18772 static_cast<void>(check_parents);
18777#if JSON_DIAGNOSTICS
18780 case value_t::array:
18782 for (
auto& element : *
m_value.array)
18784 element.m_parent =
this;
18789 case value_t::object:
18791 for (
auto& element : *
m_value.object)
18793 element.second.m_parent =
this;
18798 case value_t::null:
18799 case value_t::string:
18800 case value_t::boolean:
18801 case value_t::number_integer:
18802 case value_t::number_unsigned:
18803 case value_t::number_float:
18804 case value_t::binary:
18805 case value_t::discarded:
18814#if JSON_DIAGNOSTICS
18815 for (
typename iterator::difference_type i = 0; i <
count; ++i)
18817 (it + i)->m_parent =
this;
18820 static_cast<void>(
count);
18827#if JSON_DIAGNOSTICS
18828 if (old_capacity != std::size_t(-1))
18831 JSON_ASSERT(
type() == value_t::array);
18832 if (JSON_HEDLEY_UNLIKELY(
m_value.array->capacity() != old_capacity))
18842#ifdef JSON_HEDLEY_MSVC_VERSION
18843#pragma warning(push )
18844#pragma warning(disable : 4127)
18846 if (detail::is_ordered_map<object_t>::value)
18851#ifdef JSON_HEDLEY_MSVC_VERSION
18852#pragma warning( pop )
18857 static_cast<void>(j);
18858 static_cast<void>(old_capacity);
18883 using parse_event_t = detail::parse_event_t;
18978 assert_invariant();
19002 assert_invariant();
19067 template <
typename CompatibleType,
19068 typename U = detail::uncvref_t<CompatibleType>,
19069 detail::enable_if_t <
19070 !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value,
int > = 0 >
19072 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
19073 std::forward<CompatibleType>(val))))
19075 JSONSerializer<U>::to_json(*
this, std::forward<CompatibleType>(val));
19077 assert_invariant();
19106 template <
typename BasicJsonType,
19107 detail::enable_if_t <
19108 detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value,
int > = 0 >
19111 using other_boolean_t =
typename BasicJsonType::boolean_t;
19112 using other_number_float_t =
typename BasicJsonType::number_float_t;
19113 using other_number_integer_t =
typename BasicJsonType::number_integer_t;
19114 using other_number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
19115 using other_string_t =
typename BasicJsonType::string_t;
19116 using other_object_t =
typename BasicJsonType::object_t;
19117 using other_array_t =
typename BasicJsonType::array_t;
19118 using other_binary_t =
typename BasicJsonType::binary_t;
19120 switch (val.type())
19122 case value_t::boolean:
19123 JSONSerializer<other_boolean_t>::to_json(*
this, val.template get<other_boolean_t>());
19125 case value_t::number_float:
19126 JSONSerializer<other_number_float_t>::to_json(*
this, val.template get<other_number_float_t>());
19128 case value_t::number_integer:
19129 JSONSerializer<other_number_integer_t>::to_json(*
this, val.template get<other_number_integer_t>());
19131 case value_t::number_unsigned:
19132 JSONSerializer<other_number_unsigned_t>::to_json(*
this, val.template get<other_number_unsigned_t>());
19134 case value_t::string:
19135 JSONSerializer<other_string_t>::to_json(*
this, val.template get_ref<const other_string_t&>());
19137 case value_t::object:
19138 JSONSerializer<other_object_t>::to_json(*
this, val.template get_ref<const other_object_t&>());
19140 case value_t::array:
19141 JSONSerializer<other_array_t>::to_json(*
this, val.template get_ref<const other_array_t&>());
19143 case value_t::binary:
19144 JSONSerializer<other_binary_t>::to_json(*
this, val.template get_ref<const other_binary_t&>());
19146 case value_t::null:
19149 case value_t::discarded:
19150 m_type = value_t::discarded;
19153 JSON_ASSERT(
false);
19156 assert_invariant();
19234 bool type_deduction =
true,
19235 value_t manual_type = value_t::array)
19239 bool is_an_object = std::all_of(init.begin(), init.end(),
19240 [](
const detail::json_ref<basic_json>& element_ref)
19242 return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
19246 if (!type_deduction)
19249 if (manual_type == value_t::array)
19251 is_an_object =
false;
19255 if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
19257 JSON_THROW(type_error::create(301,
"cannot create object from initializer list",
basic_json()));
19264 m_type = value_t::object;
19267 for (
auto& element_ref : init)
19269 auto element = element_ref.moved_or_copied();
19271 std::move(*((*element.m_value.array)[0].m_value.string)),
19272 std::move((*element.m_value.array)[1]));
19278 m_type = value_t::array;
19279 m_value.array = create<array_t>(init.begin(), init.end());
19283 assert_invariant();
19317 res.m_type = value_t::binary;
19318 res.m_value = init;
19354 res.m_type = value_t::binary;
19355 res.m_value =
binary_t(init, subtype);
19364 res.m_type = value_t::binary;
19365 res.m_value = std::move(init);
19374 res.m_type = value_t::binary;
19375 res.m_value =
binary_t(std::move(init), subtype);
19419 return basic_json(init,
false, value_t::array);
19463 return basic_json(init,
false, value_t::object);
19489 : m_type(value_t::array)
19491 m_value.array = create<array_t>(cnt, val);
19493 assert_invariant();
19551 template <
class InputIT,
typename std::enable_if <
19552 std::is_same<InputIT, typename basic_json_t::iterator>::value ||
19553 std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
int >
::type = 0 >
19556 JSON_ASSERT(first.m_object !=
nullptr);
19557 JSON_ASSERT(last.m_object !=
nullptr);
19560 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
19562 JSON_THROW(invalid_iterator::create(201,
"iterators are not compatible",
basic_json()));
19566 m_type = first.m_object->m_type;
19571 case value_t::boolean:
19572 case value_t::number_float:
19573 case value_t::number_integer:
19574 case value_t::number_unsigned:
19575 case value_t::string:
19577 if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
19578 || !last.m_it.primitive_iterator.is_end()))
19580 JSON_THROW(invalid_iterator::create(204,
"iterators out of range", *first.m_object));
19585 case value_t::null:
19586 case value_t::object:
19587 case value_t::array:
19588 case value_t::binary:
19589 case value_t::discarded:
19596 case value_t::number_integer:
19598 m_value.number_integer = first.m_object->m_value.number_integer;
19602 case value_t::number_unsigned:
19604 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
19608 case value_t::number_float:
19610 m_value.number_float = first.m_object->m_value.number_float;
19614 case value_t::boolean:
19616 m_value.boolean = first.m_object->m_value.boolean;
19620 case value_t::string:
19622 m_value = *first.m_object->m_value.string;
19626 case value_t::object:
19628 m_value.object = create<object_t>(first.m_it.object_iterator,
19629 last.m_it.object_iterator);
19633 case value_t::array:
19635 m_value.array = create<array_t>(first.m_it.array_iterator,
19636 last.m_it.array_iterator);
19640 case value_t::binary:
19642 m_value = *first.m_object->m_value.binary;
19646 case value_t::null:
19647 case value_t::discarded:
19649 JSON_THROW(invalid_iterator::create(206,
"cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
19653 assert_invariant();
19661 template<
typename JsonRef,
19662 detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
19663 std::is_same<typename JsonRef::value_type, basic_json>>
::value,
int> = 0 >
19692 : m_type(other.m_type)
19695 other.assert_invariant();
19699 case value_t::object:
19705 case value_t::array:
19711 case value_t::string:
19717 case value_t::boolean:
19723 case value_t::number_integer:
19729 case value_t::number_unsigned:
19735 case value_t::number_float:
19741 case value_t::binary:
19747 case value_t::null:
19748 case value_t::discarded:
19754 assert_invariant();
19784 : m_type(std::move(other.m_type)),
19785 m_value(std::move(other.m_value))
19788 other.assert_invariant(
false);
19791 other.m_type = value_t::null;
19792 other.m_value = {};
19795 assert_invariant();
19822 std::is_nothrow_move_constructible<value_t>::value&&
19823 std::is_nothrow_move_assignable<value_t>::value&&
19824 std::is_nothrow_move_constructible<json_value>::value&&
19825 std::is_nothrow_move_assignable<json_value>::value
19829 other.assert_invariant();
19832 swap(m_type, other.m_type);
19836 assert_invariant();
19857 assert_invariant(
false);
19920 const char indent_char =
' ',
19921 const bool ensure_ascii =
false,
19922 const error_handler_t error_handler = error_handler_t::strict)
const
19925 serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
19929 s.dump(*
this,
true, ensure_ascii,
static_cast<unsigned int>(indent));
19933 s.dump(*
this,
false, ensure_ascii, 0);
19972 constexpr value_t
type() const noexcept
20054 return m_type == value_t::null;
20076 return m_type == value_t::boolean;
20135 return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
20163 return m_type == value_t::number_unsigned;
20191 return m_type == value_t::number_float;
20213 return m_type == value_t::object;
20235 return m_type == value_t::array;
20257 return m_type == value_t::string;
20279 return m_type == value_t::binary;
20306 return m_type == value_t::discarded;
20350 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(
type_name()), *
this));
20372 constexpr const array_t* get_impl_ptr(
const array_t* )
const noexcept
20460 template<
typename ReferenceType,
typename ThisType>
20461 static ReferenceType get_ref_impl(ThisType& obj)
20464 auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
20466 if (JSON_HEDLEY_LIKELY(ptr !=
nullptr))
20471 JSON_THROW(type_error::create(303,
"incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
20505 template<
typename PointerType,
typename std::enable_if<
20506 std::is_pointer<PointerType>::value,
int>
::type = 0>
20507 auto get_ptr() noexcept -> decltype(
std::declval<basic_json_t&>().get_impl_ptr(
std::declval<PointerType>()))
20510 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20517 template <
typename PointerType,
typename std::enable_if <
20518 std::is_pointer<PointerType>::value&&
20519 std::is_const<typename std::remove_pointer<PointerType>::type>
::value,
int >
::type = 0 >
20520 constexpr auto get_ptr() const noexcept -> decltype(
std::declval<const basic_json_t&>().get_impl_ptr(
std::declval<PointerType>()))
20523 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20565 template <
typename ValueType,
20566 detail::enable_if_t <
20567 detail::is_default_constructible<ValueType>::value&&
20568 detail::has_from_json<basic_json_t, ValueType>::value,
20570 ValueType get_impl(detail::priority_tag<0> )
const noexcept(
noexcept(
20571 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20573 auto ret = ValueType();
20574 JSONSerializer<ValueType>::from_json(*
this, ret);
20608 template <
typename ValueType,
20609 detail::enable_if_t <
20610 detail::has_non_default_from_json<basic_json_t, ValueType>::value,
20612 ValueType get_impl(detail::priority_tag<1> )
const noexcept(
noexcept(
20613 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20615 return JSONSerializer<ValueType>::from_json(*
this);
20633 template <
typename BasicJsonType,
20634 detail::enable_if_t <
20635 detail::is_basic_json<BasicJsonType>::value,
20637 BasicJsonType get_impl(detail::priority_tag<2> )
const
20656 template<
typename BasicJsonType,
20657 detail::enable_if_t<
20658 std::is_same<BasicJsonType, basic_json_t>::value,
20660 basic_json get_impl(detail::priority_tag<3> )
const
20669 template<
typename PointerType,
20670 detail::enable_if_t<
20671 std::is_pointer<PointerType>::value,
20673 constexpr auto get_impl(detail::priority_tag<4> )
const noexcept
20674 ->
decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
20677 return get_ptr<PointerType>();
20704 template <
typename ValueTypeCV,
typename ValueType = detail::uncvref_t<ValueTypeCV>>
20705#if defined(JSON_HAS_CPP_14)
20709 noexcept(
std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
20710 ->
decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
20715 static_assert(!std::is_reference<ValueTypeCV>::value,
20716 "get() cannot be used with reference types, you might want to use get_ref()");
20717 return get_impl<ValueType>(detail::priority_tag<4> {});
20747 template<
typename PointerType,
typename std::enable_if<
20748 std::is_pointer<PointerType>::value,
int>
::type = 0>
20749 auto get() noexcept -> decltype(
std::declval<basic_json_t&>().template
get_ptr<PointerType>())
20752 return get_ptr<PointerType>();
20788 template <
typename ValueType,
20789 detail::enable_if_t <
20790 !detail::is_basic_json<ValueType>::value&&
20791 detail::has_from_json<basic_json_t, ValueType>::value,
20793 ValueType &
get_to(ValueType& v)
const noexcept(
noexcept(
20794 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
20796 JSONSerializer<ValueType>::from_json(*
this, v);
20802 template<
typename ValueType,
20803 detail::enable_if_t <
20804 detail::is_basic_json<ValueType>::value,
20813 typename T, std::size_t N,
20814 typename Array = T (&)[N],
20815 detail::enable_if_t <
20816 detail::has_from_json<basic_json_t, Array>::value,
int > = 0 >
20818 noexcept(
noexcept(JSONSerializer<Array>::from_json(
20819 std::declval<const basic_json_t&>(), v)))
20821 JSONSerializer<Array>::from_json(*
this, v);
20851 template<
typename ReferenceType,
typename std::enable_if<
20852 std::is_reference<ReferenceType>::value,
int>
::type = 0>
20856 return get_ref_impl<ReferenceType>(*
this);
20863 template <
typename ReferenceType,
typename std::enable_if <
20864 std::is_reference<ReferenceType>::value&&
20865 std::is_const<typename std::remove_reference<ReferenceType>::type>
::value,
int >
::type = 0 >
20869 return get_ref_impl<ReferenceType>(*
this);
20901 template <
typename ValueType,
typename std::enable_if <
20902 detail::conjunction <
20903 detail::negation<std::is_pointer<ValueType>>,
20904 detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
20905 detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
20906 detail::negation<detail::is_basic_json<ValueType>>,
20907 detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
20909#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
20910 detail::negation<std::is_same<ValueType, std::string_view>>,
20912 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
20914 JSON_EXPLICIT
operator ValueType()
const
20917 return get<ValueType>();
20933 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name()), *
this));
20936 return *get_ptr<binary_t*>();
20944 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name()), *
this));
20947 return *get_ptr<const binary_t*>();
20990 if (JSON_HEDLEY_LIKELY(
is_array()))
20994 return set_parent(
m_value.array->at(idx));
20996 JSON_CATCH (std::out_of_range&)
20999 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
21004 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
21037 if (JSON_HEDLEY_LIKELY(
is_array()))
21041 return m_value.array->at(idx);
21043 JSON_CATCH (std::out_of_range&)
21046 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
21051 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
21085 reference at(
const typename object_t::key_type& key)
21092 return set_parent(
m_value.object->at(key));
21094 JSON_CATCH (std::out_of_range&)
21097 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found", *
this));
21102 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
21143 return m_value.object->at(key);
21145 JSON_CATCH (std::out_of_range&)
21148 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found", *
this));
21153 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
21187 m_type = value_t::array;
21188 m_value.array = create<array_t>();
21189 assert_invariant();
21193 if (JSON_HEDLEY_LIKELY(
is_array()))
21196 if (idx >=
m_value.array->size())
21198#if JSON_DIAGNOSTICS
21200 const auto old_size =
m_value.array->size();
21201 const auto old_capacity =
m_value.array->capacity();
21203 m_value.array->resize(idx + 1);
21205#if JSON_DIAGNOSTICS
21206 if (JSON_HEDLEY_UNLIKELY(
m_value.array->capacity() != old_capacity))
21214 set_parents(
begin() +
static_cast<typename iterator::difference_type
>(old_size),
static_cast<typename iterator::difference_type
>(idx + 1 - old_size));
21217 assert_invariant();
21220 return m_value.array->operator[](idx);
21223 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name()), *
this));
21248 if (JSON_HEDLEY_LIKELY(
is_array()))
21250 return m_value.array->operator[](idx);
21253 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name()), *
this));
21288 m_type = value_t::object;
21289 m_value.object = create<object_t>();
21290 assert_invariant();
21296 return set_parent(
m_value.object->operator[](key));
21299 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21337 JSON_ASSERT(
m_value.object->find(key) !=
m_value.object->end());
21338 return m_value.object->find(key)->second;
21341 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21371 template<
typename T>
21372 JSON_HEDLEY_NON_NULL(2)
21378 m_type = value_t::object;
21380 assert_invariant();
21386 return set_parent(
m_value.object->operator[](key));
21389 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21422 template<
typename T>
21423 JSON_HEDLEY_NON_NULL(2)
21429 JSON_ASSERT(
m_value.object->find(key) !=
m_value.object->end());
21430 return m_value.object->find(key)->second;
21433 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
21487 template <
class ValueType,
typename std::enable_if <
21488 detail::is_getable<basic_json_t, ValueType>::value
21489 && !std::is_same<value_t, ValueType>::value,
int >
::type = 0 >
21490 ValueType
value(
const typename object_t::key_type& key,
const ValueType& default_value)
const
21496 const auto it =
find(key);
21499 return it->template get<ValueType>();
21502 return default_value;
21505 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name()), *
this));
21512 string_t value(
const typename object_t::key_type& key,
const char* default_value)
const
21560 template<
class ValueType,
typename std::enable_if<
21561 detail::is_getable<basic_json_t, ValueType>::value,
int>
::type = 0>
21570 return ptr.get_checked(
this).template get<ValueType>();
21574 return default_value;
21578 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name()), *
this));
21585 JSON_HEDLEY_NON_NULL(3)
21723 template <
class IteratorType,
typename std::enable_if <
21724 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21725 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21727 IteratorType
erase(IteratorType pos)
21730 if (JSON_HEDLEY_UNLIKELY(
this != pos.m_object))
21732 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
21735 IteratorType result =
end();
21739 case value_t::boolean:
21740 case value_t::number_float:
21741 case value_t::number_integer:
21742 case value_t::number_unsigned:
21743 case value_t::string:
21744 case value_t::binary:
21746 if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
21748 JSON_THROW(invalid_iterator::create(205,
"iterator out of range", *
this));
21753 AllocatorType<string_t> alloc;
21754 std::allocator_traits<
decltype(alloc)>::destroy(alloc,
m_value.string);
21755 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21760 AllocatorType<binary_t> alloc;
21761 std::allocator_traits<
decltype(alloc)>::destroy(alloc,
m_value.binary);
21762 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21766 m_type = value_t::null;
21767 assert_invariant();
21771 case value_t::object:
21773 result.m_it.object_iterator =
m_value.object->erase(pos.m_it.object_iterator);
21777 case value_t::array:
21779 result.m_it.array_iterator =
m_value.array->erase(pos.m_it.array_iterator);
21783 case value_t::null:
21784 case value_t::discarded:
21786 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21838 template <
class IteratorType,
typename std::enable_if <
21839 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21840 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21842 IteratorType
erase(IteratorType first, IteratorType last)
21845 if (JSON_HEDLEY_UNLIKELY(
this != first.m_object ||
this != last.m_object))
21847 JSON_THROW(invalid_iterator::create(203,
"iterators do not fit current value", *
this));
21850 IteratorType result =
end();
21854 case value_t::boolean:
21855 case value_t::number_float:
21856 case value_t::number_integer:
21857 case value_t::number_unsigned:
21858 case value_t::string:
21859 case value_t::binary:
21861 if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
21862 || !last.m_it.primitive_iterator.is_end()))
21864 JSON_THROW(invalid_iterator::create(204,
"iterators out of range", *
this));
21869 AllocatorType<string_t> alloc;
21870 std::allocator_traits<
decltype(alloc)>::destroy(alloc,
m_value.string);
21871 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21876 AllocatorType<binary_t> alloc;
21877 std::allocator_traits<
decltype(alloc)>::destroy(alloc,
m_value.binary);
21878 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21882 m_type = value_t::null;
21883 assert_invariant();
21887 case value_t::object:
21889 result.m_it.object_iterator =
m_value.object->erase(first.m_it.object_iterator,
21890 last.m_it.object_iterator);
21894 case value_t::array:
21896 result.m_it.array_iterator =
m_value.array->erase(first.m_it.array_iterator,
21897 last.m_it.array_iterator);
21901 case value_t::null:
21902 case value_t::discarded:
21904 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21944 return m_value.object->erase(key);
21947 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21977 if (JSON_HEDLEY_LIKELY(
is_array()))
21979 if (JSON_HEDLEY_UNLIKELY(idx >=
size()))
21981 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
21988 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
22026 template<
typename KeyT>
22029 auto result =
end();
22033 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
22043 template<
typename KeyT>
22046 auto result =
cend();
22050 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
22077 template<
typename KeyT>
22109 template <
typename KeyT,
typename std::enable_if <
22144 return ptr.contains(
this);
22184 result.set_begin();
22224 result.set_begin();
22488 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
22491 return ref.items();
22497 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
22500 return ref.items();
22571 iteration_proxy<iterator>
items() noexcept
22573 return iteration_proxy<iterator>(*
this);
22579 iteration_proxy<const_iterator>
items() const noexcept
22581 return iteration_proxy<const_iterator>(*
this);
22636 bool empty() const noexcept
22640 case value_t::null:
22646 case value_t::array:
22649 return m_value.array->empty();
22652 case value_t::object:
22655 return m_value.object->empty();
22658 case value_t::string:
22659 case value_t::boolean:
22660 case value_t::number_integer:
22661 case value_t::number_unsigned:
22662 case value_t::number_float:
22663 case value_t::binary:
22664 case value_t::discarded:
22720 case value_t::null:
22726 case value_t::array:
22729 return m_value.array->size();
22732 case value_t::object:
22735 return m_value.object->size();
22738 case value_t::string:
22739 case value_t::boolean:
22740 case value_t::number_integer:
22741 case value_t::number_unsigned:
22742 case value_t::number_float:
22743 case value_t::binary:
22744 case value_t::discarded:
22798 case value_t::array:
22801 return m_value.array->max_size();
22804 case value_t::object:
22807 return m_value.object->max_size();
22810 case value_t::null:
22811 case value_t::string:
22812 case value_t::boolean:
22813 case value_t::number_integer:
22814 case value_t::number_unsigned:
22815 case value_t::number_float:
22816 case value_t::binary:
22817 case value_t::discarded:
22873 void clear() noexcept
22877 case value_t::number_integer:
22883 case value_t::number_unsigned:
22889 case value_t::number_float:
22895 case value_t::boolean:
22901 case value_t::string:
22907 case value_t::binary:
22913 case value_t::array:
22919 case value_t::object:
22925 case value_t::null:
22926 case value_t::discarded:
22957 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22963 m_type = value_t::array;
22965 assert_invariant();
22969 const auto old_capacity =
m_value.array->capacity();
22970 m_value.array->push_back(std::move(val));
22971 set_parent(
m_value.array->back(), old_capacity);
22994 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
23000 m_type = value_t::array;
23002 assert_invariant();
23006 const auto old_capacity =
m_value.array->capacity();
23007 m_value.array->push_back(val);
23008 set_parent(
m_value.array->back(), old_capacity);
23041 void push_back(
const typename object_t::value_type& val)
23046 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
23052 m_type = value_t::object;
23054 assert_invariant();
23058 auto res =
m_value.object->insert(val);
23059 set_parent(res.first->second);
23099 if (
is_object() && init.size() == 2 && (*init.begin())->is_string())
23101 basic_json&& key = init.begin()->moved_or_copied();
23102 push_back(
typename object_t::value_type(
23103 std::move(key.get_ref<
string_t&>()), (init.begin() + 1)->moved_or_copied()));
23144 template<
class... Args>
23150 JSON_THROW(type_error::create(311,
"cannot use emplace_back() with " + std::string(
type_name()), *
this));
23156 m_type = value_t::array;
23158 assert_invariant();
23162 const auto old_capacity =
m_value.array->capacity();
23163 m_value.array->emplace_back(std::forward<Args>(args)...);
23164 return set_parent(
m_value.array->back(), old_capacity);
23194 template<
class... Args>
23195 std::pair<iterator, bool>
emplace(Args&& ... args)
23200 JSON_THROW(type_error::create(311,
"cannot use emplace() with " + std::string(
type_name()), *
this));
23206 m_type = value_t::object;
23208 assert_invariant();
23212 auto res =
m_value.object->emplace(std::forward<Args>(args)...);
23213 set_parent(res.first->second);
23217 it.m_it.object_iterator = res.first;
23220 return {it, res.second};
23226 template<
typename... Args>
23230 JSON_ASSERT(
m_value.array !=
nullptr);
23232 auto insert_pos = std::distance(
m_value.array->begin(), pos.m_it.array_iterator);
23233 m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
23234 result.m_it.array_iterator =
m_value.array->begin() + insert_pos;
23269 if (JSON_HEDLEY_LIKELY(
is_array()))
23272 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23274 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23281 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23290 return insert(pos, val);
23320 if (JSON_HEDLEY_LIKELY(
is_array()))
23323 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23325 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23332 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23368 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
23370 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23374 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23376 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23380 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23382 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23385 if (JSON_HEDLEY_UNLIKELY(first.m_object ==
this))
23387 JSON_THROW(invalid_iterator::create(211,
"passed iterators may not belong to container", *
this));
23391 return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
23421 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
23423 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23427 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
23429 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
23462 if (JSON_HEDLEY_UNLIKELY(!
is_object()))
23464 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
23468 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23470 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23474 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
23476 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects", *
this));
23479 m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
23506 m_type = value_t::object;
23507 m_value.object = create<object_t>();
23508 assert_invariant();
23513 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name()), *
this));
23515 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
23517 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(j.type_name()), *
this));
23520 for (
auto it = j.cbegin(); it != j.cend(); ++it)
23522 m_value.object->operator[](it.key()) = it.value();
23523#if JSON_DIAGNOSTICS
23524 m_value.object->operator[](it.key()).m_parent =
this;
23560 m_type = value_t::object;
23561 m_value.object = create<object_t>();
23562 assert_invariant();
23567 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name()), *
this));
23571 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23573 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23577 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
23578 || !last.m_object->is_object()))
23580 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects", *
this));
23583 for (
auto it = first; it != last; ++it)
23585 m_value.object->operator[](it.key()) = it.value();
23586#if JSON_DIAGNOSTICS
23587 m_value.object->operator[](it.key()).m_parent =
this;
23610 std::is_nothrow_move_constructible<value_t>::value&&
23611 std::is_nothrow_move_assignable<value_t>::value&&
23612 std::is_nothrow_move_constructible<json_value>::value&&
23613 std::is_nothrow_move_assignable<json_value>::value
23616 std::swap(m_type, other.m_type);
23617 std::swap(
m_value, other.m_value);
23620 other.set_parents();
23621 assert_invariant();
23643 std::is_nothrow_move_constructible<value_t>::value&&
23644 std::is_nothrow_move_assignable<value_t>::value&&
23645 std::is_nothrow_move_constructible<json_value>::value&&
23646 std::is_nothrow_move_assignable<json_value>::value
23675 if (JSON_HEDLEY_LIKELY(
is_array()))
23677 std::swap(*(
m_value.array), other);
23681 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23710 std::swap(*(
m_value.object), other);
23714 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23743 std::swap(*(
m_value.string), other);
23747 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23776 std::swap(*(
m_value.binary), other);
23780 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23790 std::swap(*(
m_value.binary), other);
23794 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23866#pragma GCC diagnostic push
23867#pragma GCC diagnostic ignored "-Wfloat-equal"
23869 const auto lhs_type = lhs.type();
23870 const auto rhs_type = rhs.type();
23872 if (lhs_type == rhs_type)
23876 case value_t::array:
23877 return *lhs.m_value.array == *rhs.m_value.array;
23879 case value_t::object:
23880 return *lhs.m_value.object == *rhs.m_value.object;
23882 case value_t::null:
23885 case value_t::string:
23886 return *lhs.m_value.string == *rhs.m_value.string;
23888 case value_t::boolean:
23889 return lhs.m_value.boolean == rhs.m_value.boolean;
23891 case value_t::number_integer:
23892 return lhs.m_value.number_integer == rhs.m_value.number_integer;
23894 case value_t::number_unsigned:
23895 return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
23897 case value_t::number_float:
23898 return lhs.m_value.number_float == rhs.m_value.number_float;
23900 case value_t::binary:
23901 return *lhs.m_value.binary == *rhs.m_value.binary;
23903 case value_t::discarded:
23908 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23910 return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
23912 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23914 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_integer);
23916 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23918 return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
23920 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23922 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23924 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23926 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
23928 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23930 return lhs.m_value.number_integer ==
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23935#pragma GCC diagnostic pop
23943 template<
typename ScalarType,
typename std::enable_if<
23944 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23954 template<
typename ScalarType,
typename std::enable_if<
23955 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23981 return !(lhs == rhs);
23988 template<
typename ScalarType,
typename std::enable_if<
23989 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23999 template<
typename ScalarType,
typename std::enable_if<
24000 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24034 const auto lhs_type = lhs.type();
24035 const auto rhs_type = rhs.type();
24037 if (lhs_type == rhs_type)
24041 case value_t::array:
24044 return (*lhs.m_value.array) < (*rhs.m_value.array);
24046 case value_t::object:
24047 return (*lhs.m_value.object) < (*rhs.m_value.object);
24049 case value_t::null:
24052 case value_t::string:
24053 return (*lhs.m_value.string) < (*rhs.m_value.string);
24055 case value_t::boolean:
24056 return (lhs.m_value.boolean) < (rhs.m_value.boolean);
24058 case value_t::number_integer:
24059 return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
24061 case value_t::number_unsigned:
24062 return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
24064 case value_t::number_float:
24065 return (lhs.m_value.number_float) < (rhs.m_value.number_float);
24067 case value_t::binary:
24068 return (*lhs.m_value.binary) < (*rhs.m_value.binary);
24070 case value_t::discarded:
24075 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
24077 return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
24079 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
24081 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_integer);
24083 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
24085 return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
24087 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
24089 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_unsigned);
24091 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
24093 return lhs.m_value.number_integer <
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
24095 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
24097 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
24110 template<
typename ScalarType,
typename std::enable_if<
24111 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24121 template<
typename ScalarType,
typename std::enable_if<
24122 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24149 return !(rhs < lhs);
24156 template<
typename ScalarType,
typename std::enable_if<
24157 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24167 template<
typename ScalarType,
typename std::enable_if<
24168 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24195 return !(lhs <= rhs);
24202 template<
typename ScalarType,
typename std::enable_if<
24203 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24213 template<
typename ScalarType,
typename std::enable_if<
24214 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24241 return !(lhs < rhs);
24248 template<
typename ScalarType,
typename std::enable_if<
24249 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24259 template<
typename ScalarType,
typename std::enable_if<
24260 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24309 const bool pretty_print = o.width() > 0;
24310 const auto indentation = pretty_print ? o.width() : 0;
24316 serializer s(detail::output_adapter<char>(o), o.fill());
24317 s.dump(j, pretty_print,
false,
static_cast<unsigned int>(indentation));
24329 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator<<(std::ostream&,
const basic_json&))
24396 template<
typename InputType>
24400 const bool allow_exceptions =
true,
24401 const bool ignore_comments =
false)
24404 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(
true, result);
24434 template<
typename IteratorType>
24439 const bool allow_exceptions =
true,
24440 const bool ignore_comments =
false)
24443 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(
true, result);
24448 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
parse(ptr, ptr + len))
24451 const bool allow_exceptions =
true,
24452 const bool ignore_comments =
false)
24455 parser(i.get(), cb, allow_exceptions, ignore_comments).parse(
true, result);
24489 template<
typename InputType>
24490 static bool accept(InputType&& i,
24491 const bool ignore_comments =
false)
24493 return parser(detail::input_adapter(std::forward<InputType>(i)),
nullptr,
false, ignore_comments).accept(
true);
24496 template<
typename IteratorType>
24497 static bool accept(IteratorType first, IteratorType last,
24498 const bool ignore_comments =
false)
24500 return parser(detail::input_adapter(std::move(first), std::move(last)),
nullptr,
false, ignore_comments).accept(
true);
24504 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
accept(ptr, ptr + len))
24505 static bool accept(detail::span_input_adapter&& i,
24506 const bool ignore_comments =
false)
24508 return parser(i.get(),
nullptr,
false, ignore_comments).accept(
true);
24551 template <
typename InputType,
typename SAX>
24552 JSON_HEDLEY_NON_NULL(2)
24553 static
bool sax_parse(InputType&& i, SAX* sax,
24555 const
bool strict = true,
24556 const
bool ignore_comments = false)
24558 auto ia = detail::input_adapter(std::forward<InputType>(i));
24559 return format == input_format_t::json
24560 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24561 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24564 template<
class IteratorType,
class SAX>
24565 JSON_HEDLEY_NON_NULL(3)
24566 static
bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
24567 input_format_t format = input_format_t::
json,
24568 const
bool strict = true,
24569 const
bool ignore_comments = false)
24571 auto ia = detail::input_adapter(std::move(first), std::move(last));
24572 return format == input_format_t::json
24573 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24574 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24577 template <
typename SAX>
24578 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
sax_parse(ptr, ptr + len, ...))
24579 JSON_HEDLEY_NON_NULL(2)
24580 static
bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
24581 input_format_t format = input_format_t::
json,
24582 const
bool strict = true,
24583 const
bool ignore_comments = false)
24586 return format == input_format_t::json
24588 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24590 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24601 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator>>(std::istream&,
basic_json&))
24634 parser(detail::input_adapter(i)).parse(
false, j);
24681 case value_t::null:
24683 case value_t::object:
24685 case value_t::array:
24687 case value_t::string:
24689 case value_t::boolean:
24691 case value_t::binary:
24693 case value_t::discarded:
24694 return "discarded";
24695 case value_t::number_integer:
24696 case value_t::number_unsigned:
24697 case value_t::number_float:
24705 JSON_PRIVATE_UNLESS_TESTED:
24711 value_t m_type = value_t::null;
24716#if JSON_DIAGNOSTICS
24829 std::vector<std::uint8_t> result;
24834 static void to_cbor(
const basic_json& j, detail::output_adapter<std::uint8_t> o)
24836 binary_writer<std::uint8_t>(o).write_cbor(j);
24841 binary_writer<char>(o).write_cbor(j);
24924 std::vector<std::uint8_t> result;
24931 binary_writer<std::uint8_t>(o).write_msgpack(j);
24936 binary_writer<char>(o).write_msgpack(j);
25026 const bool use_size =
false,
25027 const bool use_type =
false)
25029 std::vector<std::uint8_t> result;
25030 to_ubjson(j, result, use_size, use_type);
25035 const bool use_size =
false,
const bool use_type =
false)
25037 binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
25041 const bool use_size =
false,
const bool use_type =
false)
25043 binary_writer<char>(o).write_ubjson(j, use_size, use_type);
25105 std::vector<std::uint8_t> result;
25118 static void to_bson(
const basic_json& j, detail::output_adapter<std::uint8_t> o)
25120 binary_writer<std::uint8_t>(o).write_bson(j);
25128 binary_writer<char>(o).write_bson(j);
25234 template<
typename InputType>
25237 const bool strict =
true,
25238 const bool allow_exceptions =
true,
25242 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25243 auto ia = detail::input_adapter(std::forward<InputType>(i));
25244 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
25245 return res ? result :
basic_json(value_t::discarded);
25251 template<
typename IteratorType>
25254 const bool strict =
true,
25255 const bool allow_exceptions =
true,
25259 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25260 auto ia = detail::input_adapter(std::move(first), std::move(last));
25261 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
25262 return res ? result :
basic_json(value_t::discarded);
25265 template<
typename T>
25267 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_cbor(ptr, ptr + len))
25269 const bool strict =
true,
25270 const bool allow_exceptions =
true,
25273 return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
25280 const bool strict =
true,
25281 const bool allow_exceptions =
true,
25282 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
25285 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25288 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
25378 template<
typename InputType>
25381 const bool strict =
true,
25382 const bool allow_exceptions =
true)
25385 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25386 auto ia = detail::input_adapter(std::forward<InputType>(i));
25387 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
25388 return res ? result :
basic_json(value_t::discarded);
25394 template<
typename IteratorType>
25397 const bool strict =
true,
25398 const bool allow_exceptions =
true)
25401 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25402 auto ia = detail::input_adapter(std::move(first), std::move(last));
25403 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
25404 return res ? result :
basic_json(value_t::discarded);
25408 template<
typename T>
25410 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
25412 const bool strict =
true,
25413 const bool allow_exceptions =
true)
25415 return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
25419 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
25421 const bool strict =
true,
25422 const bool allow_exceptions =
true)
25425 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25428 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
25429 return res ? result :
basic_json(value_t::discarded);
25495 template<
typename InputType>
25498 const bool strict =
true,
25499 const bool allow_exceptions =
true)
25502 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25503 auto ia = detail::input_adapter(std::forward<InputType>(i));
25504 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25505 return res ? result :
basic_json(value_t::discarded);
25511 template<
typename IteratorType>
25514 const bool strict =
true,
25515 const bool allow_exceptions =
true)
25518 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25519 auto ia = detail::input_adapter(std::move(first), std::move(last));
25520 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25521 return res ? result :
basic_json(value_t::discarded);
25524 template<
typename T>
25526 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
25528 const bool strict =
true,
25529 const bool allow_exceptions =
true)
25531 return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
25535 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
25537 const bool strict =
true,
25538 const bool allow_exceptions =
true)
25541 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25544 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25545 return res ? result :
basic_json(value_t::discarded);
25609 template<
typename InputType>
25612 const bool strict =
true,
25613 const bool allow_exceptions =
true)
25616 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25617 auto ia = detail::input_adapter(std::forward<InputType>(i));
25618 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25619 return res ? result :
basic_json(value_t::discarded);
25625 template<
typename IteratorType>
25628 const bool strict =
true,
25629 const bool allow_exceptions =
true)
25632 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25633 auto ia = detail::input_adapter(std::move(first), std::move(last));
25634 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25635 return res ? result :
basic_json(value_t::discarded);
25638 template<
typename T>
25640 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
25642 const bool strict =
true,
25643 const bool allow_exceptions =
true)
25645 return from_bson(ptr, ptr + len, strict, allow_exceptions);
25649 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
25651 const bool strict =
true,
25652 const bool allow_exceptions =
true)
25655 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25658 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25659 return res ? result :
basic_json(value_t::discarded);
25705 return ptr.get_unchecked(
this);
25733 return ptr.get_unchecked(
this);
25776 return ptr.get_checked(
this);
25819 return ptr.get_checked(
this);
25847 json_pointer::flatten(
"", *
this, result);
25883 return json_pointer::unflatten(*
this);
25948 enum class patch_operations {add, remove, replace, move, copy, test, invalid};
25950 const auto get_op = [](
const std::string & op)
25954 return patch_operations::add;
25956 if (op ==
"remove")
25958 return patch_operations::remove;
25960 if (op ==
"replace")
25962 return patch_operations::replace;
25966 return patch_operations::move;
25970 return patch_operations::copy;
25974 return patch_operations::test;
25977 return patch_operations::invalid;
25992 if (top_pointer != ptr)
25994 result.
at(top_pointer);
25998 const auto last_path = ptr.
back();
26002 switch (parent.m_type)
26004 case value_t::null:
26005 case value_t::object:
26008 parent[last_path] = val;
26012 case value_t::array:
26014 if (last_path ==
"-")
26021 const auto idx = json_pointer::array_index(last_path);
26022 if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
26025 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", parent));
26029 parent.insert(parent.begin() +
static_cast<difference_type>(idx), val);
26035 case value_t::string:
26036 case value_t::boolean:
26037 case value_t::number_integer:
26038 case value_t::number_unsigned:
26039 case value_t::number_float:
26040 case value_t::binary:
26041 case value_t::discarded:
26043 JSON_ASSERT(
false);
26048 const auto operation_remove = [
this, &result](
json_pointer & ptr)
26051 const auto last_path = ptr.back();
26056 if (parent.is_object())
26059 auto it = parent.
find(last_path);
26060 if (JSON_HEDLEY_LIKELY(it != parent.end()))
26066 JSON_THROW(out_of_range::create(403,
"key '" + last_path +
"' not found", *
this));
26069 else if (parent.is_array())
26072 parent.erase(json_pointer::array_index(last_path));
26077 if (JSON_HEDLEY_UNLIKELY(!json_patch.
is_array()))
26079 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects", json_patch));
26083 for (
const auto& val : json_patch)
26086 const auto get_value = [&val](
const std::string & op,
26087 const std::string & member,
26091 auto it = val.m_value.object->find(member);
26094 const auto error_msg = (op ==
"op") ?
"operation" :
"operation '" + op +
"'";
26097 if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
26100 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have member '" + member +
"'", val));
26104 if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
26107 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have string member '" + member +
"'", val));
26115 if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
26117 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects", val));
26121 const auto op = get_value(
"op",
"op",
true).template get<std::string>();
26122 const auto path = get_value(op,
"path",
true).template get<std::string>();
26125 switch (get_op(op))
26127 case patch_operations::add:
26129 operation_add(ptr, get_value(
"add",
"value",
false));
26133 case patch_operations::remove:
26135 operation_remove(ptr);
26139 case patch_operations::replace:
26142 result.
at(ptr) = get_value(
"replace",
"value",
false);
26146 case patch_operations::move:
26148 const auto from_path = get_value(
"move",
"from",
true).template get<std::string>();
26158 operation_remove(from_ptr);
26159 operation_add(ptr, v);
26163 case patch_operations::copy:
26165 const auto from_path = get_value(
"copy",
"from",
true).template get<std::string>();
26174 operation_add(ptr, v);
26178 case patch_operations::test:
26180 bool success =
false;
26185 success = (result.
at(ptr) == get_value(
"test",
"value",
false));
26193 if (JSON_HEDLEY_UNLIKELY(!success))
26195 JSON_THROW(other_error::create(501,
"unsuccessful: " + val.dump(), val));
26201 case patch_operations::invalid:
26206 JSON_THROW(parse_error::create(105, 0,
"operation value '" + op +
"' is invalid", val));
26249 const std::string& path =
"")
26255 if (source == target)
26260 if (source.type() != target.type())
26265 {
"op",
"replace"}, {
"path", path}, {
"value", target}
26270 switch (source.type())
26272 case value_t::array:
26276 while (i < source.size() && i < target.size())
26279 auto temp_diff =
diff(source[i], target[i], path +
"/" + std::to_string(i));
26280 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
26289 while (i < source.size())
26296 {
"path", path +
"/" + std::to_string(i)}
26302 while (i < target.size())
26307 {
"path", path +
"/-"},
26308 {
"value", target[i]}
26316 case value_t::object:
26319 for (
auto it = source.cbegin(); it != source.cend(); ++it)
26322 const auto path_key = path +
"/" + detail::escape(it.key());
26324 if (target.find(it.key()) != target.end())
26327 auto temp_diff =
diff(it.value(), target[it.key()], path_key);
26328 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
26335 {
"op",
"remove"}, {
"path", path_key}
26341 for (
auto it = target.cbegin(); it != target.cend(); ++it)
26343 if (source.find(it.key()) == source.end())
26346 const auto path_key = path +
"/" + detail::escape(it.key());
26349 {
"op",
"add"}, {
"path", path_key},
26350 {
"value", it.value()}
26358 case value_t::null:
26359 case value_t::string:
26360 case value_t::boolean:
26361 case value_t::number_integer:
26362 case value_t::number_unsigned:
26363 case value_t::number_float:
26364 case value_t::binary:
26365 case value_t::discarded:
26371 {
"op",
"replace"}, {
"path", path}, {
"value", target}
26433 if (apply_patch.is_object())
26439 for (
auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
26441 if (it.value().is_null())
26453 *
this = apply_patch;
26469NLOHMANN_BASIC_JSON_TPL_DECLARATION
26470std::string
to_string(
const NLOHMANN_BASIC_JSON_TPL& j)
26495 return nlohmann::detail::hash(j);
26503struct less<::nlohmann::detail::value_t>
26509 bool operator()(nlohmann::detail::value_t lhs,
26510 nlohmann::detail::value_t rhs)
const noexcept
26512 return nlohmann::detail::operator<(lhs, rhs);
26517#ifndef JSON_HAS_CPP_20
26526 is_nothrow_move_constructible<nlohmann::json>::value&&
26527 is_nothrow_move_assignable<nlohmann::json>::value
26550JSON_HEDLEY_NON_NULL(1)
26551inline
nlohmann::json operator "" _json(const
char* s,
std::
size_t n)
26569JSON_HEDLEY_NON_NULL(1)
26570inline
nlohmann::json::json_pointer operator "" _json_pointer(const
char* s,
std::
size_t n)
26579#if defined(__clang__)
26580 #pragma clang diagnostic pop
26585#undef JSON_INTERNAL_CATCH
26589#undef JSON_PRIVATE_UNLESS_TESTED
26590#undef JSON_HAS_CPP_11
26591#undef JSON_HAS_CPP_14
26592#undef JSON_HAS_CPP_17
26593#undef JSON_HAS_CPP_20
26594#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
26595#undef NLOHMANN_BASIC_JSON_TPL
26596#undef JSON_EXPLICIT
26597#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
26602#undef JSON_HEDLEY_ALWAYS_INLINE
26603#undef JSON_HEDLEY_ARM_VERSION
26604#undef JSON_HEDLEY_ARM_VERSION_CHECK
26605#undef JSON_HEDLEY_ARRAY_PARAM
26606#undef JSON_HEDLEY_ASSUME
26607#undef JSON_HEDLEY_BEGIN_C_DECLS
26608#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
26609#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
26610#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
26611#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
26612#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
26613#undef JSON_HEDLEY_CLANG_HAS_FEATURE
26614#undef JSON_HEDLEY_CLANG_HAS_WARNING
26615#undef JSON_HEDLEY_COMPCERT_VERSION
26616#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
26617#undef JSON_HEDLEY_CONCAT
26618#undef JSON_HEDLEY_CONCAT3
26619#undef JSON_HEDLEY_CONCAT3_EX
26620#undef JSON_HEDLEY_CONCAT_EX
26621#undef JSON_HEDLEY_CONST
26622#undef JSON_HEDLEY_CONSTEXPR
26623#undef JSON_HEDLEY_CONST_CAST
26624#undef JSON_HEDLEY_CPP_CAST
26625#undef JSON_HEDLEY_CRAY_VERSION
26626#undef JSON_HEDLEY_CRAY_VERSION_CHECK
26627#undef JSON_HEDLEY_C_DECL
26628#undef JSON_HEDLEY_DEPRECATED
26629#undef JSON_HEDLEY_DEPRECATED_FOR
26630#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
26631#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
26632#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
26633#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
26634#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
26635#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
26636#undef JSON_HEDLEY_DIAGNOSTIC_POP
26637#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
26638#undef JSON_HEDLEY_DMC_VERSION
26639#undef JSON_HEDLEY_DMC_VERSION_CHECK
26640#undef JSON_HEDLEY_EMPTY_BASES
26641#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
26642#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
26643#undef JSON_HEDLEY_END_C_DECLS
26644#undef JSON_HEDLEY_FLAGS
26645#undef JSON_HEDLEY_FLAGS_CAST
26646#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
26647#undef JSON_HEDLEY_GCC_HAS_BUILTIN
26648#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
26649#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
26650#undef JSON_HEDLEY_GCC_HAS_EXTENSION
26651#undef JSON_HEDLEY_GCC_HAS_FEATURE
26652#undef JSON_HEDLEY_GCC_HAS_WARNING
26653#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
26654#undef JSON_HEDLEY_GCC_VERSION
26655#undef JSON_HEDLEY_GCC_VERSION_CHECK
26656#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
26657#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
26658#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
26659#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
26660#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
26661#undef JSON_HEDLEY_GNUC_HAS_FEATURE
26662#undef JSON_HEDLEY_GNUC_HAS_WARNING
26663#undef JSON_HEDLEY_GNUC_VERSION
26664#undef JSON_HEDLEY_GNUC_VERSION_CHECK
26665#undef JSON_HEDLEY_HAS_ATTRIBUTE
26666#undef JSON_HEDLEY_HAS_BUILTIN
26667#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
26668#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
26669#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
26670#undef JSON_HEDLEY_HAS_EXTENSION
26671#undef JSON_HEDLEY_HAS_FEATURE
26672#undef JSON_HEDLEY_HAS_WARNING
26673#undef JSON_HEDLEY_IAR_VERSION
26674#undef JSON_HEDLEY_IAR_VERSION_CHECK
26675#undef JSON_HEDLEY_IBM_VERSION
26676#undef JSON_HEDLEY_IBM_VERSION_CHECK
26677#undef JSON_HEDLEY_IMPORT
26678#undef JSON_HEDLEY_INLINE
26679#undef JSON_HEDLEY_INTEL_CL_VERSION
26680#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
26681#undef JSON_HEDLEY_INTEL_VERSION
26682#undef JSON_HEDLEY_INTEL_VERSION_CHECK
26683#undef JSON_HEDLEY_IS_CONSTANT
26684#undef JSON_HEDLEY_IS_CONSTEXPR_
26685#undef JSON_HEDLEY_LIKELY
26686#undef JSON_HEDLEY_MALLOC
26687#undef JSON_HEDLEY_MCST_LCC_VERSION
26688#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
26689#undef JSON_HEDLEY_MESSAGE
26690#undef JSON_HEDLEY_MSVC_VERSION
26691#undef JSON_HEDLEY_MSVC_VERSION_CHECK
26692#undef JSON_HEDLEY_NEVER_INLINE
26693#undef JSON_HEDLEY_NON_NULL
26694#undef JSON_HEDLEY_NO_ESCAPE
26695#undef JSON_HEDLEY_NO_RETURN
26696#undef JSON_HEDLEY_NO_THROW
26697#undef JSON_HEDLEY_NULL
26698#undef JSON_HEDLEY_PELLES_VERSION
26699#undef JSON_HEDLEY_PELLES_VERSION_CHECK
26700#undef JSON_HEDLEY_PGI_VERSION
26701#undef JSON_HEDLEY_PGI_VERSION_CHECK
26702#undef JSON_HEDLEY_PREDICT
26703#undef JSON_HEDLEY_PRINTF_FORMAT
26704#undef JSON_HEDLEY_PRIVATE
26705#undef JSON_HEDLEY_PUBLIC
26706#undef JSON_HEDLEY_PURE
26707#undef JSON_HEDLEY_REINTERPRET_CAST
26708#undef JSON_HEDLEY_REQUIRE
26709#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
26710#undef JSON_HEDLEY_REQUIRE_MSG
26711#undef JSON_HEDLEY_RESTRICT
26713#undef JSON_HEDLEY_SENTINEL
26714#undef JSON_HEDLEY_STATIC_ASSERT
26715#undef JSON_HEDLEY_STATIC_CAST
26716#undef JSON_HEDLEY_STRINGIFY
26717#undef JSON_HEDLEY_STRINGIFY_EX
26718#undef JSON_HEDLEY_SUNPRO_VERSION
26719#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
26720#undef JSON_HEDLEY_TINYC_VERSION
26721#undef JSON_HEDLEY_TINYC_VERSION_CHECK
26722#undef JSON_HEDLEY_TI_ARMCL_VERSION
26723#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
26724#undef JSON_HEDLEY_TI_CL2000_VERSION
26725#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
26726#undef JSON_HEDLEY_TI_CL430_VERSION
26727#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
26728#undef JSON_HEDLEY_TI_CL6X_VERSION
26729#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
26730#undef JSON_HEDLEY_TI_CL7X_VERSION
26731#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
26732#undef JSON_HEDLEY_TI_CLPRU_VERSION
26733#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
26734#undef JSON_HEDLEY_TI_VERSION
26735#undef JSON_HEDLEY_TI_VERSION_CHECK
26736#undef JSON_HEDLEY_UNAVAILABLE
26737#undef JSON_HEDLEY_UNLIKELY
26738#undef JSON_HEDLEY_UNPREDICTABLE
26739#undef JSON_HEDLEY_UNREACHABLE
26740#undef JSON_HEDLEY_UNREACHABLE_RETURN
26741#undef JSON_HEDLEY_VERSION
26742#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
26743#undef JSON_HEDLEY_VERSION_DECODE_MINOR
26744#undef JSON_HEDLEY_VERSION_DECODE_REVISION
26745#undef JSON_HEDLEY_VERSION_ENCODE
26746#undef JSON_HEDLEY_WARNING
26749#undef JSON_HEDLEY_FALL_THROUGH
ValueType & get_to(ValueType &v) const
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
iteration_proxy< iterator > items() noexcept
helper to access iterator member functions in range-based for
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
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
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...
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
iterator begin() noexcept
returns an iterator to the first element
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
static std::vector< std::uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
basic_json(const JsonRef &ref)
static std::vector< std::uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
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
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
const binary_t & get_binary() const
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
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
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
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
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
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 std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
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.
basic_json(const basic_json &other)
copy constructor
~basic_json() noexcept
destructor
friend struct detail::external_constructor
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
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 iteration_proxy< iterator > iterator_wrapper(reference ref) noexcept
wrapper to access iterator member functions in range-based for
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
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
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 char * type_name() const noexcept
return the type as string
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
constexpr bool is_number() const noexcept
return whether value is a number
friend std::ostream & operator>>(const basic_json &j, std::ostream &o)
serialize to stream
std::less< StringType > object_comparator_t
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
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)
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)
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
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
json_pointer & operator/=(std::string token)
append an unescaped reference token at the end of this JSON pointer
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
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
const std::string & back() const
return 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(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
void push_back(std::string &&token)
append an unescaped token at the end of the reference pointer
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON 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
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin)
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
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
json_sax & operator=(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
ordered_map(std::initializer_list< T > init, const Allocator &alloc=Allocator())
std::vector< std::pair< const Key, T >, Allocator > Container
const T & at(const Key &key) const
iterator find(const Key &key)
iterator erase(iterator pos)
void insert(InputIt first, InputIt last)
std::pair< iterator, bool > insert(value_type &&value)
const_iterator find(const Key &key) const
size_type erase(const Key &key)
T & operator[](const Key &key)
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
ordered_map(It first, It last, const Allocator &alloc=Allocator())
std::pair< iterator, bool > insert(const value_type &value)
size_type count(const Key &key) const
std::pair< iterator, bool > emplace(const key_type &key, T &&t)
const T & operator[](const Key &key) const